using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using Characters;
using Characters.AI;
using Characters.AI.TwinSister;
using Characters.Abilities;
using Characters.Abilities.Customs;
using Characters.Abilities.Spirits;
using Characters.Actions;
using Characters.Cooldowns;
using Characters.Gear;
using Characters.Gear.Items;
using Characters.Gear.Quintessences;
using Characters.Gear.Synergy;
using Characters.Gear.Synergy.Inscriptions;
using Characters.Gear.Weapons;
using Characters.Gear.Weapons.Gauges;
using Characters.Operations;
using Characters.Operations.Attack;
using Characters.Operations.Fx;
using Characters.Operations.Gauge;
using Characters.Operations.Summon;
using Characters.Player;
using DCDefense;
using Data;
using FX;
using GameResources;
using HarmonyLib;
using Level;
using Level.Npc.FieldNpcs;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using Platforms;
using Platforms.Steam;
using Scenes;
using Services;
using Singletons;
using Steamworks;
using UI;
using UI.GearPopup;
using UI.Inventory;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.ResourceManagement.AsyncOperations;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: IgnoresAccessChecksTo("Plugins.Common")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class IsReadOnlyAttribute : Attribute
	{
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace ChzzkSkul
{
	public static class ChzzkCardSynergy
	{
		public static List<string> EnemiesAssetKeys = new List<string>();

		public static bool EnemiesKeysCached = false;

		private static int _cachedCardCount = 0;

		private static bool _cachedIsSuper = false;

		private static float _cacheExpireTime = 0f;

		private const float CACHE_DURATION = 0.3f;

		public static Character GetPlayer()
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Expected O, but got Unknown
			try
			{
				if ((Object)(object)Object.FindObjectOfType<Service>() == (Object)null)
				{
					return null;
				}
				Service instance = Singleton<Service>.Instance;
				object obj;
				if ((Object)(object)instance == (Object)null)
				{
					obj = null;
				}
				else
				{
					LevelManager levelManager = instance.levelManager;
					obj = (((Object)(object)levelManager != (Object)null) ? levelManager.player : null);
				}
				return (Character)obj;
			}
			catch
			{
				return null;
			}
		}

		public static Inscription TryGetCardInscription(Character player)
		{
			if ((Object)(object)player == (Object)null || player.playerComponents == null || player.playerComponents.inventory == null || (Object)(object)player.playerComponents.inventory.synergy == (Object)null)
			{
				return null;
			}
			try
			{
				EnumArray<Key, Inscription> inscriptions = player.playerComponents.inventory.synergy.inscriptions;
				if (inscriptions == null)
				{
					return null;
				}
				PropertyInfo property = ((object)inscriptions).GetType().GetProperty("Array");
				if (property != null && (!(property.GetValue(inscriptions) is Array array) || 37 >= array.Length))
				{
					return null;
				}
				return inscriptions[(Key)37];
			}
			catch
			{
				return null;
			}
		}

		private static void RefreshCache()
		{
			if (!(Time.time < _cacheExpireTime))
			{
				_cacheExpireTime = Time.time + 0.3f;
				Character player = GetPlayer();
				Inscription val = TryGetCardInscription(player);
				_cachedCardCount = val?.count ?? 0;
				_cachedIsSuper = val != null && val.isSuper;
			}
		}

		public static int GetCardCount(Item item = null)
		{
			if ((Object)(object)item != (Object)null && (Object)(object)((Component)item).gameObject != (Object)null)
			{
				string name = ((Object)((Component)item).gameObject).name;
				if (name.Contains("_E") || name.Contains("_RE"))
				{
					return 4;
				}
			}
			RefreshCache();
			return _cachedCardCount;
		}

		public static bool IsCardSynergySuper(Item item = null)
		{
			if ((Object)(object)item != (Object)null && (Object)(object)((Component)item).gameObject != (Object)null)
			{
				string name = ((Object)((Component)item).gameObject).name;
				if (name.Contains("_R") || name.Contains("_RE"))
				{
					return true;
				}
			}
			RefreshCache();
			return _cachedIsSuper;
		}

		public static void ShowFloatingText(string message)
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Expected O, but got Unknown
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			if (message.Contains("$CHAOS$"))
			{
				message = "무언가가 일어났습니다!";
			}
			try
			{
				Service instance = Singleton<Service>.Instance;
				object obj;
				if ((Object)(object)instance == (Object)null)
				{
					obj = null;
				}
				else
				{
					LevelManager levelManager = instance.levelManager;
					obj = (((Object)(object)levelManager != (Object)null) ? levelManager.player : null);
				}
				Character val = (Character)obj;
				if ((Object)val == (Object)null)
				{
					return;
				}
				Service instance2 = Singleton<Service>.Instance;
				if ((Object)(object)instance2 != (Object)null)
				{
					FloatingTextSpawner floatingTextSpawner = instance2.floatingTextSpawner;
					if ((Object)(object)floatingTextSpawner != (Object)null)
					{
						floatingTextSpawner.SpawnBuff(message, ((Component)val).transform.position + Vector3.up * 2f, "#FFD700");
					}
				}
			}
			catch
			{
			}
		}

		public static void InvalidateCache()
		{
			_cacheExpireTime = 0f;
		}
	}
	public static class ChzzkStatManager
	{
		public class StatData
		{
			public double percent = 0.0;

			public double percentPoint = 0.0;

			public double constant = 0.0;
		}

		[Serializable]
		public class SavedStatValue
		{
			public int categoryIndex;

			public int kindIndex;

			public double value;
		}

		[Serializable]
		public class SavedAbilityValue
		{
			public GlitchedTrigger trigger;

			public GlitchedAction action;

			public float value1;

			public float value2;

			public string effectDescription;
		}

		[Serializable]
		public class SavedGlitchedItem
		{
			public string originalName;

			public int slotIndex;

			public Rarity rarity;

			public Key keyword1;

			public Key keyword2;

			public List<SavedStatValue> stats = new List<SavedStatValue>();

			public List<SavedAbilityValue> abilities = new List<SavedAbilityValue>();

			public string glitchedName;

			public string glitchedDesc;

			public string glitchedFlavor;

			public string copiedItemName;

			public string extraCopiedItemName;
		}

		public class SaveWrapper
		{
			public bool ForceNextOmen;

			public bool ForceNextDarkEnemy;

			public bool IsBossRushActive;

			public bool IsScreenEffectActive;

			public string ScreenEffectType;

			public float ScreenEffectTimer;

			public bool IsNukeActive;

			public int NukeScenesPassed;

			public float NukeElapsed;

			public float BossRushElapsed;

			public List<string> CurrentVoteOptions = new List<string>();

			public Dictionary<int, StatData> SavedStats = new Dictionary<int, StatData>();

			public int SpawnedBossCount;

			public bool IsVoteCompletedInThisStage;

			public string StageName;

			public string VotedResultTitle;

			public List<string> CustomSuperInscriptions = new List<string>();

			public List<SavedGlitchedItem> SavedGlitchedItems = new List<SavedGlitchedItem>();

			public List<string> ExtraInventoryItems = new List<string>();

			public bool IsInventoryExpanded;
		}

		public static Dictionary<int, StatData> SavedStats = new Dictionary<int, StatData>();

		public static SaveWrapper SaveData = new SaveWrapper();

		private static string saveFilePath => Path.Combine(Application.persistentDataPath, "ChzzkSkul_SavedStats.json");

		public static event Action OnSave;

		public static event Action OnLoad;

		public static event Action OnClear;

		public static string GetOriginalItemName(string name)
		{
			if (string.IsNullOrEmpty(name))
			{
				return name;
			}
			if (name.StartsWith("Glitched-"))
			{
				int num = "Glitched-".Length - 1;
				int num2 = name.LastIndexOf('-');
				if (num2 > num)
				{
					return name.Substring(num + 1, num2 - num - 1);
				}
			}
			return name;
		}

		public static void Load()
		{
			try
			{
				if (!File.Exists(saveFilePath))
				{
					return;
				}
				string text = File.ReadAllText(saveFilePath);
				try
				{
					SaveWrapper saveWrapper = JsonConvert.DeserializeObject<SaveWrapper>(text);
					if (saveWrapper != null)
					{
						SaveData = saveWrapper;
						if (saveWrapper.SavedStats != null)
						{
							SavedStats = saveWrapper.SavedStats;
						}
						ChzzkStatManager.OnLoad?.Invoke();
					}
				}
				catch (Exception ex)
				{
					Debug.LogError((object)("[ChzzkStatManager] JSON Deserialize Error: " + ex.Message));
				}
			}
			catch (Exception ex2)
			{
				Debug.LogError((object)("[ChzzkStatManager] Load Error: " + ex2.Message));
			}
		}

		public static void Save()
		{
			try
			{
				SaveData.SavedStats = SavedStats;
				ChzzkStatManager.OnSave?.Invoke();
				string contents = JsonConvert.SerializeObject((object)SaveData, (Formatting)1);
				File.WriteAllText(saveFilePath, contents);
			}
			catch (Exception ex)
			{
				Debug.LogError((object)("[ChzzkStatManager] Save Error: " + ex.Message));
			}
		}

		public static int KindToInt(Kind kind)
		{
			if (kind == Kind.AttackDamage)
			{
				return 0;
			}
			if (kind == Kind.PhysicalAttackDamage)
			{
				return 1;
			}
			if (kind == Kind.MagicAttackDamage)
			{
				return 2;
			}
			if (kind == Kind.AttackSpeed)
			{
				return 3;
			}
			if (kind == Kind.MovementSpeed)
			{
				return 4;
			}
			if (kind == Kind.CriticalChance)
			{
				return 5;
			}
			if (kind == Kind.CriticalDamage)
			{
				return 6;
			}
			if (kind == Kind.Health)
			{
				return 7;
			}
			if (kind == Kind.TakingDamage)
			{
				return 8;
			}
			return -1;
		}

		public static Kind IntToKind(int id)
		{
			return (Kind)(id switch
			{
				0 => Kind.AttackDamage, 
				1 => Kind.PhysicalAttackDamage, 
				2 => Kind.MagicAttackDamage, 
				3 => Kind.AttackSpeed, 
				4 => Kind.MovementSpeed, 
				5 => Kind.CriticalChance, 
				6 => Kind.CriticalDamage, 
				7 => Kind.Health, 
				8 => Kind.TakingDamage, 
				_ => Kind.AttackDamage, 
			});
		}

		public static void AddStat(Character player, Category category, Kind kind, double value)
		{
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Expected O, but got Unknown
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Expected O, but got Unknown
			int num = KindToInt(kind);
			if (num != -1)
			{
				if (!SavedStats.ContainsKey(num))
				{
					SavedStats[num] = new StatData();
				}
				if (category == Category.Percent)
				{
					SavedStats[num].percent += value;
				}
				else if (category == Category.PercentPoint)
				{
					SavedStats[num].percentPoint += value;
				}
				else if (category == Category.Constant)
				{
					SavedStats[num].constant += value;
				}
				Save();
				if ((Object)(object)player != (Object)null && player.stat != null)
				{
					double num2 = ((category == Category.Percent) ? (1.0 + value) : value);
					player.stat.AttachValues(new Values((Value[])(object)new Value[1]
					{
						new Value(category, kind, num2)
					}));
				}
			}
		}

		public static void ApplyToPlayer(Character player)
		{
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Expected O, but got Unknown
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Expected O, but got Unknown
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Expected O, but got Unknown
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Expected O, but got Unknown
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Expected O, but got Unknown
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Expected O, but got Unknown
			if ((Object)(object)player == (Object)null || player.stat == null)
			{
				return;
			}
			foreach (KeyValuePair<int, StatData> savedStat in SavedStats)
			{
				Kind val = IntToKind(savedStat.Key);
				if (savedStat.Value.percent != 0.0)
				{
					player.stat.AttachValues(new Values((Value[])(object)new Value[1]
					{
						new Value(Category.Percent, val, 1.0 + savedStat.Value.percent)
					}));
				}
				if (savedStat.Value.percentPoint != 0.0)
				{
					player.stat.AttachValues(new Values((Value[])(object)new Value[1]
					{
						new Value(Category.PercentPoint, val, savedStat.Value.percentPoint)
					}));
				}
				if (savedStat.Value.constant != 0.0)
				{
					player.stat.AttachValues(new Values((Value[])(object)new Value[1]
					{
						new Value(Category.Constant, val, savedStat.Value.constant)
					}));
				}
			}
		}

		public static void Clear()
		{
			if (SavedStats.Count > 0)
			{
				SavedStats.Clear();
			}
			SaveData.IsInventoryExpanded = false;
			if (SaveData.ExtraInventoryItems != null)
			{
				SaveData.ExtraInventoryItems.Clear();
			}
			if (SaveData.SavedGlitchedItems != null)
			{
				SaveData.SavedGlitchedItems.Clear();
			}
			ChzzkStatManager.OnClear?.Invoke();
			Save();
			Debug.Log((object)"[ChzzkStatManager] Cleared saved stats because a new run started.");
		}
	}
	public sealed class VaseOfTheFallenAbilityComponent : AbilityComponent<VaseOfTheFallenAbility>, IStackable
	{
		public int currentKillCount { get; set; }

		public float stack
		{
			get
			{
				return currentKillCount;
			}
			set
			{
				currentKillCount = (int)value;
			}
		}

		public override void Initialize()
		{
			base.Initialize();
			base._ability.component = this;
		}
	}
	[Serializable]
	public class VaseOfTheFallenAbility : Ability, ICloneable
	{
		public class Instance : AbilityInstance<VaseOfTheFallenAbility>
		{
			private Values _stats;

			private float _currentRevengeCooldown;

			private float _revengeTimeRemaining = 1f;

			public bool _canRevenge = false;

			public bool _isCooldown = false;

			private int _lostStacks;

			public override float iconFillAmount => _isCooldown ? (1f - _currentRevengeCooldown / base.ability._revengeCooldown) : (1f - _revengeTimeRemaining / base.ability._revengeTimeout);

			public override int iconStacks => ((Object)(object)base.ability.component != (Object)null) ? base.ability.component.currentKillCount : 0;

			public override Sprite icon
			{
				get
				{
					if ((Object)(object)base.ability.component == (Object)null || base.ability.component.currentKillCount == 0)
					{
						return null;
					}
					return ((Ability)base.ability)._defaultIcon;
				}
			}

			public Instance(Character owner, VaseOfTheFallenAbility ability)
				: base(owner, ability)
			{
			}

			public override void OnAttach()
			{
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				//IL_0052: Expected O, but got Unknown
				//IL_0052: Unknown result type (might be due to invalid IL or missing references)
				//IL_005c: Expected O, but got Unknown
				//IL_0078: Unknown result type (might be due to invalid IL or missing references)
				//IL_0082: Expected O, but got Unknown
				_stats = base.ability._statPerStack.Clone();
				((AbilityInstance)this).owner.stat.AttachValues(_stats);
				RefreshStacks();
				Character owner = ((AbilityInstance)this).owner;
				owner.onKilled = (OnKilledDelegate)Delegate.Combine((Delegate?)(object)owner.onKilled, (Delegate?)new OnKilledDelegate(OnKilledEnemy));
				((Health)((AbilityInstance)this).owner.health).onTakeDamage.Add(-1000, new TakeDamageDelegate(OnTakeDamage));
			}

			public override void OnDetach()
			{
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Expected O, but got Unknown
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0028: Expected O, but got Unknown
				//IL_0056: Unknown result type (might be due to invalid IL or missing references)
				//IL_0060: Expected O, but got Unknown
				Character owner = ((AbilityInstance)this).owner;
				owner.onKilled = (OnKilledDelegate)Delegate.Remove((Delegate?)(object)owner.onKilled, (Delegate?)new OnKilledDelegate(OnKilledEnemy));
				((AbilityInstance)this).owner.stat.DetachValues(_stats);
				((Health)((AbilityInstance)this).owner.health).onTakeDamage.Remove(new TakeDamageDelegate(OnTakeDamage));
			}

			private void OnKilledEnemy(ITarget target, ref Damage damage)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: Invalid comparison between Unknown and I4
				if ((int)target.character.type != 7 && (Object)(object)base.ability.component != (Object)null)
				{
					int currentKillCount = base.ability.component.currentKillCount;
					base.ability.component.currentKillCount = Math.Min(currentKillCount + 1, base.ability._maxStack);
					RefreshStacks();
				}
			}

			private unsafe bool OnTakeDamage(ref Damage damage)
			{
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
				//IL_0103: Expected O, but got Unknown
				if (((AbilityInstance)this).owner.invulnerable.value)
				{
					return false;
				}
				AttackType attackType = damage.attackType;
				if (((object)(*(AttackType*)(&attackType))/*cast due to .constrained prefix*/).Equals((object)(AttackType)0))
				{
					return false;
				}
				if (damage.@null)
				{
					return false;
				}
				if (((Damage)(ref damage)).amount < 1.0)
				{
					return false;
				}
				if ((Object)(object)base.ability.component != (Object)null)
				{
					int currentKillCount = base.ability.component.currentKillCount;
					_lostStacks = currentKillCount / 2;
					base.ability.component.currentKillCount /= 2;
					RefreshStacks();
					_canRevenge = true;
					_revengeTimeRemaining = base.ability._revengeTimeout;
					((PriorityList<GiveDamageDelegate>)(object)((AbilityInstance)this).owner.onGiveDamage).Add(int.MaxValue, new GiveDamageDelegate(OnRevenge));
				}
				return false;
			}

			private bool OnRevenge(ITarget target, ref Damage damage)
			{
				//IL_005a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0064: Expected O, but got Unknown
				if (damage.@null)
				{
					return false;
				}
				if (((Damage)(ref damage)).amount < 1.0)
				{
					return false;
				}
				_canRevenge = false;
				_revengeTimeRemaining = base.ability._revengeTimeout;
				((PriorityList<GiveDamageDelegate>)(object)((AbilityInstance)this).owner.onGiveDamage).Remove(new GiveDamageDelegate(OnRevenge));
				if (_isCooldown)
				{
					return false;
				}
				if ((Object)(object)base.ability.component != (Object)null)
				{
					base.ability.component.currentKillCount += _lostStacks / 2;
				}
				_isCooldown = true;
				_currentRevengeCooldown = 0f;
				return false;
			}

			public override void UpdateTime(float deltaTime)
			{
				//IL_005f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0069: Expected O, but got Unknown
				((AbilityInstance)this).UpdateTime(deltaTime);
				if (_canRevenge)
				{
					_revengeTimeRemaining -= deltaTime;
				}
				if (_revengeTimeRemaining < 0f)
				{
					_revengeTimeRemaining = base.ability._revengeTimeout;
					_canRevenge = false;
					((PriorityList<GiveDamageDelegate>)(object)((AbilityInstance)this).owner.onGiveDamage).Remove(new GiveDamageDelegate(OnRevenge));
				}
				if (_isCooldown)
				{
					_currentRevengeCooldown += deltaTime;
				}
				if (_currentRevengeCooldown > base.ability._revengeCooldown)
				{
					_currentRevengeCooldown = 0f;
					_isCooldown = false;
				}
			}

			private void RefreshStacks()
			{
				if (!((Object)(object)base.ability.component == (Object)null))
				{
					int currentKillCount = base.ability.component.currentKillCount;
					for (int i = 0; i < ((ReorderableArray<Value>)(object)_stats).values.Length; i++)
					{
						((ReorderableArray<Value>)(object)_stats).values[i].value = ((ReorderableArray<Value>)(object)base.ability._statPerStack).values[i].GetStackedValue((double)currentKillCount);
					}
					((AbilityInstance)this).owner.stat.SetNeedUpdate();
				}
			}
		}

		[SerializeField]
		internal float _revengeTimeout = 1f;

		[SerializeField]
		internal float _revengeCooldown = 1f;

		[SerializeField]
		internal int _maxStack = 1;

		[SerializeField]
		internal Values _statPerStack;

		public VaseOfTheFallenAbilityComponent component { get; set; }

		public override IAbilityInstance CreateInstance(Character owner)
		{
			return (IAbilityInstance)(object)new Instance(owner, this);
		}

		public object Clone()
		{
			return new VaseOfTheFallenAbility
			{
				_revengeTimeout = _revengeTimeout,
				_revengeCooldown = _revengeCooldown,
				_maxStack = _maxStack,
				_statPerStack = _statPerStack.Clone(),
				_defaultIcon = base._defaultIcon
			};
		}
	}
	public sealed class CorruptedSymbolAbilityComponent : AbilityComponent<CorruptedSymbolAbility>
	{
		public override void Initialize()
		{
			base.Initialize();
		}
	}
	[Serializable]
	public class CorruptedSymbolAbility : Ability, ICloneable
	{
		public class Instance : AbilityInstance<CorruptedSymbolAbility>
		{
			private Values _stats;

			private EnumArray<Key, Inscription> _inscriptions;

			private Inventory _inventory;

			public override int iconStacks => SpoilsInscriptionCount();

			public int SpoilsInscriptionCount()
			{
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Invalid comparison between Unknown and I4
				foreach (Inscription inscription in _inscriptions)
				{
					if ((int)inscription.key == 21)
					{
						return inscription.count;
					}
				}
				return 0;
			}

			public Instance(Character owner, CorruptedSymbolAbility ability)
				: base(owner, ability)
			{
				_inventory = owner.playerComponents.inventory;
				_inscriptions = owner.playerComponents.inventory.synergy.inscriptions;
			}

			public override void OnAttach()
			{
				_stats = base.ability._statPerStack.Clone();
				((AbilityInstance)this).owner.stat.AttachValues(_stats);
				RefreshSpoilsInscriptionCount();
				_inventory.onUpdatedKeywordCounts += RefreshSpoilsInscriptionCount;
			}

			public override void OnDetach()
			{
				((AbilityInstance)this).owner.stat.DetachValues(_stats);
				_inventory.onUpdatedKeywordCounts -= RefreshSpoilsInscriptionCount;
			}

			private void RefreshSpoilsInscriptionCount()
			{
				for (int i = 0; i < ((ReorderableArray<Value>)(object)_stats).values.Length; i++)
				{
					((ReorderableArray<Value>)(object)_stats).values[i].value = ((ReorderableArray<Value>)(object)base.ability._statPerStack).values[i].GetStackedValue((double)SpoilsInscriptionCount());
				}
				((AbilityInstance)this).owner.stat.SetNeedUpdate();
			}
		}

		[SerializeField]
		internal Values _statPerStack;

		public override IAbilityInstance CreateInstance(Character owner)
		{
			return (IAbilityInstance)(object)new Instance(owner, this);
		}

		public object Clone()
		{
			return new CorruptedSymbolAbility
			{
				_statPerStack = _statPerStack.Clone(),
				_defaultIcon = base._defaultIcon
			};
		}
	}
	public sealed class GodLittleBoneAbilityComponent : AbilityComponent<GodLittleBoneAbility>
	{
		public override void Initialize()
		{
			base.Initialize();
		}
	}
	[Serializable]
	public class GodLittleBoneAbility : Ability, ICloneable
	{
		public class Instance : AbilityInstance<GodLittleBoneAbility>
		{
			public Instance(Character owner, GodLittleBoneAbility ability)
				: base(owner, ability)
			{
			}

			public override void OnAttach()
			{
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				//IL_001f: Expected O, but got Unknown
				((PriorityList<GiveDamageDelegate>)(object)((AbilityInstance)this).owner.onGiveDamage).Add(100, new GiveDamageDelegate(OnGiveDamage));
			}

			public override void OnDetach()
			{
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Expected O, but got Unknown
				((PriorityList<GiveDamageDelegate>)(object)((AbilityInstance)this).owner.onGiveDamage).Remove(new GiveDamageDelegate(OnGiveDamage));
			}

			private bool OnGiveDamage(ITarget target, ref Damage damage)
			{
				if (damage.@null || ((Damage)(ref damage)).amount < 1.0)
				{
					return false;
				}
				damage.multiplier *= 1.5;
				return false;
			}
		}

		public override IAbilityInstance CreateInstance(Character owner)
		{
			return (IAbilityInstance)(object)new Instance(owner, this);
		}

		public object Clone()
		{
			return new GodLittleBoneAbility
			{
				_defaultIcon = base._defaultIcon
			};
		}
	}
	public sealed class StreamerHealAbilityComponent : AbilityComponent<StreamerHealAbility>
	{
		public override void Initialize()
		{
			base.Initialize();
		}
	}
	[Serializable]
	public class StreamerHealAbility : Ability, ICloneable
	{
		public class Instance : AbilityInstance<StreamerHealAbility>
		{
			private float _elapsed = 0f;

			public Instance(Character owner, StreamerHealAbility ability)
				: base(owner, ability)
			{
			}

			public override void OnAttach()
			{
			}

			public override void OnDetach()
			{
			}

			public override void UpdateTime(float deltaTime)
			{
				((AbilityInstance)this).UpdateTime(deltaTime);
				_elapsed += deltaTime;
				if (_elapsed >= 3f)
				{
					_elapsed -= 3f;
					((Health)((AbilityInstance)this).owner.health).Heal(1.0, true);
				}
			}
		}

		public override IAbilityInstance CreateInstance(Character owner)
		{
			return (IAbilityInstance)(object)new Instance(owner, this);
		}

		public object Clone()
		{
			return new StreamerHealAbility
			{
				_defaultIcon = base._defaultIcon
			};
		}
	}
	public enum GlitchedTrigger
	{
		OnAttack,
		OnSkill,
		OnHit,
		OnDash,
		OnSwap,
		OnPeriodic,
		OnKill,
		OnPassive
	}
	public enum GlitchedAction
	{
		AddDamage,
		Shield,
		Heal,
		StatBoost,
		SpawnGold,
		SpawnBone,
		Explosion,
		SelfExplosion,
		StatDebuff,
		LoseGold,
		CastRandomSkill,
		UseRandomQuintessence,
		SpawnEnemy,
		SpawnItem,
		Freeze,
		Teleport,
		SpawnTemporarySpirit,
		PassiveBonusDamage,
		PassiveSummonSpirit,
		PassiveStatBoost,
		PassiveCopyItem,
		None
	}
	public sealed class TMTrainerAbilityComponent : AbilityComponent<TMTrainerAbility>
	{
		public override void Initialize()
		{
			base.Initialize();
		}
	}
	[Serializable]
	public class TMTrainerAbility : Ability, ICloneable
	{
		public class Instance : AbilityInstance<TMTrainerAbility>
		{
			private float _cooldownTimer = 0f;

			private float _periodicTimer = 0f;

			private Random _rnd = new Random();

			private List<Spirit> _summonedSpirits = new List<Spirit>();

			private Values _passiveStats;

			private static readonly string[] SpiritItemNames = new string[6] { "UndineWaterSpirit", "SalamanderFireSpirit", "GnomeEarthSpirit", "SylphidWindSpirit", "LughLightSpirit", "DeathShadowSpirit" };

			private static readonly FieldInfo damageKeyField = typeof(Damage).GetField("key", BindingFlags.Instance | BindingFlags.Public);

			public Instance(Character owner, TMTrainerAbility ability)
				: base(owner, ability)
			{
			}

			public override void OnAttach()
			{
				//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
				//IL_01be: Expected O, but got Unknown
				//IL_01da: Unknown result type (might be due to invalid IL or missing references)
				//IL_01e4: Expected O, but got Unknown
				//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
				//IL_0204: Expected O, but got Unknown
				//IL_0204: Unknown result type (might be due to invalid IL or missing references)
				//IL_020e: Expected O, but got Unknown
				//IL_008a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0094: Expected O, but got Unknown
				//IL_0129: Unknown result type (might be due to invalid IL or missing references)
				//IL_012f: Expected O, but got Unknown
				//IL_012f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0139: Expected O, but got Unknown
				if (base.ability.trigger == GlitchedTrigger.OnPassive)
				{
					if (base.ability.action == GlitchedAction.PassiveSummonSpirit)
					{
						string spiritItemName = SpiritItemNames[_rnd.Next(SpiritItemNames.Length)];
						((MonoBehaviour)((AbilityInstance)this).owner).StartCoroutine(C_SummonSpirit(spiritItemName));
					}
					else if (base.ability.action == GlitchedAction.PassiveBonusDamage)
					{
						((PriorityList<GiveDamageDelegate>)(object)((AbilityInstance)this).owner.onGiveDamage).Add(100, new GiveDamageDelegate(OnGiveDamageForPassiveBonus));
					}
					else if (base.ability.action == GlitchedAction.PassiveStatBoost)
					{
						int num = (int)base.ability.value2;
						Kind val = Kind.AttackSpeed;
						switch (num)
						{
						case 1:
							val = Kind.PhysicalAttackDamage;
							break;
						case 2:
							val = Kind.MagicAttackDamage;
							break;
						case 3:
							val = Kind.MovementSpeed;
							break;
						}
						_passiveStats = new Values((Value[])(object)new Value[1]
						{
							new Value(Category.PercentPoint, val, (double)base.ability.value1 / 100.0)
						});
						((AbilityInstance)this).owner.stat.AttachValues(_passiveStats);
						((AbilityInstance)this).owner.stat.SetNeedUpdate();
					}
				}
				else
				{
					switch (base.ability.trigger)
					{
					case GlitchedTrigger.OnAttack:
						((PriorityList<GiveDamageDelegate>)(object)((AbilityInstance)this).owner.onGiveDamage).Add(100, new GiveDamageDelegate(OnGiveDamageForAttack));
						break;
					case GlitchedTrigger.OnHit:
						((Health)((AbilityInstance)this).owner.health).onTakeDamage.Add(-100, new TakeDamageDelegate(OnTakeDamageForHit));
						break;
					case GlitchedTrigger.OnKill:
					{
						Character owner = ((AbilityInstance)this).owner;
						owner.onKilled = (OnKilledDelegate)Delegate.Combine((Delegate?)(object)owner.onKilled, (Delegate?)new OnKilledDelegate(OnKilled));
						break;
					}
					case GlitchedTrigger.OnSkill:
					case GlitchedTrigger.OnDash:
					case GlitchedTrigger.OnSwap:
						((AbilityInstance)this).owner.onStartAction += OnStartAction;
						break;
					case GlitchedTrigger.OnPeriodic:
						break;
					}
				}
			}

			public override void OnDetach()
			{
				//IL_013a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0144: Expected O, but got Unknown
				//IL_015e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0168: Expected O, but got Unknown
				//IL_017e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0188: Expected O, but got Unknown
				//IL_0188: Unknown result type (might be due to invalid IL or missing references)
				//IL_0192: Expected O, but got Unknown
				//IL_00de: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e8: Expected O, but got Unknown
				foreach (Spirit summonedSpirit in _summonedSpirits)
				{
					if ((Object)(object)summonedSpirit != (Object)null && (Object)(object)((Component)summonedSpirit).gameObject != (Object)null)
					{
						Object.Destroy((Object)(object)((Component)summonedSpirit).gameObject);
					}
				}
				_summonedSpirits.Clear();
				if (_passiveStats != null)
				{
					((AbilityInstance)this).owner.stat.DetachValues(_passiveStats);
					((AbilityInstance)this).owner.stat.SetNeedUpdate();
				}
				if (base.ability.trigger == GlitchedTrigger.OnPassive)
				{
					if (base.ability.action == GlitchedAction.PassiveBonusDamage)
					{
						((PriorityList<GiveDamageDelegate>)(object)((AbilityInstance)this).owner.onGiveDamage).Remove(new GiveDamageDelegate(OnGiveDamageForPassiveBonus));
					}
					return;
				}
				switch (base.ability.trigger)
				{
				case GlitchedTrigger.OnAttack:
					((PriorityList<GiveDamageDelegate>)(object)((AbilityInstance)this).owner.onGiveDamage).Remove(new GiveDamageDelegate(OnGiveDamageForAttack));
					break;
				case GlitchedTrigger.OnHit:
					((Health)((AbilityInstance)this).owner.health).onTakeDamage.Remove(new TakeDamageDelegate(OnTakeDamageForHit));
					break;
				case GlitchedTrigger.OnKill:
				{
					Character owner = ((AbilityInstance)this).owner;
					owner.onKilled = (OnKilledDelegate)Delegate.Remove((Delegate?)(object)owner.onKilled, (Delegate?)new OnKilledDelegate(OnKilled));
					break;
				}
				case GlitchedTrigger.OnSkill:
				case GlitchedTrigger.OnDash:
				case GlitchedTrigger.OnSwap:
					((AbilityInstance)this).owner.onStartAction -= OnStartAction;
					break;
				case GlitchedTrigger.OnPeriodic:
					break;
				}
			}

			public override void UpdateTime(float deltaTime)
			{
				((AbilityInstance)this).UpdateTime(deltaTime);
				if (base.ability.trigger == GlitchedTrigger.OnPeriodic)
				{
					_periodicTimer += deltaTime;
					if (_periodicTimer >= base.ability.value2)
					{
						_periodicTimer = 0f;
						TriggerAction(null);
					}
				}
			}

			private bool OnGiveDamageForAttack(ITarget target, ref Damage damage)
			{
				if (base.ability.trigger == GlitchedTrigger.OnAttack)
				{
					if (damage.key == "GlitchedPassiveBonus")
					{
						return false;
					}
					TriggerAction(target);
				}
				return false;
			}

			private bool OnTakeDamageForHit(ref Damage damage)
			{
				if (base.ability.trigger == GlitchedTrigger.OnHit)
				{
					TriggerAction(null);
				}
				return false;
			}

			private void OnKilled(ITarget target, ref Damage damage)
			{
				if (base.ability.trigger == GlitchedTrigger.OnKill)
				{
					TriggerAction(target);
				}
			}

			private void OnStartAction(Action action)
			{
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0025: Invalid comparison between Unknown and I4
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_0047: Invalid comparison between Unknown and I4
				//IL_0063: Unknown result type (might be due to invalid IL or missing references)
				//IL_0069: Invalid comparison between Unknown and I4
				if (!((Object)(object)action == (Object)null))
				{
					bool flag = false;
					if (base.ability.trigger == GlitchedTrigger.OnSkill && (int)action.type == 4)
					{
						flag = true;
					}
					else if (base.ability.trigger == GlitchedTrigger.OnDash && (int)action.type == 0)
					{
						flag = true;
					}
					else if (base.ability.trigger == GlitchedTrigger.OnSwap && (int)action.type == 5)
					{
						flag = true;
					}
					if (flag)
					{
						TriggerAction(null);
					}
				}
			}

			private void TriggerAction(ITarget target)
			{
				//IL_0070: Unknown result type (might be due to invalid IL or missing references)
				//IL_0075: Unknown result type (might be due to invalid IL or missing references)
				//IL_0093: Unknown result type (might be due to invalid IL or missing references)
				//IL_0098: Unknown result type (might be due to invalid IL or missing references)
				//IL_05fd: Unknown result type (might be due to invalid IL or missing references)
				//IL_05fe: Unknown result type (might be due to invalid IL or missing references)
				//IL_0742: Unknown result type (might be due to invalid IL or missing references)
				//IL_0743: Unknown result type (might be due to invalid IL or missing references)
				//IL_0b17: Unknown result type (might be due to invalid IL or missing references)
				//IL_0b18: Unknown result type (might be due to invalid IL or missing references)
				//IL_0225: Unknown result type (might be due to invalid IL or missing references)
				//IL_0226: Unknown result type (might be due to invalid IL or missing references)
				//IL_0178: Unknown result type (might be due to invalid IL or missing references)
				//IL_018a: Unknown result type (might be due to invalid IL or missing references)
				//IL_018f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0543: Unknown result type (might be due to invalid IL or missing references)
				//IL_0548: Unknown result type (might be due to invalid IL or missing references)
				//IL_0552: Unknown result type (might be due to invalid IL or missing references)
				//IL_0557: Unknown result type (might be due to invalid IL or missing references)
				//IL_05c0: Unknown result type (might be due to invalid IL or missing references)
				//IL_05c5: Unknown result type (might be due to invalid IL or missing references)
				//IL_05cf: Unknown result type (might be due to invalid IL or missing references)
				//IL_05d4: Unknown result type (might be due to invalid IL or missing references)
				//IL_064c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0652: Invalid comparison between Unknown and I4
				//IL_0791: Unknown result type (might be due to invalid IL or missing references)
				//IL_0797: Invalid comparison between Unknown and I4
				//IL_0b66: Unknown result type (might be due to invalid IL or missing references)
				//IL_0b6c: Invalid comparison between Unknown and I4
				//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
				//IL_0208: Unknown result type (might be due to invalid IL or missing references)
				//IL_020d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0656: Unknown result type (might be due to invalid IL or missing references)
				//IL_065c: Invalid comparison between Unknown and I4
				//IL_079b: Unknown result type (might be due to invalid IL or missing references)
				//IL_07a1: Invalid comparison between Unknown and I4
				//IL_08aa: Unknown result type (might be due to invalid IL or missing references)
				//IL_08bc: Unknown result type (might be due to invalid IL or missing references)
				//IL_08c1: Unknown result type (might be due to invalid IL or missing references)
				//IL_0b70: Unknown result type (might be due to invalid IL or missing references)
				//IL_0b76: Invalid comparison between Unknown and I4
				//IL_0691: Unknown result type (might be due to invalid IL or missing references)
				//IL_069f: Unknown result type (might be due to invalid IL or missing references)
				//IL_06a4: Unknown result type (might be due to invalid IL or missing references)
				//IL_07d6: Unknown result type (might be due to invalid IL or missing references)
				//IL_07e4: Unknown result type (might be due to invalid IL or missing references)
				//IL_07e9: Unknown result type (might be due to invalid IL or missing references)
				//IL_0274: Unknown result type (might be due to invalid IL or missing references)
				//IL_027a: Invalid comparison between Unknown and I4
				//IL_027e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0284: Invalid comparison between Unknown and I4
				//IL_02b9: Unknown result type (might be due to invalid IL or missing references)
				//IL_02c7: Unknown result type (might be due to invalid IL or missing references)
				//IL_02cc: Unknown result type (might be due to invalid IL or missing references)
				//IL_0328: Unknown result type (might be due to invalid IL or missing references)
				//IL_0345: Unknown result type (might be due to invalid IL or missing references)
				//IL_034a: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)((AbilityInstance)this).owner == (Object)null || (Object)(object)((Component)((AbilityInstance)this).owner).gameObject == (Object)null || (Object)(object)((Component)((AbilityInstance)this).owner).transform == (Object)null || (Object)(object)((AbilityInstance)this).owner.health == (Object)null || ((Health)((AbilityInstance)this).owner.health).dead)
				{
					return;
				}
				Vector3 position = ((Component)((AbilityInstance)this).owner).transform.position;
				if (target != null && (Object)(object)target.transform != (Object)null)
				{
					position = target.transform.position;
				}
				switch (base.ability.action)
				{
				case GlitchedAction.AddDamage:
				{
					double num9 = base.ability.value1;
					bool flag2 = _rnd.Next(2) == 0;
					if (target != null && (Object)(object)target.character != (Object)null && (Object)(object)((Component)target.character).transform != (Object)null && (Object)(object)target.character.health != (Object)null && !((Health)target.character.health).dead)
					{
						Damage val9 = default(Damage);
						((Damage)(ref val9))..ctor(Attacker.op_Implicit(((AbilityInstance)this).owner), num9, Vector2.op_Implicit(((Component)target.character).transform.position), (Attribute)(!flag2), (AttackType)4, (MotionType)0, 1.0, 0f, 0.0, 1.0, 1.0, true, false, 0.0, 0.0, (short)0, (PriorityList<bool>)null, 1.0);
						object obj5 = val9;
						damageKeyField.SetValue(obj5, "GlitchedPassiveBonus");
						val9 = (Damage)obj5;
						((AbilityInstance)this).owner.Attack(target, ref val9);
						break;
					}
					Collider2D[] array7 = Physics2D.OverlapCircleAll(Vector2.op_Implicit(position), 5f);
					Collider2D[] array8 = array7;
					Damage val11 = default(Damage);
					foreach (Collider2D val10 in array8)
					{
						if (!((Object)(object)val10 == (Object)null))
						{
							Character componentInParent4 = ((Component)val10).GetComponentInParent<Character>();
							if ((Object)(object)componentInParent4 != (Object)null && (int)componentInParent4.type != 6 && (int)componentInParent4.type != 7 && (Object)(object)componentInParent4.health != (Object)null && !((Health)componentInParent4.health).dead)
							{
								((Damage)(ref val11))..ctor(Attacker.op_Implicit(((AbilityInstance)this).owner), num9, Vector2.op_Implicit(((Component)componentInParent4).transform.position), (Attribute)(!flag2), (AttackType)4, (MotionType)0, 1.0, 0f, 0.0, 1.0, 1.0, true, false, 0.0, 0.0, (short)0, (PriorityList<bool>)null, 1.0);
								object obj6 = val11;
								damageKeyField.SetValue(obj6, "GlitchedPassiveBonus");
								val11 = (Damage)obj6;
								((AbilityInstance)this).owner.Attack(componentInParent4, ref val11);
							}
						}
					}
					break;
				}
				case GlitchedAction.Shield:
				{
					double num7 = base.ability.value1;
					try
					{
						FieldInfo field = ((object)((AbilityInstance)this).owner.health).GetType().GetField("shield", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
						if (field != null)
						{
							object value = field.GetValue(((AbilityInstance)this).owner.health);
							if (value != null)
							{
								(value.GetType().GetMethod("Add", new Type[2]
								{
									typeof(Object),
									typeof(double)
								}) ?? value.GetType().GetMethod("Add", new Type[2]
								{
									typeof(object),
									typeof(double)
								}))?.Invoke(value, new object[2]
								{
									((AbilityInstance)this).owner,
									num7
								});
							}
						}
						break;
					}
					catch
					{
						break;
					}
				}
				case GlitchedAction.Heal:
				{
					double num6 = base.ability.value1;
					((Health)((AbilityInstance)this).owner.health).Heal(num6, true);
					break;
				}
				case GlitchedAction.StatBoost:
				{
					bool attackSpeed2 = _rnd.Next(2) == 0;
					double amount2 = (double)base.ability.value1 / 100.0;
					((MonoBehaviour)((AbilityInstance)this).owner).StartCoroutine(C_TriggerStatBoost(attackSpeed2, amount2, base.ability.value2));
					break;
				}
				case GlitchedAction.SpawnGold:
				{
					int num5 = (int)base.ability.value1;
					try
					{
						Service instance2 = Singleton<Service>.Instance;
						if ((Object)(object)instance2 != (Object)null && (Object)(object)instance2.levelManager != (Object)null)
						{
							instance2.levelManager.DropCurrency((Type)0, num5, 10, ((Component)((AbilityInstance)this).owner).transform.position + Vector3.up * 1.5f);
						}
						break;
					}
					catch
					{
						break;
					}
				}
				case GlitchedAction.SpawnBone:
				{
					int num4 = (int)base.ability.value1;
					try
					{
						Service instance = Singleton<Service>.Instance;
						if ((Object)(object)instance != (Object)null && (Object)(object)instance.levelManager != (Object)null)
						{
							instance.levelManager.DropCurrency((Type)2, num4, num4, ((Component)((AbilityInstance)this).owner).transform.position + Vector3.up * 1.5f);
						}
						break;
					}
					catch
					{
						break;
					}
				}
				case GlitchedAction.Explosion:
				{
					double num8 = base.ability.value1;
					Collider2D[] array5 = Physics2D.OverlapCircleAll(Vector2.op_Implicit(position), 7f);
					Collider2D[] array6 = array5;
					Damage val8 = default(Damage);
					foreach (Collider2D val7 in array6)
					{
						if (!((Object)(object)val7 == (Object)null))
						{
							Character componentInParent3 = ((Component)val7).GetComponentInParent<Character>();
							if ((Object)(object)componentInParent3 != (Object)null && (int)componentInParent3.type != 6 && (int)componentInParent3.type != 7 && (Object)(object)componentInParent3.health != (Object)null && !((Health)componentInParent3.health).dead)
							{
								((Damage)(ref val8))..ctor(Attacker.op_Implicit(((AbilityInstance)this).owner), num8, Vector2.op_Implicit(((Component)componentInParent3).transform.position), (Attribute)2, (AttackType)4, (MotionType)0, 1.0, 0f, 0.0, 1.0, 1.0, true, false, 0.0, 0.0, (short)0, (PriorityList<bool>)null, 1.0);
								((AbilityInstance)this).owner.Attack(componentInParent3, ref val8);
							}
						}
					}
					break;
				}
				case GlitchedAction.SelfExplosion:
				{
					double num2 = base.ability.value1;
					double num3 = _rnd.Next(3, 11);
					Collider2D[] array3 = Physics2D.OverlapCircleAll(Vector2.op_Implicit(position), 8f);
					Collider2D[] array4 = array3;
					Damage val5 = default(Damage);
					foreach (Collider2D val4 in array4)
					{
						if (!((Object)(object)val4 == (Object)null))
						{
							Character componentInParent2 = ((Component)val4).GetComponentInParent<Character>();
							if ((Object)(object)componentInParent2 != (Object)null && (int)componentInParent2.type != 6 && (int)componentInParent2.type != 7 && (Object)(object)componentInParent2.health != (Object)null && !((Health)componentInParent2.health).dead)
							{
								((Damage)(ref val5))..ctor(Attacker.op_Implicit(((AbilityInstance)this).owner), num2, Vector2.op_Implicit(((Component)componentInParent2).transform.position), (Attribute)2, (AttackType)4, (MotionType)0, 1.0, 0f, 0.0, 1.0, 1.0, true, false, 0.0, 0.0, (short)0, (PriorityList<bool>)null, 1.0);
								((AbilityInstance)this).owner.Attack(componentInParent2, ref val5);
							}
						}
					}
					if ((Object)(object)((AbilityInstance)this).owner != (Object)null && (Object)(object)((AbilityInstance)this).owner.health != (Object)null && !((Health)((AbilityInstance)this).owner.health).dead)
					{
						Damage val6 = default(Damage);
						((Damage)(ref val6))..ctor(Attacker.op_Implicit(((AbilityInstance)this).owner), num3, Vector2.op_Implicit(((Component)((AbilityInstance)this).owner).transform.position), (Attribute)2, (AttackType)4, (MotionType)0, 1.0, 0f, 0.0, 1.0, 1.0, true, false, 0.0, 0.0, (short)0, (PriorityList<bool>)null, 1.0);
						((Health)((AbilityInstance)this).owner.health).TakeDamage(ref val6);
					}
					break;
				}
				case GlitchedAction.StatDebuff:
				{
					bool attackSpeed = _rnd.Next(2) == 0;
					double amount = (double)(0f - base.ability.value1) / 100.0;
					((MonoBehaviour)((AbilityInstance)this).owner).StartCoroutine(C_TriggerStatBoost(attackSpeed, amount, base.ability.value2));
					break;
				}
				case GlitchedAction.LoseGold:
				{
					int val2 = (int)base.ability.value1;
					try
					{
						int num = Math.Min(val2, Currency.gold.balance);
						if (num > 0)
						{
							Currency.gold.Consume(num);
						}
						break;
					}
					catch
					{
						break;
					}
				}
				case GlitchedAction.CastRandomSkill:
				{
					if (((AbilityInstance)this).owner.playerComponents == null || ((AbilityInstance)this).owner.playerComponents.inventory == null || !((Object)(object)((AbilityInstance)this).owner.playerComponents.inventory.weapon != (Object)null))
					{
						break;
					}
					Weapon current = ((AbilityInstance)this).owner.playerComponents.inventory.weapon.current;
					if ((Object)(object)current != (Object)null && current.currentSkills != null && current.currentSkills.Count > 0)
					{
						SkillInfo val3 = current.currentSkills[_rnd.Next(current.currentSkills.Count)];
						if ((Object)(object)val3 != (Object)null && (Object)(object)val3.action != (Object)null)
						{
							val3.action.TryStart();
						}
					}
					break;
				}
				case GlitchedAction.UseRandomQuintessence:
					((MonoBehaviour)((AbilityInstance)this).owner).StartCoroutine(C_UseRandomQuintessence(((AbilityInstance)this).owner));
					break;
				case GlitchedAction.SpawnEnemy:
					((MonoBehaviour)((AbilityInstance)this).owner).StartCoroutine(C_SpawnRandomEnemy(((AbilityInstance)this).owner));
					break;
				case GlitchedAction.SpawnItem:
					((MonoBehaviour)((AbilityInstance)this).owner).StartCoroutine(C_SpawnRandomItem(((AbilityInstance)this).owner));
					break;
				case GlitchedAction.Freeze:
				{
					Collider2D[] array = Physics2D.OverlapCircleAll(Vector2.op_Implicit(position), 8f);
					bool flag = false;
					Collider2D[] array2 = array;
					foreach (Collider2D val in array2)
					{
						if (!((Object)(object)val == (Object)null))
						{
							Character componentInParent = ((Component)val).GetComponentInParent<Character>();
							if ((Object)(object)componentInParent != (Object)null && (int)componentInParent.type != 6 && (int)componentInParent.type != 7 && (Object)(object)componentInParent.health != (Object)null && !((Health)componentInParent.health).dead && (Object)(object)componentInParent.status != (Object)null)
							{
								componentInParent.status.ApplyFreeze(((AbilityInstance)this).owner);
								flag = true;
							}
						}
					}
					if (!flag)
					{
					}
					break;
				}
				case GlitchedAction.Teleport:
					break;
				case GlitchedAction.SpawnTemporarySpirit:
				{
					string spiritItemName = SpiritItemNames[_rnd.Next(SpiritItemNames.Length)];
					((MonoBehaviour)((AbilityInstance)this).owner).StartCoroutine(C_SummonSpirit(spiritItemName, base.ability.value1));
					break;
				}
				}
			}

			private IEnumerator C_SpawnRandomEnemy(Character owner)
			{
				if (ChzzkCardSynergy.EnemiesAssetKeys == null || ChzzkCardSynergy.EnemiesAssetKeys.Count == 0)
				{
					yield break;
				}
				string foundKey = ChzzkCardSynergy.EnemiesAssetKeys[_rnd.Next(ChzzkCardSynergy.EnemiesAssetKeys.Count)];
				if (foundKey == null)
				{
					yield break;
				}
				AsyncOperationHandle<GameObject> handle = Addressables.InstantiateAsync((object)foundKey, (Transform)null, false, true);
				while (!handle.IsDone)
				{
					yield return null;
				}
				if ((Object)(object)owner == (Object)null || (Object)(object)((Component)owner).gameObject == (Object)null || (Object)(object)((Component)owner).transform == (Object)null || (int)handle.Status != 1)
				{
					yield break;
				}
				GameObject loadedObj = handle.Result;
				if (!((Object)(object)loadedObj != (Object)null))
				{
					yield break;
				}
				Character enemyChar = loadedObj.GetComponent<Character>();
				if (!((Object)(object)enemyChar != (Object)null))
				{
					yield break;
				}
				loadedObj.transform.position = ((Component)owner).transform.position + new Vector3((float)_rnd.Next(-4, 5), 1f, 0f);
				loadedObj.SetActive(true);
				if ((Object)(object)enemyChar.attach != (Object)null)
				{
					enemyChar.attach.SetActive(true);
				}
				yield return null;
				if (!((Object)(object)enemyChar != (Object)null) || !((Object)(object)owner != (Object)null) || !((Object)(object)((Component)owner).gameObject != (Object)null))
				{
					yield break;
				}
				MonoBehaviour[] componentsInChildren = ((Component)enemyChar).GetComponentsInChildren<MonoBehaviour>(true);
				foreach (MonoBehaviour mono in componentsInChildren)
				{
					if ((Object)(object)mono == (Object)null)
					{
						continue;
					}
					AIController controller = (AIController)(object)((mono is AIController) ? mono : null);
					if (controller != null)
					{
						controller.target = owner;
						try
						{
							controller.FoundEnemy();
						}
						catch
						{
						}
					}
				}
				if ((Object)(object)Map.Instance != (Object)null && (Object)(object)Map.Instance.waveContainer != (Object)null)
				{
					try
					{
						Map.Instance.waveContainer.Attach(enemyChar);
					}
					catch
					{
					}
				}
			}

			private IEnumerator C_SpawnRandomItem(Character owner)
			{
				Service service = Singleton<Service>.Instance;
				if (!((Object)(object)service != (Object)null) || !((Object)(object)service.gearManager != (Object)null) || !((Object)(object)service.levelManager != (Object)null))
				{
					yield break;
				}
				Rarity rarity = (Rarity)_rnd.Next(4);
				ItemReference itemRef = service.gearManager.GetItemToTake(rarity);
				if (itemRef != null)
				{
					ItemRequest request = itemRef.LoadAsync();
					while (!((Request<Item>)(object)request).isDone)
					{
						yield return null;
					}
					if (!((Object)(object)owner == (Object)null) && !((Object)(object)((Component)owner).gameObject == (Object)null) && !((Object)(object)((Component)owner).transform == (Object)null) && (Object)(object)((Request<Item>)(object)request).asset != (Object)null)
					{
						service.levelManager.DropItem(request, ((Component)owner).transform.position + Vector3.up * 1f);
					}
				}
			}

			private IEnumerator C_UseRandomQuintessence(Character owner)
			{
				Service service = Singleton<Service>.Instance;
				if (!((Object)(object)service != (Object)null) || !((Object)(object)service.gearManager != (Object)null))
				{
					yield break;
				}
				Rarity rarity = (Rarity)_rnd.Next(4);
				EssenceReference quinteRef = service.gearManager.GetQuintessenceToTake(rarity);
				if (quinteRef == null)
				{
					yield break;
				}
				EssenceRequest req = quinteRef.LoadAsync();
				while (!((Request<Quintessence>)(object)req).isDone)
				{
					yield return null;
				}
				if ((Object)(object)owner == (Object)null || (Object)(object)((Component)owner).gameObject == (Object)null || (Object)(object)((Component)owner).transform == (Object)null || !((Object)(object)((Request<Quintessence>)(object)req).asset != (Object)null))
				{
					yield break;
				}
				Quintessence prefab = ((Component)((Request<Quintessence>)(object)req).asset).GetComponent<Quintessence>();
				if ((Object)(object)prefab != (Object)null)
				{
					Quintessence quinteInstance = Object.Instantiate<Quintessence>(prefab);
					((Component)quinteInstance).transform.parent = ((Component)owner).transform;
					((Component)quinteInstance).transform.localPosition = Vector3.zero;
					try
					{
						((Gear)quinteInstance).Initialize();
						quinteInstance.SetOwner(owner);
						quinteInstance.Use();
					}
					catch (Exception ex)
					{
						Debug.LogError((object)("[UseRandomQuintessence] Failed to use quintessence: " + ex));
					}
					Object.Destroy((Object)(object)((Component)quinteInstance).gameObject, 20f);
				}
			}

			private IEnumerator C_SummonSpirit(string spiritItemName, float duration = -1f)
			{
				Service service = Singleton<Service>.Instance;
				if ((Object)(object)service == (Object)null)
				{
					yield break;
				}
				GlobalSummonedSpirits.RemoveAll((Spirit s) => (Object)(object)s == (Object)null || (Object)(object)((Component)s).gameObject == (Object)null);
				if (GlobalSummonedSpirits.Count >= 128)
				{
					yield break;
				}
				ItemReference itemRef = null;
				if (!GearResource.instance.TryGetItemReferenceByName(spiritItemName, ref itemRef))
				{
					yield break;
				}
				ItemRequest req = itemRef.LoadAsync();
				while (!((Request<Item>)(object)req).isDone)
				{
					yield return null;
				}
				if ((Object)(object)((AbilityInstance)this).owner == (Object)null || (Object)(object)((Component)((AbilityInstance)this).owner).gameObject == (Object)null || !((Object)(object)((Request<Item>)(object)req).asset != (Object)null))
				{
					yield break;
				}
				Item itemPrefab = ((Component)((Request<Item>)(object)req).asset).GetComponent<Item>();
				if (!((Object)(object)itemPrefab != (Object)null))
				{
					yield break;
				}
				Spirit spiritComponent = ((Component)itemPrefab).GetComponentInChildren<Spirit>(true);
				if (!((Object)(object)spiritComponent != (Object)null))
				{
					yield break;
				}
				GameObject spiritGo = Object.Instantiate<GameObject>(((Component)spiritComponent).gameObject);
				spiritGo.transform.position = ((Component)((AbilityInstance)this).owner).transform.position;
				Spirit spiritInstance = spiritGo.GetComponent<Spirit>();
				if ((Object)(object)spiritInstance != (Object)null)
				{
					((AbilityAttacher)spiritInstance).Initialize(((AbilityInstance)this).owner);
					spiritInstance.targetPosition = ((Component)((AbilityInstance)this).owner).transform;
					spiritInstance.Attach();
					((AbilityAttacher)spiritInstance).StartAttach();
					_summonedSpirits.Add(spiritInstance);
					GlobalSummonedSpirits.Add(spiritInstance);
					if (duration > 0f)
					{
						((MonoBehaviour)((AbilityInstance)this).owner).StartCoroutine(C_TemporarySpirit(spiritInstance, duration));
					}
				}
			}

			private IEnumerator C_TemporarySpirit(Spirit spirit, float duration)
			{
				yield return (object)new WaitForSeconds(duration);
				if ((Object)(object)spirit != (Object)null)
				{
					_summonedSpirits.Remove(spirit);
					try
					{
						spirit.Detach();
					}
					catch
					{
					}
					try
					{
						((AbilityAttacher)spirit).StopAttach();
					}
					catch
					{
					}
					try
					{
						Object.Destroy((Object)(object)((Component)spirit).gameObject);
					}
					catch
					{
					}
				}
			}

			private bool OnGiveDamageForPassiveBonus(ITarget target, ref Damage damage)
			{
				//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
				//IL_0134: Unknown result type (might be due to invalid IL or missing references)
				//IL_0151: Unknown result type (might be due to invalid IL or missing references)
				//IL_0156: Unknown result type (might be due to invalid IL or missing references)
				if (damage.@null || ((Damage)(ref damage)).amount < 1.0)
				{
					return false;
				}
				if (damage.key == "GlitchedPassiveBonus")
				{
					return false;
				}
				double num = base.ability.value1;
				bool flag = _rnd.Next(2) == 0;
				if (target != null && (Object)(object)target.character != (Object)null && (Object)(object)((Component)target.character).transform != (Object)null && (Object)(object)target.character.health != (Object)null && !((Health)target.character.health).dead)
				{
					Damage val = default(Damage);
					((Damage)(ref val))..ctor(Attacker.op_Implicit(((AbilityInstance)this).owner), num, Vector2.op_Implicit(((Component)target.character).transform.position), (Attribute)(!flag), (AttackType)4, (MotionType)0, 1.0, 0f, 0.0, 1.0, 1.0, true, false, 0.0, 0.0, (short)0, (PriorityList<bool>)null, 1.0);
					object obj = val;
					damageKeyField.SetValue(obj, "GlitchedPassiveBonus");
					val = (Damage)obj;
					((AbilityInstance)this).owner.Attack(target, ref val);
				}
				return false;
			}

			private IEnumerator C_TriggerStatBoost(bool attackSpeed, double amount, float duration)
			{
				if (!((Object)(object)((AbilityInstance)this).owner == (Object)null) && !((Object)(object)((Component)((AbilityInstance)this).owner).gameObject == (Object)null) && ((AbilityInstance)this).owner.stat != null)
				{
					Category category = Category.PercentPoint;
					Kind kind = (attackSpeed ? Kind.BasicAttackSpeed : Kind.SkillCooldownSpeed);
					Value val = new Value(category, kind, amount);
					Values statValues = new Values((Value[])(object)new Value[1] { val });
					((AbilityInstance)this).owner.stat.AttachValues(statValues);
					if (amount < 0.0)
					{
						string msg = ((!PluginItems.IsKorean()) ? (attackSpeed ? $"[Data Degrade] Attack speed reduced by {Math.Abs(amount) * 100.0:F0}%!" : $"[Data Degrade] Cooldown speed reduced by {Math.Abs(amount) * 100.0:F0}%!") : (attackSpeed ? $"[?곗씠???\u0080?? 怨듦꺽 ?띾룄 {amount * 100.0:F0}% 媛먯냼!" : $"[?곗씠???\u0080?? 荑⑤떎???띾룄 {amount * 100.0:F0}% 媛먯냼!"));
						ChzzkCardSynergy.ShowFloatingText(msg);
					}
					else
					{
						string msg2 = ((!PluginItems.IsKorean()) ? (attackSpeed ? $"[Data Alter] Attack speed +{amount * 100.0:F0}%!" : $"[Data Alter] Cooldown speed +{amount * 100.0:F0}%!") : (attackSpeed ? $"[?곗씠??蹂\u0080議? 怨듦꺽 ?띾룄 +{amount * 100.0:F0}% 媛\u0080??" : $"[?곗씠??蹂\u0080議? 荑⑤떎???띾룄 +{amount * 100.0:F0}% 媛\u0080??"));
						ChzzkCardSynergy.ShowFloatingText(msg2);
					}
					yield return (object)new WaitForSeconds(duration);
					if ((Object)(object)((AbilityInstance)this).owner != (Object)null && (Object)(object)((Component)((AbilityInstance)this).owner).gameObject != (Object)null && ((AbilityInstance)this).owner.stat != null)
					{
						((AbilityInstance)this).owner.stat.DetachValues(statValues);
					}
				}
			}
		}

		public GlitchedTrigger trigger;

		public GlitchedAction action;

		public float value1;

		public float value2;

		public string effectDescription;

		public static readonly List<Spirit> GlobalSummonedSpirits = new List<Spirit>();

		public override IAbilityInstance CreateInstance(Character owner)
		{
			return (IAbilityInstance)(object)new Instance(owner, this);
		}

		public object Clone()
		{
			return MemberwiseClone();
		}
	}
	public sealed class GlitchedStatAbilityComponent : AbilityComponent<GlitchedStatAbility>
	{
		public override void Initialize()
		{
			base.Initialize();
		}
	}
	[Serializable]
	public class GlitchedStatAbility : Ability, ICloneable
	{
		public class Instance : AbilityInstance<GlitchedStatAbility>
		{
			private Values _stats;

			public Instance(Character owner, GlitchedStatAbility ability)
				: base(owner, ability)
			{
			}

			public override void OnAttach()
			{
				if (base.ability.stats != null)
				{
					_stats = base.ability.stats.Clone();
					((AbilityInstance)this).owner.stat.AttachValues(_stats);
					((AbilityInstance)this).owner.stat.SetNeedUpdate();
				}
			}

			public override void OnDetach()
			{
				if (_stats != null)
				{
					((AbilityInstance)this).owner.stat.DetachValues(_stats);
					((AbilityInstance)this).owner.stat.SetNeedUpdate();
				}
			}
		}

		public Values stats;

		public override IAbilityInstance CreateInstance(Character owner)
		{
			return (IAbilityInstance)(object)new Instance(owner, this);
		}

		public object Clone()
		{
			return new GlitchedStatAbility
			{
				stats = ((stats != null) ? stats.Clone() : null),
				_defaultIcon = base._defaultIcon
			};
		}
	}
	[HarmonyPatch]
	public class UseSkillBypassPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch(typeof(CooldownSerializer), "get_canUse")]
		private static bool get_canUse_Prefix(CooldownSerializer __instance, ref bool __result)
		{
			try
			{
				Character player = ChzzkCardSynergy.GetPlayer();
				if ((Object)(object)player != (Object)null && player.playerComponents != null && player.playerComponents.inventory != null)
				{
					WeaponInventory weapon = player.playerComponents.inventory.weapon;
					if ((Object)(object)weapon != (Object)null)
					{
						Weapon current = weapon.current;
						if ((Object)(object)current != (Object)null && current.currentSkills != null)
						{
							foreach (SkillInfo currentSkill in current.currentSkills)
							{
								if ((Object)(object)currentSkill != (Object)null && (Object)(object)currentSkill.action != (Object)null && currentSkill.action.cooldown == __instance)
								{
									__result = true;
									return false;
								}
							}
						}
						Weapon next = weapon.next;
						if ((Object)(object)next != (Object)null && next.currentSkills != null)
						{
							foreach (SkillInfo currentSkill2 in next.currentSkills)
							{
								if ((Object)(object)currentSkill2 != (Object)null && (Object)(object)currentSkill2.action != (Object)null && currentSkill2.action.cooldown == __instance)
								{
									__result = true;
									return false;
								}
							}
						}
					}
				}
			}
			catch (Exception ex)
			{
				Debug.LogWarning((object)("[UseSkillBypassPatch] Failed to bypass cooldown: " + ex.Message));
			}
			return true;
		}
	}
	public sealed class GuanYuCrescentBladeAbilityComponent : AbilityComponent<GuanYuCrescentBladeAbility>
	{
		public override void Initialize()
		{
			base.Initialize();
		}
	}
	[Serializable]
	public class GuanYuCrescentBladeAbility : Ability, ICloneable
	{
		public class Instance : AbilityInstance<GuanYuCrescentBladeAbility>
		{
			private float _cooldownTimer = 0f;

			private const float Cooldown = 0f;

			public Instance(Character owner, GuanYuCrescentBladeAbility ability)
				: base(owner, ability)
			{
			}

			public override void OnAttach()
			{
				((AbilityInstance)this).owner.onStartAction += OnStartAction;
			}

			public override void OnDetach()
			{
				((AbilityInstance)this).owner.onStartAction -= OnStartAction;
			}

			public override void UpdateTime(float deltaTime)
			{
				((AbilityInstance)this).UpdateTime(deltaTime);
				if (_cooldownTimer > 0f)
				{
					_cooldownTimer -= deltaTime;
				}
			}

			private void OnStartAction(Action action)
			{
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Invalid comparison between Unknown and I4
				//IL_0055: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Invalid comparison between Unknown and I4
				//IL_005e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0066: Unknown result type (might be due to invalid IL or missing references)
				//IL_006c: Invalid comparison between Unknown and I4
				if (!((Object)(object)action == (Object)null))
				{
					Debug.Log((object)$"[ChzzkSkul] GuanYu Crescent Blade OnStartAction: name='{((Object)action).name}', type={action.type}");
					if ((int)action.type == 1 || (((Object)action).name != null && ((Object)action).name.IndexOf("attack", StringComparison.OrdinalIgnoreCase) >= 0 && (int)action.type != 4 && (int)action.type != 0 && (int)action.type != 5))
					{
						TriggerSlash();
					}
				}
			}

			private void TriggerSlash()
			{
				//IL_0071: Unknown result type (might be due to invalid IL or missing references)
				//IL_0076: Unknown result type (might be due to invalid IL or missing references)
				//IL_04d7: Unknown result type (might be due to invalid IL or missing references)
				//IL_04df: Unknown result type (might be due to invalid IL or missing references)
				//IL_035b: Unknown result type (might be due to invalid IL or missing references)
				//IL_046e: Unknown result type (might be due to invalid IL or missing references)
				//IL_047a: Unknown result type (might be due to invalid IL or missing references)
				//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
				//IL_01af: Unknown result type (might be due to invalid IL or missing references)
				//IL_00be: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c4: Invalid comparison between Unknown and I4
				//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ef: Invalid comparison between Unknown and I4
				//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
				//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
				//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ce: Invalid comparison between Unknown and I4
				//IL_03f5: Unknown result type (might be due to invalid IL or missing references)
				//IL_024a: Unknown result type (might be due to invalid IL or missing references)
				//IL_02e4: Unknown result type (might be due to invalid IL or missing references)
				bool flag = false;
				_cooldownTimer = 0f;
				if ((Object)(object)((AbilityInstance)this).owner == (Object)null || (Object)(object)((Component)((AbilityInstance)this).owner).gameObject == (Object)null || (Object)(object)((AbilityInstance)this).owner.health == (Object)null || ((Health)((AbilityInstance)this).owner.health).dead)
				{
					return;
				}
				int num = 0;
				try
				{
					Collider2D[] array = Physics2D.OverlapCircleAll(Vector2.op_Implicit(((Component)((AbilityInstance)this).owner).transform.position), 10f);
					Collider2D[] array2 = array;
					foreach (Collider2D val in array2)
					{
						if (!((Object)(object)val == (Object)null))
						{
							Character componentInParent = ((Component)val).GetComponentInParent<Character>();
							if ((Object)(object)componentInParent != (Object)null && (int)componentInParent.type != 6 && (int)componentInParent.type != 7 && (Object)(object)componentInParent.health != (Object)null && !((Health)componentInParent.health).dead)
							{
								num++;
							}
						}
					}
				}
				catch
				{
				}
				double baseMultiplier = 1.0;
				if (num == 1)
				{
					baseMultiplier = 1.5;
				}
				Debug.Log((object)("[ChzzkSkul] GuanYu TriggerSlash executing! GreenSlashEffect: " + ((GreenSlashEffect != null) ? "Ready" : "NULL") + ", BlackCircleEffect: " + ((BlackCircleEffect != null) ? "Ready" : "NULL") + ", SlashSound: " + ((SlashSound != null) ? "Ready" : "NULL")));
				Vector3 val2 = ((Component)((AbilityInstance)this).owner).transform.position;
				if ((Object)(object)((AbilityInstance)this).owner.collider != (Object)null)
				{
					Bounds bounds = ((Collider2D)((AbilityInstance)this).owner.collider).bounds;
					val2 = ((Bounds)(ref bounds)).center;
				}
				float num2 = (((int)((AbilityInstance)this).owner.lookingDirection == 1) ? (-1f) : 1f);
				val2.x += num2 * 1.5f;
				float num3 = ((num >= 4) ? 1.1f : 0.7f);
				MonoBehaviour val3 = null;
				MonoBehaviour val4 = null;
				EffectInfo val5 = GreenSlashEffect ?? SlashEffect;
				if (val5 != null)
				{
					try
					{
						EffectPoolInstance val6 = val5.Spawn(val2, 0f, num3);
						val3 = (MonoBehaviour)(object)val6;
						if ((Object)(object)val3 != (Object)null)
						{
							if (!((Component)val3).gameObject.activeSelf)
							{
								Debug.Log((object)"[ChzzkSkul] GuanYu GreenSlashEffect spawned inactive! Forcing SetActive(true).");
								((Component)val3).gameObject.SetActive(true);
							}
							SpriteRenderer component = ((Component)val3).GetComponent<SpriteRenderer>();
							if ((Object)(object)component != (Object)null)
							{
								((Renderer)component).enabled = true;
							}
							Animator component2 = ((Component)val3).GetComponent<Animator>();
							if ((Object)(object)component2 != (Object)null)
							{
								((Behaviour)component2).enabled = true;
							}
							Debug.Log((object)$"[ChzzkSkul] GuanYu GreenSlashEffect spawned successfully at {val2} (scale {num3})");
						}
						else
						{
							Debug.LogWarning((object)"[ChzzkSkul] GuanYu GreenSlashEffect Spawn returned null!");
						}
					}
					catch (Exception ex)
					{
						Debug.LogError((object)("[ChzzkSkul] Failed to spawn GuanYu GreenSlashEffect: " + ex));
					}
				}
				else
				{
					Debug.LogWarning((object)"[ChzzkSkul] GuanYu GreenSlashEffect is null, cannot spawn green visual!");
				}
				if (BlackCircleEffect != null)
				{
					try
					{
						EffectPoolInstance val7 = BlackCircleEffect.Spawn(val2, 0f, num3);
						val4 = (MonoBehaviour)(object)val7;
						if ((Object)(object)val4 != (Object)null)
						{
							if (!((Component)val4).gameObject.activeSelf)
							{
								Debug.Log((object)"[ChzzkSkul] GuanYu BlackCircleEffect spawned inactive! Forcing SetActive(true).");
								((Component)val4).gameObject.SetActive(true);
							}
							SpriteRenderer component3 = ((Component)val4).GetComponent<SpriteRenderer>();
							if ((Object)(object)component3 != (Object)null)
							{
								((Renderer)component3).enabled = true;
							}
							Animator component4 = ((Component)val4).GetComponent<Animator>();
							if ((Object)(object)component4 != (Object)null)
							{
								((Behaviour)component4).enabled = true;
							}
							Debug.Log((object)$"[ChzzkSkul] GuanYu BlackCircleEffect spawned successfully at {val2} (scale {num3})");
						}
						else
						{
							Debug.LogWarning((object)"[ChzzkSkul] GuanYu BlackCircleEffect Spawn returned null!");
						}
					}
					catch (Exception ex2)
					{
						Debug.LogError((object)("[ChzzkSkul] Failed to spawn GuanYu BlackCircleEffect: " + ex2));
					}
				}
				else
				{
					Debug.LogWarning((object)"[ChzzkSkul] GuanYu BlackCircleEffect is null, cannot spawn black visual!");
				}
				if (SlashSound != null)
				{
					try
					{
						PersistentSingleton<SoundManager>.Instance.PlaySound(SlashSound, val2);
						Debug.Log((object)$"[ChzzkSkul] GuanYu SlashSound played successfully at {val2}");
					}
					catch (Exception ex3)
					{
						Debug.LogError((object)("[ChzzkSkul] Failed to play GuanYu SlashSound: " + ex3));
					}
				}
				else
				{
					Debug.LogWarning((object)"[ChzzkSkul] GuanYu SlashSound is null, cannot play audio!");
				}
				((MonoBehaviour)((AbilityInstance)this).owner).StartCoroutine(PerformContinuousSlash(val3 ?? val4, ((AbilityInstance)this).owner.lookingDirection, baseMultiplier, num3, val2));
			}

			private IEnumerator PerformContinuousSlash(MonoBehaviour spawnedEffect, LookingDirection direction, double baseMultiplier, float visualScale, Vector3 spawnPos)
			{
				//IL_0015: 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_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				float duration = 0.25f;
				float elapsed = 0f;
				HashSet<Character> alreadyHit = new HashSet<Character>();
				while (elapsed < duration && !((Object)(object)((AbilityInstance)this).owner == (Object)null) && !((Object)(object)((Component)((AbilityInstance)this).owner).gameObject == (Object)null) && !((Object)(object)((AbilityInstance)this).owner.health == (Object)null) && !((Health)((AbilityInstance)this).owner.health).dead)
				{
					Vector3 slashCenter = (((Object)(object)spawnedEffect != (Object)null && (Object)(object)((Component)spawnedEffect).gameObject != (Object)null) ? ((Component)spawnedEffect).transform.position : spawnPos);
					try
					{
						Collider2D[] colliders = Physics2D.OverlapCircleAll(Vector2.op_Implicit(slashCenter), 12f * visualScale);
						Collider2D[] array = colliders;
						foreach (Collider2D c in array)
						{
							if ((Object)(object)c == (Object)null)
							{
								continue;
							}
							Character enemy = ((Component)c).GetComponentInParent<Character>();
							if (!((Object)(object)enemy != (Object)null) || (int)enemy.type == 6 || (int)enemy.type == 7 || !((Object)(object)enemy.health != (Object)null) || ((Health)enemy.health).dead || alreadyHit.Contains(enemy))
							{
								continue;
							}
							float dx = ((Component)enemy).transform.position.x - slashCenter.x;
							float dy = Mathf.Abs(((Component)enemy).transform.position.y - slashCenter.y);
							float minDx = -7.5f * visualScale;
							float maxDx = 7.5f * visualScale;
							float maxDy = 5f * visualScale;
							if (dx >= minDx && dx <= maxDx && dy <= maxDy)
							{
								alreadyHit.Add(enemy);
								double currentMultiplier = baseMultiplier;
								if (((Health)enemy.health).percent <= 0.5)
								{
									currentMultiplier *= 1.5;
								}
								double physPower = ((AbilityInstance)this).owner.stat.GetFinal(Kind.PhysicalAttackDamage);
								Damage slashDmg = new Damage(Attacker.op_Implicit(((AbilityInstance)this).owner), 35.0 * currentMultiplier * physPower, Vector2.op_Implicit(((Component)enemy).transform.position), (Attribute)0, (AttackType)4, (MotionType)0, "GuanYuSlash", 1.0, 0f, 0.0, 1.0, 1.0, true, false, 0.0, 0.0, (short)0, (PriorityList<bool>)null, 1.0);
								try
								{
									((AbilityInstance)this).owner.Attack(enemy, ref slashDmg);
									Debug.Log((object)$"[ChzzkSkul] GuanYu attacked enemy {((Object)enemy).name} for {35.0 * currentMultiplier} damage (continuous slash, elapsed {elapsed}s).");
								}
								catch (Exception ex)
								{
									Debug.LogError((object)("[ChzzkSkul] Failed to execute Attack on enemy: " + ex));
								}
							}
						}
					}
					catch (Exception ex2)
					{
						Debug.LogError((object)("[ChzzkSkul] GuanYu continuous overlap search exception: " + ex2));
					}
					elapsed += Time.deltaTime;
					yield return null;
				}
			}
		}

		public static EffectInfo SlashEffect;

		public static EffectInfo GreenSlashEffect;

		public static EffectInfo BlackCircleEffect;

		public static SoundInfo SlashSound;

		public override IAbilityInstance CreateInstance(Character owner)
		{
			return (IAbilityInstance)(object)new Instance(owner, this);
		}

		public object Clone()
		{
			return new GuanYuCrescentBladeAbility
			{
				_defaultIcon = base._defaultIcon
			};
		}
	}
	public sealed class ZeusHammerAbilityComponent : AbilityComponent<ZeusHammerAbility>
	{
		public override void Initialize()
		{
			base.Initialize();
		}
	}
	[Serializable]
	public class ZeusHammerAbility : Ability, ICloneable
	{
		public class Instance : AbilityInstance<ZeusHammerAbility>
		{
			private float _timer = 0f;

			private const float Interval = 0.4f;

			public Instance(Character owner, ZeusHammerAbility ability)
				: base(owner, ability)
			{
			}

			public override void OnAttach()
			{
			}

			public override void OnDetach()
			{
			}

			public override void UpdateTime(float deltaTime)
			{
				((AbilityInstance)this).UpdateTime(deltaTime);
				_timer += deltaTime;
				if (_timer >= 0.4f)
				{
					_timer = 0f;
					TriggerLightning();
				}
			}

			private void TriggerLightning()
			{
				//IL_005c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0061: Unknown result type (might be due to invalid IL or missing references)
				//IL_010d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0125: Unknown result type (might be due to invalid IL or missing references)
				//IL_012a: Unknown result type (might be due to invalid IL or missing references)
				//IL_01af: Unknown result type (might be due to invalid IL or missing references)
				//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)((AbilityInstance)this).owner == (Object)null || (Object)(object)((Component)((AbilityInstance)this).owner).gameObject == (Object)null || (Object)(object)((AbilityInstance)this).owner.health == (Object)null || ((Health)((AbilityInstance)this).owner.health).dead)
				{
					return;
				}
				Collider2D[] source = Physics2D.OverlapCircleAll(Vector2.op_Implicit(((Component)((AbilityInstance)this).owner).transform.position), 7f);
				List<Character> list = (from c in source
					select ((Object)(object)c != (Object)null) ? ((Component)c).GetComponentInParent<Character>() : null into c
					where (Object)(object)c != (Object)null && (int)c.type != 6 && (int)c.type != 7 && (Object)(object)c.health != (Object)null && !((Health)c.health).dead
					select c).Distinct().ToList();
				if (list.Count > 0)
				{
					int index = Random.Range(0, list.Count);
					Character val = list[index];
					double final = ((AbilityInstance)this).owner.stat.GetFinal(Kind.MagicAttackDamage);
					Damage val2 = default(Damage);
					((Damage)(ref val2))..ctor(Attacker.op_Implicit(((AbilityInstance)this).owner), 35.0 * final, Vector2.op_Implicit(((Component)val).transform.position), (Attribute)1, (AttackType)4, (MotionType)0, "ZeusLightning", 1.0, 0f, 0.0, 1.0, 1.0, true, false, 0.0, 0.0, (short)0, (PriorityList<bool>)null, 1.0);
					((AbilityInstance)this).owner.Attack(val, ref val2);
					if (LightningEffect != null)
					{
						LightningEffect.Spawn(((Component)val).transform.position, 0f, 1f);
					}
					if (LightningSound != null)
					{
						PersistentSingleton<SoundManager>.Instance.PlaySound(LightningSound, ((Component)val).transform.position);
					}
				}
			}
		}

		public static EffectInfo LightningEffect;

		public static SoundInfo LightningSound;

		public override IAbilityInstance CreateInstance(Character owner)
		{
			return (IAbilityInstance)(object)new Instance(owner, this);
		}

		public object Clone()
		{
			return new ZeusHammerAbility
			{
				_defaultIcon = base._defaultIcon
			};
		}
	}
	public sealed class MedjedCloakAbilityComponent : AbilityComponent<MedjedCloakAbility>
	{
		public override void Initialize()
		{
			base.Initialize();
		}
	}
	[Serializable]
	public class MedjedCloakAbility : Ability, ICloneable
	{
		public class Instance : AbilityInstance<MedjedCloakAbility>
		{
			public Instance(Character owner, MedjedCloakAbility ability)
				: base(owner, ability)
			{
			}

			public override void OnAttach()
			{
				IsActive = true;
			}

			public override void OnDetach()
			{
				IsActive = false;
			}
		}

		public static bool IsActive;

		public override IAbilityInstance CreateInstance(Character owner)
		{
			return (IAbilityInstance)(object)new Instance(owner, this);
		}

		public object Clone()
		{
			return new MedjedCloakAbility
			{
				_defaultIcon = base._defaultIcon
			};
		}
	}
	public sealed class VirusAbilityComponent : AbilityComponent<VirusAbility>
	{
		public override void Initialize()
		{
			base.Initialize();
		}
	}
	[Serializable]
	public class VirusAbility : Ability, ICloneable
	{
		public class Instance : AbilityInstance<VirusAbility>
		{
			private float _timer = 0f;

			private const float Interval = 10f;

			public Instance(Character owner, VirusAbility ability)
				: base(owner, ability)
			{
			}

			public override void OnAttach()
			{
			}

			public override void OnDetach()
			{
			}

			public override void UpdateTime(float deltaTime)
			{
				((AbilityInstance)this).UpdateTime(deltaTime);
				_timer += deltaTime;
				if (_timer >= 10f)
				{
					_timer = 0f;
					TriggerVirusDamage();
				}
			}

			private void TriggerVirusDamage()
			{
				if (!((Object)(object)((AbilityInstance)this).owner == (Object)null) && !((Object)(object)((AbilityInstance)this).owner.health == (Object)null) && !((Health)((AbilityInstance)this).owner.health).dead)
				{
					((Health)((AbilityInstance)this).owner.health).TakeHealth(0.5);
					ChzzkCardSynergy.ShowFloatingText("諛붿씠?ъ뒪 ?④낵濡?泥대젰??0.5 媛먯냼?덉뒿?덈떎.");
				}
			}
		}

		public override IAbilityInstance CreateInstance(Character owner)
		{
			return (IAbilityInstance)(object)new Instance(owner, this);
		}

		public object Clone()
		{
			return new VirusAbility
			{
				_defaultIcon = base._defaultIcon
			};
		}
	}
	public sealed class ChallengersBeltAbilityComponent : AbilityComponent<ChallengersBeltAbility>
	{
		public override void Initialize()
		{
			base.Initialize();
		}
	}
	[Serializable]
	public class ChallengersBeltAbility : Ability, ICloneable
	{
		public class Instance : AbilityInstance<ChallengersBeltAbility>
		{
			public Instance(Character owner, ChallengersBeltAbility ability)
				: base(owner, ability)
			{
			}

			public override void OnAttach()
			{
				IsActive = true;
			}

			public override void OnDetach()
			{
				IsActive = false;
			}
		}

		public static bool IsActive;

		public override IAbilityInstance CreateInstance(Character owner)
		{
			return (IAbilityInstance)(object)new Instance(owner, this);
		}

		public object Clone()
		{
			return new ChallengersBeltAbility
			{
				_defaultIcon = base._defaultIcon
			};
		}
	}
	[Serializable]
	public sealed class BrokenHeartEvolveBehavior : MonoBehaviour
	{
		[SerializeField]
		private Item _item = null;

		private void Update()
		{
			Character player = Singleton<Service>.Instance.levelManager.player;
			if (!((Object)(object)player == (Object)null) && player.playerComponents != null && player.playerComponents.inventory != null)
			{
				List<Quintessence> items = player.playerComponents.inventory.quintessence.items;
				if (items.Any((Quintessence q) => (Object)(object)q != (Object)null && ((Object)q).name.Equals("Succubus", StringComparison.OrdinalIgnoreCase)))
				{
					ChangeItem();
				}
			}
		}

		private void ChangeItem()
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Invalid comparison between Unknown and I4
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			ItemReference val = default(ItemReference);
			if (GearResource.instance.TryGetItemReferenceByName(((Object)_item).name + "_2", ref val))
			{
				ItemRequest val2 = val.LoadAsync();
				((Request<Item>)(object)val2).WaitForCompletion();
				if ((int)((Gear)_item).state == 1)
				{
					Character player = Singleton<Service>.Instance.levelManager.player;
					Vector3 val3 = (((Object)(object)player != (Object)null) ? ((Component)player).transform.position : ((Component)_item).transform.position);
					Item val4 = Singleton<Service>.Instance.levelManager.DropItem(val2, val3);
					_item.ChangeOnInventory(val4);
				}
			}
		}
	}
	[Serializable]
	public sealed class SmallTwigEvolveBehavior : MonoBehaviour
	{
		[SerializeField]
		private Item _item = null;

		private bool _hasEquipped = false;

		private Character player;

		private void Awake()
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			player = Singleton<Service>.Instance.levelManager.player;
			_hasEquipped = false;
			player.playerComponents.inventory.weapon.onSwap += CheckEvolveCondition;
			player.playerComponents.inventory.weapon.onChanged += new OnChangeDelegate(OnSkullChanged);
		}

		private void OnDestroy()
		{
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Expected O, but got Unknown
			if ((Object)(object)player != (Object)null && player.playerComponents != null && player.playerComponents.inventory != null)
			{
				player.playerComponents.inventory.weapon.onSwap -= CheckEvolveCondition;
				player.playerComponents.inventory.weapon.onChanged -= new OnChangeDelegate(OnSkullChanged);
			}
		}

		private void Update()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Invalid comparison between Unknown and I4
			if ((int)((Gear)_item).state == 1 && !_hasEquipped)
			{
				CheckEvolveCondition();
				_hasEquipped = true;
			}
		}

		private void OnSkullChanged(Weapon old, Weapon @new)
		{
			CheckEvolveCondition();
		}

		private void CheckEvolveCondition()
		{
			Weapon current = player.playerComponents.inventory.weapon.current;
			if ((Object)(object)current != (Object)null && (((Object)current).name.Equals("Skul", StringComparison.OrdinalIgnoreCase) || ((Object)current).name.Equals("HeroSkul", StringComparison.OrdinalIgnoreCase)))
			{
				ChangeItem();
			}
		}

		private void ChangeItem()
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Invalid comparison between Unknown and I4
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			ItemReference val = default(ItemReference);
			if (GearResource.instance.TryGetItemReferenceByName(((Object)_item).name + "_2", ref val))
			{
				ItemRequest val2 = val.LoadAsync();
				((Request<Item>)(object)val2).WaitForCompletion();
				if ((int)((Gear)_item).state == 1)
				{
					Vector3 val3 = (((Object)(object)player != (Object)null) ? ((Component)player).transform.position : ((Component)_item).transform.position);
					Item val4 = Singleton<Service>.Instance.levelManager.DropItem(val2, val3);
					_item.ChangeOnInventory(val4);
				}
			}
		}
	}
	[Serializable]
	public sealed class SmallTwigRevertBehavior : MonoBehaviour
	{
		[SerializeField]
		private Item _item = null;

		private bool _hasEquipped = false;

		private Character player;

		private void Awake()
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			player = Singleton<Service>.Instance.levelManager.player;
			_hasEquipped = false;
			player.playerComponents.inventory.weapon.onSwap += CheckRevertCondition;
			player.playerComponents.inventory.weapon.onChanged += new OnChangeDelegate(OnSkullChanged);
		}

		private void OnDestroy()
		{
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Expected O, but got Unknown
			if ((Object)(object)player != (Object)null && player.playerComponents != null && player.playerComponents.inventory != null)
			{
				player.playerComponents.inventory.weapon.onSwap -= CheckRevertCondition;
				player.playerComponents.inventory.weapon.onChanged -= new OnChangeDelegate(OnSkullChanged);
			}
		}

		private void Update()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Invalid comparison between Unknown and I4
			if ((int)((Gear)_item).state == 1 && !_hasEquipped)
			{
				CheckRevertCondition();
				_hasEquipped = true;
			}
		}

		private void OnSkullChanged(Weapon old, Weapon @new)
		{
			CheckRevertCondition();
		}

		private void CheckRevertCondition()
		{
			Weapon current = player.playerComponents.inventory.weapon.current;
			if ((Object)(object)current != (Object)null && !((Object)current).name.Equals("Skul", StringComparison.OrdinalIgnoreCase) && !((Object)current).name.Equals("HeroSkul", StringComparison.OrdinalIgnoreCase))
			{
				ChangeItem();
			}
		}

		private void ChangeItem()
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Invalid comparison between Unknown and I4
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			string text = ((Object)_item).name;
			if (text.EndsWith("_2"))
			{
				text = text.Substring(0, text.Length - 2);
			}
			ItemReference val = default(ItemReference);
			if (GearResource.instance.TryGetItemReferenceByName(text, ref val))
			{
				ItemRequest val2 = val.LoadAsync();
				((Request<Item>)(object)val2).WaitForCompletion();
				if ((int)((Gear)_item).state == 1)
				{
					Vector3 val3 = (((Object)(object)player != (Object)null) ? ((Component)player).transform.position : ((Component)_item).transform.position);
					Item val4 = Singleton<Service>.Instance.levelManager.DropItem(val2, val3);
					_item.ChangeOnInventory(val4);
				}
			}
		}
	}
	[Serializable]
	public sealed class ScaleOfTheOtherworldBehavior : MonoBehaviour
	{
		[SerializeField]
		private Item _item = null;

		private void Awake()
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_item == (Object)null)
			{
				_item = ((Component)this).GetComponentInParent<Item>() ?? ((Component)this).GetComponent<Item>();
			}
			if (!((Object)(object)_item == (Object)null))
			{
				BonusKeyword val = new BonusKeyword();
				val.type = (Type)0;
				val.count = 1;
				_item.bonusKeyword = (BonusKeyword[])(object)new BonusKeyword[1] { val };
				Key[] array = new Key[36];
				RuntimeHelpers.InitializeArray(array, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
				Key[] array2 = (Key[])(object)array;
				Random random = new Random();
				int num = random.Next(array2.Length);
				int num2;
				for (num2 = random.Next(array2.Length); num2 == num; num2 = random.Next(array2.Length))
				{
				}
				_item.keyword1 = array2[num];
				_item.keyword2 = array2[num2];
			}
		}
	}
	[Serializable]
	public sealed class CardFoolBehavior : MonoBehaviour
	{
		[SerializeField]
		private Item _item = null;

		private bool _isHooked = false;

		private Character _lastOwner = null;

		private Values _extraStats = null;

		private Values _dashStats = null;

		private bool _hasDashCharge = false;

		private bool _lastIsSuper = false;

		private bool _lastIsEnhanced = false;

		private Random _rnd = new Random();

		private void Awake()
		{
			if ((Object)(object)_item == (Object)null)
			{
				_item = ((Component)this).GetComponentInParent<Item>() ?? ((Component)this).GetComponent<Item>();
			}
		}

		private void Update()
		{
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Expected O, but got Unknown
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Expected O, but got Unknown
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Expected O, but got Unknown
			if ((Object)(object)_item == (Object)null || (Object)(object)((Gear)_item).owner == (Object)null)
			{
				ClearStats();
				Unsubscribe();
				return;
			}
			if ((Object)(object)((Gear)_item).owner != (Object)(object)_lastOwner)
			{
				Unsubscribe();
				_lastOwner = ((Gear)_item).owner;
				Subscribe();
			}
			bool flag = ChzzkCardSynergy.IsCardSynergySuper(_item);
			bool flag2 = ChzzkCardSynergy.GetCardCount(_item) >= 6;
			if (_extraStats == null || flag != _lastIsSuper || flag2 != _lastIsEnhanced)
			{
				ClearStats();
				_lastIsSuper = flag;
				_lastIsEnhanced = flag2;
				List<Value> list = new List<Value>();
				if (!flag)
				{
					double num = (flag2 ? 0.3 : 0.2);
					list.Add(new Value(Category.PercentPoint, Kind.MovementSpeed, num));
				}
				else
				{
					list.Add(new Value(Category.PercentPoint, Kind.MovementSpeed, -0.1));
				}
				if (list.Count > 0)
				{
					_extraStats = new Values(list.ToArray());
					((Gear)_item).owner.stat.AttachValues(_extraStats);
					((Gear)_item).owner.stat.SetNeedUpdate();
				}
			}
		}

		private void Subscribe()
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			if ((Object)(object)_lastOwner == (Object)null)
			{
				return;
			}
			try
			{
				_lastOwner.onStartAction += OnStartAction;
				((PriorityList<GiveDamageDelegate>)(object)_lastOwner.onGiveDamage).Add(100, new GiveDamageDelegate(OnGiveDamage));
				_isHooked = true;
			}
			catch
			{
			}
		}

		private void Unsubscribe()
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			if ((Object)(object)_lastOwner == (Object)null || !_isHooked)
			{
				return;
			}
			try
			{
				_lastOwner.onStartAction -= OnStartAction;
				((PriorityList<GiveDamageDelegate>)(object)_lastOwner.onGiveDamage).Remove(new GiveDamageDelegate(OnGiveDamage));
				_isHooked = false;
			}
			catch
			{
			}
		}

		private void OnStartAction(Action action)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)action == (Object)null) && (int)action.type == 0 && !((Object)(object)_lastOwner == (Object)null) && _lastIsSuper)
			{
				((MonoBehaviour)this).StartCoroutine(C_FoolDashBuff());
			}
		}

		private IEnumerator C_FoolDashBuff()
		{
			if (!((Object)(object)_lastOwner == (Object)null) && _dashStats == null)
			{
				double speed = (_lastIsEnhanced ? 0.7 : 0.5);
				float duration = (_lastIsEnhanced ? 1.5f : 1f);
				_dashStats = new Values((Value[])(object)new Value[1]
				{
					new Value(Category.PercentPoint, Kind.MovementSpeed, speed)
				});
				_lastOwner.stat.AttachValues(_dashStats);
				_lastOwner.stat.SetNeedUpdate();
				_hasDashCharge = true;
				yield return (object)new WaitForSeconds(duration);
				if ((Object)(object)_lastOwner != (Object)null && _dashStats != null)
				{
					_lastOwner.stat.DetachValues(_dashStats);
					_lastOwner.stat.SetNeedUpdate();
					_dashStats = null;
				}
				_hasDashCharge = false;
			}
		}

		private bool OnGiveDamage(ITarget target, ref Damage damage)
		{
			if (_hasDashCharge && (Object)(object)_lastOwner != (Object)null)
			{
				_hasDashCharge = false;
				double num = (_lastIsEnhanced ? 2.5 : 2.0);
				damage.multiplier *= num;
				ChzzkCardSynergy.ShowFloatingText(PluginItems.IsKorean() ? "[??쐞移?愿묐?] ?\u0080誘몄? 利앺룺!" : "[Reversed Fool] Damage Amplified!");
				if (_dashStats != null && (Object)(object)_lastOwner != (Object)null)
				{
					try
					{
						_lastOwner.stat.DetachValues(_dashStats);
						_lastOwner.stat.SetNeedUpdate();
					}
					catch
					{
					}
					_dashStats = null;
				}
			}
			return false;
		}

		private void ClearStats()
		{
			if ((Object)(object)_lastOwner != (Object)null)
			{
				if (_extraStats != null)
				{
					try
					{
						_lastOwner.stat.DetachValues(_extraStats);
					}
					catch
					{
					}
				}
				if (_dashStats != null)
				{
					try
					{
						_lastOwner.stat.DetachValues(_dashStats);
					}
					catch
					{
					}
				}
				try
				{
					_lastOwner.stat.SetNeedUpdate();
				}
				catch
				{
				}
			}
			_extraStats = null;
			_dashStats = null;
			_hasDashCharge = false;
		}

		private void OnDestroy()
		{
			ClearStats();
			Unsubscribe();
		}
	}
	[Serializable]
	public sealed class CardMagicianBehavior : MonoBehaviour
	{
		[SerializeField]
		private Item _item = null;

		private bool _isHooked = false;

		private Character _lastOwner = null;

		private Values _extraStats = null;

		private bool _lastIsSuper = false;

		private bool _lastIsEnhanced = false;

		private Random _rnd = new Random();

		private void Awake()
		{
			if ((Object)(object)_item == (Object)null)
			{
				_item = ((Component)this).GetComponentInParent<Item>() ?? ((Component)this).GetComponent<Item>();
			}
		}

		private void Update()
		{
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Expected O, but got Unknown
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Expected O, but got Unknown
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Expected O, but got Unknown
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Expected O, but got Unknown
			if ((Object)(object)_item == (Object)null || (Object)(object)((Gear)_item).owner == (Object)null)
			{
				ClearStats();
				Unsubscribe();
				return;
			}
			if ((Object)(object)((Gear)_item).owner != (Object)(object)_lastOwner)
			{
				Unsubscribe();
				_lastOwner = ((Gear)_item).owner;
				Subscribe();
			}
			bool flag