using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using CardChoiceSpawnUniqueCardPatch.CustomCategories;
using GearUpCards.Cards;
using GearUpCards.Extensions;
using GearUpCards.MonoBehaviours;
using GearUpCards.MonoBehaviours.Visuals;
using GearUpCards.Utils;
using HarmonyLib;
using Jotunn.Utils;
using Microsoft.CodeAnalysis;
using ModdingUtils.Extensions;
using ModdingUtils.MonoBehaviours;
using ModdingUtils.Utils;
using Photon.Pun;
using RarityLib.Utils;
using Sonigon;
using SoundImplementation;
using TMPro;
using UnboundLib;
using UnboundLib.Cards;
using UnboundLib.GameModes;
using UnboundLib.Utils;
using UnityEngine;
using UnityEngine.Audio;
using UnityEngine.Rendering;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(/*Could not decode attribute arguments.*/)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.1", FrameworkDisplayName = ".NET Framework 4.7.1")]
[assembly: AssemblyVersion("0.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(/*Could not decode attribute arguments.*/)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
public class CardHolder : MonoBehaviour
{
	public List<GameObject> Cards;

	public List<GameObject> HiddenCards;

	internal void RegisterCards()
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0060: Unknown result type (might be due to invalid IL or missing references)
		//IL_0065: Unknown result type (might be due to invalid IL or missing references)
		Enumerator<GameObject> enumerator = Cards.GetEnumerator();
		try
		{
			while (enumerator.MoveNext())
			{
				GameObject current = enumerator.Current;
				CustomCard component = current.GetComponent<CustomCard>();
				if (component != null)
				{
					component.BuildUnityCard((Action<CardInfo>)null);
				}
				else
				{
					CustomCard.RegisterUnityCard(current, "GearUP", current.GetComponent<CardInfo>().cardName, true, (Action<CardInfo>)null);
				}
			}
		}
		finally
		{
			((IDisposable)enumerator).Dispose();
		}
		enumerator = HiddenCards.GetEnumerator();
		try
		{
			while (enumerator.MoveNext())
			{
				GameObject current2 = enumerator.Current;
				CustomCard component2 = current2.GetComponent<CustomCard>();
				if (component2 != null)
				{
					component2.BuildUnityCard((Action<CardInfo>)delegate(CardInfo cardInfo)
					{
						Cards.instance.AddHiddenCard(cardInfo);
					});
				}
				else
				{
					CustomCard.RegisterUnityCard(current2, "GearUP", current2.GetComponent<CardInfo>().cardName, false, (Action<CardInfo>)null);
					Cards.instance.AddHiddenCard(current2.GetComponent<CardInfo>());
				}
			}
		}
		finally
		{
			((IDisposable)enumerator).Dispose();
		}
	}
}
public class FixSoundEffect : MonoBehaviour
{
	private Gun gun;

	private void Awake()
	{
		gun = ((Component)this).GetComponent<Gun>();
		AudioMixerGroup audioGroup = SoundVolumeManager.Instance.audioMixer.FindMatchingGroups("SFX")[0];
		SetAudioMixerGroup(gun.soundShotModifier.single, audioGroup);
		SetAudioMixerGroup(gun.soundShotModifier.singleAutoLoop, audioGroup);
		SetAudioMixerGroup(gun.soundShotModifier.singleAutoTail, audioGroup);
		SetAudioMixerGroup(gun.soundShotModifier.shotgun, audioGroup);
		SetAudioMixerGroup(gun.soundShotModifier.shotgunAutoLoop, audioGroup);
		SetAudioMixerGroup(gun.soundShotModifier.shotgunAutoTail, audioGroup);
		SetAudioMixerGroup(gun.soundImpactModifier.impactCharacter, audioGroup);
		SetAudioMixerGroup(gun.soundImpactModifier.impactEnvironment, audioGroup);
	}

	private void SetAudioMixerGroup(SoundEvent soundEvent, AudioMixerGroup audioGroup)
	{
		if (!((Object)(object)soundEvent == (Object)null))
		{
			soundEvent.variables.audioMixerGroup = audioGroup;
		}
	}
}
namespace GearUpCards
{
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("com.pudassassin.rounds.GearUpCards", "GearUpCards", "0.5.1.0")]
	[BepInProcess("Rounds.exe")]
	public class GearUpCards : BaseUnityPlugin
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c : Object
		{
			public static readonly <>c <>9 = new <>c();

			public static Action <>9__30_0;

			public static Action <>9__30_1;

			public static Action <>9__30_2;

			public static Action<Card> <>9__32_0;

			public static Action<Card> <>9__32_1;

			internal void <Start>b__30_0()
			{
				CardUtils.MakeExclusive("Arcane Conversion", "Flak Cannon");
				if ((Object)(object)CardUtils.GetCardInfo("Size Difference") != (Object)null)
				{
					CardInfo cardInfo = CardUtils.GetCardInfo("Size Difference");
					CardUtils.MakeExclusive("Size Difference", "Size Normalizer");
					List<CardCategory> val = Enumerable.ToList<CardCategory>((IEnumerable<CardCategory>)(object)cardInfo.categories);
					val.Add(CardUtils.GearCategory.typeSizeMod);
					cardInfo.categories = val.ToArray();
				}
				if ((Object)(object)CardUtils.GetCardInfo("Size Matters") != (Object)null)
				{
					CardInfo cardInfo2 = CardUtils.GetCardInfo("Size Matters");
					CardUtils.MakeExclusive("Size Matters", "Size Normalizer");
					List<CardCategory> val2 = Enumerable.ToList<CardCategory>((IEnumerable<CardCategory>)(object)cardInfo2.categories);
					val2.Add(CardUtils.GearCategory.typeSizeMod);
					cardInfo2.categories = val2.ToArray();
				}
				CardUtils.MakeExclusive("Gatling Gun", "Flak Cannon");
				if ((Object)(object)CardUtils.GetCardInfo("Plasma Rifle") != (Object)null)
				{
					CardInfo cardInfo3 = CardUtils.GetCardInfo("Plasma Rifle");
					CardUtils.MakeExclusive("Plasma Rifle", "Flak Cannon");
					List<CardCategory> val3 = Enumerable.ToList<CardCategory>((IEnumerable<CardCategory>)(object)cardInfo3.categories);
					val3.Add(CardUtils.GearCategory.typeGunMod);
					cardInfo3.categories = val3.ToArray();
				}
				if ((Object)(object)CardUtils.GetCardInfo("Plasma Shotgun") != (Object)null)
				{
					CardInfo cardInfo4 = CardUtils.GetCardInfo("Plasma Shotgun");
					CardUtils.MakeExclusive("Plasma Shotgun", "Flak Cannon");
					List<CardCategory> val4 = Enumerable.ToList<CardCategory>((IEnumerable<CardCategory>)(object)cardInfo4.categories);
					val4.Add(CardUtils.GearCategory.typeGunMod);
					cardInfo4.categories = val4.ToArray();
				}
				CardUtils.MakeExclusive("Fragmentation", "Flak Cannon");
				CardUtils.MakeExclusive("Fireworks", "Flak Cannon");
				CardUtils.MakeExclusive("Rolling Thunder", "Flak Cannon");
				CardUtils.MakeExclusive("Splitting Rounds", "Flak Cannon");
				if ((Object)(object)CardUtils.GetCardInfo("Pong") != (Object)null)
				{
					CardInfo cardInfo5 = CardUtils.GetCardInfo("Pong");
					CardUtils.MakeExclusive("Pong", "Flak Cannon");
					CardUtils.MakeExclusive("Pong", "Arc of Bullets");
					CardUtils.MakeExclusive("Pong", "Parallel Bullets");
					List<CardCategory> val5 = Enumerable.ToList<CardCategory>((IEnumerable<CardCategory>)(object)cardInfo5.categories);
					val5.Add(CardUtils.GearCategory.typeGunMod);
					val5.Add(CardUtils.GearCategory.typeUniqueGunSpread);
					cardInfo5.categories = val5.ToArray();
				}
				CardUtils.MakeExclusive("Hive", "Flak Cannon");
				CardUtils.MakeExclusive("Snake Attack", "Flak Cannon");
				if (Object.op_Implicit((Object)(object)CardUtils.GetCardInfo("Shock Blast")))
				{
					CardInfo cardInfo6 = CardUtils.GetCardInfo("Shock Blast");
					CardUtils.MakeExclusive("Shock Blast", "Flak Cannon");
					CardUtils.MakeExclusive("Shock Blast", "Arc of Bullets");
					CardUtils.MakeExclusive("Shock Blast", "Parallel Bullets");
					List<CardCategory> val6 = Enumerable.ToList<CardCategory>((IEnumerable<CardCategory>)(object)cardInfo6.categories);
					val6.Add(CardUtils.GearCategory.typeGunMod);
					val6.Add(CardUtils.GearCategory.typeUniqueGunSpread);
					cardInfo6.categories = val6.ToArray();
				}
				if (Object.op_Implicit((Object)(object)CardUtils.GetCardInfo("Mirror Mage")))
				{
					CardInfo cardInfo7 = CardUtils.GetCardInfo("Mirror Mage");
					CardUtils.MakeExclusive("Mirror Mage", "Flak Cannon");
					CardUtils.MakeExclusive("Mirror Mage", "Arc of Bullets");
					CardUtils.MakeExclusive("Mirror Mage", "Parallel Bullets");
					List<CardCategory> val7 = Enumerable.ToList<CardCategory>((IEnumerable<CardCategory>)(object)cardInfo7.categories);
					val7.Add(CardUtils.GearCategory.typeGunMod);
					val7.Add(CardUtils.GearCategory.typeUniqueGunSpread);
					cardInfo7.categories = val7.ToArray();
				}
				CardUtils.MakeExclusive("Arcane Conversion", "Piercing Bullets");
				CardUtils.MakeExclusive("Arcane Conversion", "Anonymity");
			}

			internal void <Start>b__30_1()
			{
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				//IL_005c: Unknown result type (might be due to invalid IL or missing references)
				IEnumerator<Rarity> enumerator = RarityUtils.Rarities.Values.GetEnumerator();
				try
				{
					while (((IEnumerator)enumerator).MoveNext())
					{
						Rarity current = enumerator.Current;
						CardUtils.rarityCategories.Add(current, CustomCardCategories.instance.CardCategory(String.Concat("__Rarity-", current.name)));
					}
				}
				finally
				{
					if (enumerator != null)
					{
						((IDisposable)enumerator).Dispose();
					}
				}
				Enumerator<string> enumerator2 = CardManager.categories.GetEnumerator();
				try
				{
					while (enumerator2.MoveNext())
					{
						string current2 = enumerator2.Current;
						CardUtils.packCategories.Add(current2, CustomCardCategories.instance.CardCategory(String.Concat("__Pack-", current2)));
					}
				}
				finally
				{
					((IDisposable)enumerator2).Dispose();
				}
			}

			internal void <Start>b__30_2()
			{
				GameObject[] array = Resources.FindObjectsOfTypeAll(typeof(GameObject)) as GameObject[];
				foreach (GameObject val in array)
				{
					if (((Object)val).name == "Bullet_Base" && val.CompareTag("Bullet"))
					{
						bulletObj = val;
						break;
					}
				}
				MoveTransform component = bulletObj.GetComponent<MoveTransform>();
				ProjectileHit component2 = bulletObj.GetComponent<ProjectileHit>();
				if ((Object)(object)component != (Object)null && (Object)(object)component2 != (Object)null)
				{
					bulletObj.AddComponent<BulletVFXScale>();
					Miscs.Log("[GearUp] added experimental bullet VFX rescaler");
				}
			}

			internal void <GameStart>b__32_0(Card card)
			{
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				Enumerator<Rarity, CardCategory> enumerator = CardUtils.rarityCategories.Values.GetEnumerator();
				try
				{
					while (enumerator.MoveNext())
					{
						CardCategory current = enumerator.Current;
						List<CardCategory> val = new List<CardCategory>((IEnumerable<CardCategory>)(object)card.cardInfo.categories);
						if (val.Contains(current))
						{
							val.Remove(current);
							CardCategory[] categories = val.ToArray();
							card.cardInfo.categories = categories;
							break;
						}
					}
				}
				finally
				{
					((IDisposable)enumerator).Dispose();
				}
			}

			internal void <GameStart>b__32_1(Card card)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				Rarity rarityData = RarityUtils.GetRarityData(card.cardInfo.rarity);
				CardCategory val = CardUtils.rarityCategories[rarityData];
				CardCategory[] categories = CollectionExtensions.AddToArray<CardCategory>(card.cardInfo.categories, val);
				card.cardInfo.categories = categories;
			}
		}

		public const string ModId = "com.pudassassin.rounds.GearUpCards";

		public const string ModName = "GearUpCards";

		public const string Version = "0.5.1.0";

		public const string ModInitials = "GearUP";

		public const int CardEffectPriority = 0;

		public const int ExtraCardDrawPriority = 200;

		public static GameObject bulletObj;

		public static bool isCardPickingPhase = false;

		public static bool isCardExtraDrawPhase = false;

		private static int lastPickerID = -1;

		public static AssetBundle VFXBundle;

		public static AssetBundle ATPBundle;

		public static AssetBundle CardArtBundle;

		public static AssetBundle CardAssets;

		public static AssetBundle CardIconBundle;

		public const string CompatibilityModName = "GearUpCards";

		public static bool ReducedVFX
		{
			get
			{
				return GetBool("ReduceVFX", defaultValue: true);
			}
			set
			{
				SetBool("ReduceVFX", value);
			}
		}

		public static bool EcoModeVFX
		{
			get
			{
				return GetBool("EcoModeVFX", defaultValue: true);
			}
			set
			{
				SetBool("EcoModeVFX", value);
			}
		}

		internal static string ConfigKey(string name)
		{
			return String.Concat("GearUpCards_", name.ToLower());
		}

		internal static bool GetBool(string name, bool defaultValue = false)
		{
			return PlayerPrefs.GetInt(ConfigKey(name), defaultValue ? 1 : 0) == 1;
		}

		internal static void SetBool(string name, bool value)
		{
			PlayerPrefs.SetInt(ConfigKey(name), value ? 1 : 0);
		}

		internal static int GetInt(string name, int defaultValue = 0)
		{
			return PlayerPrefs.GetInt(ConfigKey(name), defaultValue);
		}

		internal static void SetInt(string name, int value)
		{
			PlayerPrefs.SetInt(ConfigKey(name), value);
		}

		internal static float GetFloat(string name, float defaultValue = 0f)
		{
			return PlayerPrefs.GetFloat(ConfigKey(name), defaultValue);
		}

		internal static void SetFloat(string name, float value)
		{
			PlayerPrefs.SetFloat(ConfigKey(name), value);
		}

		private void Awake()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			Miscs.Log("[GearUp] Harmony Patching");
			new Harmony("com.pudassassin.rounds.GearUpCards").PatchAll();
			Miscs.Log("[GearUp] Harmony Patched");
			ATPBundle = AssetUtils.LoadAssetBundleFromResources("gearup_game_effect", typeof(GearUpCards).Assembly);
			ATPBundle.LoadAllAssets();
			Miscs.Log("[GearUp] Loaded ATP stuffs");
			VFXBundle = AssetUtils.LoadAssetBundleFromResources("gearup_asset", typeof(GearUpCards).Assembly);
			VFXBundle.LoadAllAssets();
			Miscs.Log("[GearUp] Loaded VFX stuffs");
			CardArtBundle = AssetUtils.LoadAssetBundleFromResources("gearup_cardarts", typeof(GearUpCards).Assembly);
			CardArtBundle.LoadAllAssets();
			Miscs.Log("[GearUp] Loaded Card Arts");
			CardIconBundle = AssetUtils.LoadAssetBundleFromResources("gearup_cardicon", typeof(GearUpCards).Assembly);
			CardIconBundle.LoadAllAssets();
			Miscs.Log("[GearUp] Loaded Card Icons");
		}

		private void Start()
		{
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Expected O, but got Unknown
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Expected O, but got Unknown
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Expected O, but got Unknown
			Miscs.Log("[GearUp] Loading Card Asset");
			CardAssets = AssetUtils.LoadAssetBundleFromResources("gearup_cardprefab", typeof(GearUpCards).Assembly);
			CardAssets.LoadAsset<GameObject>("CardHolderObject").GetComponent<CardHolder>().RegisterCards();
			Miscs.Log("[GearUp] Done Loading Card Asset");
			GameModeManager.AddHook("GameStart", (Func<IGameModeHandler, IEnumerator>)GameStart);
			GameModeManager.AddHook("PointEnd", (Func<IGameModeHandler, IEnumerator>)PointEnd);
			GameModeManager.AddHook("PickStart", (Func<IGameModeHandler, IEnumerator>)OnPickStart);
			GameModeManager.AddHook("PlayerPickEnd", (Func<IGameModeHandler, IEnumerator>)OnPlayerPickEnd);
			GameModeManager.AddHook("PointStart", (Func<IGameModeHandler, IEnumerator>)PointStart);
			GameModeManager.AddHook("PickEnd", (Func<IGameModeHandler, IEnumerator>)LateExtraDrawEvent, 200);
			object obj = <>c.<>9__30_0;
			if (obj == null)
			{
				Action val = delegate
				{
					CardUtils.MakeExclusive("Arcane Conversion", "Flak Cannon");
					if ((Object)(object)CardUtils.GetCardInfo("Size Difference") != (Object)null)
					{
						CardInfo cardInfo = CardUtils.GetCardInfo("Size Difference");
						CardUtils.MakeExclusive("Size Difference", "Size Normalizer");
						List<CardCategory> val5 = Enumerable.ToList<CardCategory>((IEnumerable<CardCategory>)(object)cardInfo.categories);
						val5.Add(CardUtils.GearCategory.typeSizeMod);
						cardInfo.categories = val5.ToArray();
					}
					if ((Object)(object)CardUtils.GetCardInfo("Size Matters") != (Object)null)
					{
						CardInfo cardInfo2 = CardUtils.GetCardInfo("Size Matters");
						CardUtils.MakeExclusive("Size Matters", "Size Normalizer");
						List<CardCategory> val6 = Enumerable.ToList<CardCategory>((IEnumerable<CardCategory>)(object)cardInfo2.categories);
						val6.Add(CardUtils.GearCategory.typeSizeMod);
						cardInfo2.categories = val6.ToArray();
					}
					CardUtils.MakeExclusive("Gatling Gun", "Flak Cannon");
					if ((Object)(object)CardUtils.GetCardInfo("Plasma Rifle") != (Object)null)
					{
						CardInfo cardInfo3 = CardUtils.GetCardInfo("Plasma Rifle");
						CardUtils.MakeExclusive("Plasma Rifle", "Flak Cannon");
						List<CardCategory> val7 = Enumerable.ToList<CardCategory>((IEnumerable<CardCategory>)(object)cardInfo3.categories);
						val7.Add(CardUtils.GearCategory.typeGunMod);
						cardInfo3.categories = val7.ToArray();
					}
					if ((Object)(object)CardUtils.GetCardInfo("Plasma Shotgun") != (Object)null)
					{
						CardInfo cardInfo4 = CardUtils.GetCardInfo("Plasma Shotgun");
						CardUtils.MakeExclusive("Plasma Shotgun", "Flak Cannon");
						List<CardCategory> val8 = Enumerable.ToList<CardCategory>((IEnumerable<CardCategory>)(object)cardInfo4.categories);
						val8.Add(CardUtils.GearCategory.typeGunMod);
						cardInfo4.categories = val8.ToArray();
					}
					CardUtils.MakeExclusive("Fragmentation", "Flak Cannon");
					CardUtils.MakeExclusive("Fireworks", "Flak Cannon");
					CardUtils.MakeExclusive("Rolling Thunder", "Flak Cannon");
					CardUtils.MakeExclusive("Splitting Rounds", "Flak Cannon");
					if ((Object)(object)CardUtils.GetCardInfo("Pong") != (Object)null)
					{
						CardInfo cardInfo5 = CardUtils.GetCardInfo("Pong");
						CardUtils.MakeExclusive("Pong", "Flak Cannon");
						CardUtils.MakeExclusive("Pong", "Arc of Bullets");
						CardUtils.MakeExclusive("Pong", "Parallel Bullets");
						List<CardCategory> val9 = Enumerable.ToList<CardCategory>((IEnumerable<CardCategory>)(object)cardInfo5.categories);
						val9.Add(CardUtils.GearCategory.typeGunMod);
						val9.Add(CardUtils.GearCategory.typeUniqueGunSpread);
						cardInfo5.categories = val9.ToArray();
					}
					CardUtils.MakeExclusive("Hive", "Flak Cannon");
					CardUtils.MakeExclusive("Snake Attack", "Flak Cannon");
					if (Object.op_Implicit((Object)(object)CardUtils.GetCardInfo("Shock Blast")))
					{
						CardInfo cardInfo6 = CardUtils.GetCardInfo("Shock Blast");
						CardUtils.MakeExclusive("Shock Blast", "Flak Cannon");
						CardUtils.MakeExclusive("Shock Blast", "Arc of Bullets");
						CardUtils.MakeExclusive("Shock Blast", "Parallel Bullets");
						List<CardCategory> val10 = Enumerable.ToList<CardCategory>((IEnumerable<CardCategory>)(object)cardInfo6.categories);
						val10.Add(CardUtils.GearCategory.typeGunMod);
						val10.Add(CardUtils.GearCategory.typeUniqueGunSpread);
						cardInfo6.categories = val10.ToArray();
					}
					if (Object.op_Implicit((Object)(object)CardUtils.GetCardInfo("Mirror Mage")))
					{
						CardInfo cardInfo7 = CardUtils.GetCardInfo("Mirror Mage");
						CardUtils.MakeExclusive("Mirror Mage", "Flak Cannon");
						CardUtils.MakeExclusive("Mirror Mage", "Arc of Bullets");
						CardUtils.MakeExclusive("Mirror Mage", "Parallel Bullets");
						List<CardCategory> val11 = Enumerable.ToList<CardCategory>((IEnumerable<CardCategory>)(object)cardInfo7.categories);
						val11.Add(CardUtils.GearCategory.typeGunMod);
						val11.Add(CardUtils.GearCategory.typeUniqueGunSpread);
						cardInfo7.categories = val11.ToArray();
					}
					CardUtils.MakeExclusive("Arcane Conversion", "Piercing Bullets");
					CardUtils.MakeExclusive("Arcane Conversion", "Anonymity");
				};
				<>c.<>9__30_0 = val;
				obj = (object)val;
			}
			ExtensionMethods.ExecuteAfterFrames((MonoBehaviour)(object)this, 10, (Action)obj);
			object obj2 = <>c.<>9__30_1;
			if (obj2 == null)
			{
				Action val2 = delegate
				{
					//IL_0057: Unknown result type (might be due to invalid IL or missing references)
					//IL_005c: Unknown result type (might be due to invalid IL or missing references)
					IEnumerator<Rarity> enumerator = RarityUtils.Rarities.Values.GetEnumerator();
					try
					{
						while (((IEnumerator)enumerator).MoveNext())
						{
							Rarity current = enumerator.Current;
							CardUtils.rarityCategories.Add(current, CustomCardCategories.instance.CardCategory(String.Concat("__Rarity-", current.name)));
						}
					}
					finally
					{
						if (enumerator != null)
						{
							((IDisposable)enumerator).Dispose();
						}
					}
					Enumerator<string> enumerator2 = CardManager.categories.GetEnumerator();
					try
					{
						while (enumerator2.MoveNext())
						{
							string current2 = enumerator2.Current;
							CardUtils.packCategories.Add(current2, CustomCardCategories.instance.CardCategory(String.Concat("__Pack-", current2)));
						}
					}
					finally
					{
						((IDisposable)enumerator2).Dispose();
					}
				};
				<>c.<>9__30_1 = val2;
				obj2 = (object)val2;
			}
			ExtensionMethods.ExecuteAfterFrames((MonoBehaviour)(object)this, 65, (Action)obj2);
			object obj3 = <>c.<>9__30_2;
			if (obj3 == null)
			{
				Action val3 = delegate
				{
					GameObject[] array = Resources.FindObjectsOfTypeAll(typeof(GameObject)) as GameObject[];
					foreach (GameObject val4 in array)
					{
						if (((Object)val4).name == "Bullet_Base" && val4.CompareTag("Bullet"))
						{
							bulletObj = val4;
							break;
						}
					}
					MoveTransform component = bulletObj.GetComponent<MoveTransform>();
					ProjectileHit component2 = bulletObj.GetComponent<ProjectileHit>();
					if ((Object)(object)component != (Object)null && (Object)(object)component2 != (Object)null)
					{
						bulletObj.AddComponent<BulletVFXScale>();
						Miscs.Log("[GearUp] added experimental bullet VFX rescaler");
					}
				};
				<>c.<>9__30_2 = val3;
				obj3 = (object)val3;
			}
			ExtensionMethods.ExecuteAfterFrames((MonoBehaviour)(object)this, 95, (Action)obj3);
		}

		private void Update()
		{
			if (isCardPickingPhase && lastPickerID != CardChoice.instance.pickrID)
			{
				if (CardChoice.instance.pickrID >= 0)
				{
					CardUtils.ModifyPerPlayerCardRarity(CardChoice.instance.pickrID);
				}
				lastPickerID = CardChoice.instance.pickrID;
			}
		}

		[IteratorStateMachine(/*Could not decode attribute arguments.*/)]
		private IEnumerator GameStart(IGameModeHandler gm)
		{
			Enumerator<Player> enumerator = PlayerManager.instance.players.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					Player current = enumerator.Current;
					if (!CharacterStatModifiersExtension.GetAdditionalData(current.data.stats).blacklistedCategories.Contains(CardUtils.GearCategory.tagSpellOnlyAugment))
					{
						CharacterStatModifiersExtension.GetAdditionalData(current.data.stats).blacklistedCategories.Add(CardUtils.GearCategory.tagSpellOnlyAugment);
					}
					if (CharacterStatModifiersExtension.GetAdditionalData(current.data.stats).blacklistedCategories.Contains(CardUtils.GearCategory.typeUniqueGunSpread))
					{
						CharacterStatModifiersExtension.GetAdditionalData(current.data.stats).blacklistedCategories.Remove(CardUtils.GearCategory.typeUniqueGunSpread);
					}
					if (CharacterStatModifiersExtension.GetAdditionalData(current.data.stats).blacklistedCategories.Contains(CardUtils.GearCategory.typeSizeMod))
					{
						CharacterStatModifiersExtension.GetAdditionalData(current.data.stats).blacklistedCategories.Remove(CardUtils.GearCategory.typeSizeMod);
					}
					if (CharacterStatModifiersExtension.GetAdditionalData(current.data.stats).blacklistedCategories.Contains(CardUtils.GearCategory.typeUniqueMagick))
					{
						CharacterStatModifiersExtension.GetAdditionalData(current.data.stats).blacklistedCategories.Remove(CardUtils.GearCategory.typeUniqueMagick);
					}
				}
			}
			finally
			{
				((IDisposable)enumerator).Dispose();
			}
			CardUtils.raritySnapshot = new Dictionary<string, float>();
			if (CardUtils.cardCategoryHasRarity)
			{
				Enumerable.ToList<Card>((IEnumerable<Card>)(object)CardManager.cards.Values).ForEach((Action<Card>)delegate(Card card)
				{
					//IL_000a: Unknown result type (might be due to invalid IL or missing references)
					//IL_000f: Unknown result type (might be due to invalid IL or missing references)
					Enumerator<Rarity, CardCategory> enumerator3 = CardUtils.rarityCategories.Values.GetEnumerator();
					try
					{
						while (enumerator3.MoveNext())
						{
							CardCategory current3 = enumerator3.Current;
							List<CardCategory> val2 = new List<CardCategory>((IEnumerable<CardCategory>)(object)card.cardInfo.categories);
							if (val2.Contains(current3))
							{
								val2.Remove(current3);
								CardCategory[] categories2 = val2.ToArray();
								card.cardInfo.categories = categories2;
								break;
							}
						}
					}
					finally
					{
						((IDisposable)enumerator3).Dispose();
					}
				});
				CardUtils.cardCategoryHasRarity = false;
			}
			Enumerable.ToList<Card>((IEnumerable<Card>)(object)CardManager.cards.Values).ForEach((Action<Card>)delegate(Card card)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				Rarity rarityData = RarityUtils.GetRarityData(card.cardInfo.rarity);
				CardCategory val = CardUtils.rarityCategories[rarityData];
				CardCategory[] categories = CollectionExtensions.AddToArray<CardCategory>(card.cardInfo.categories, val);
				card.cardInfo.categories = categories;
			});
			CardUtils.cardCategoryHasRarity = true;
			Enumerator<int, ObjectsToSpawn> enumerator2 = MysticMissileCard.objectSpawnDict.Values.GetEnumerator();
			try
			{
				while (enumerator2.MoveNext())
				{
					ObjectsToSpawn current2 = enumerator2.Current;
					Object.Destroy((Object)(object)current2.effect);
					Object.Destroy((Object)(object)current2.AddToProjectile);
				}
			}
			finally
			{
				((IDisposable)enumerator2).Dispose();
			}
			MysticMissileCard.objectSpawnDict.Clear();
			enumerator = PlayerManager.instance.players.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					ExtensionMethods.GetOrAddComponent<CardDrawTracker>(((Component)enumerator.Current).gameObject, false);
				}
			}
			finally
			{
				((IDisposable)enumerator).Dispose();
			}
			GearUpPreRoundEffects.instanceList.Clear();
			yield break;
		}

		[IteratorStateMachine(/*Could not decode attribute arguments.*/)]
		private IEnumerator OnPickStart(IGameModeHandler gm)
		{
			Miscs.Log("\n[GearUp] OnPickStart()");
			isCardPickingPhase = true;
			yield break;
		}

		[IteratorStateMachine(/*Could not decode attribute arguments.*/)]
		private IEnumerator OnPlayerPickEnd(IGameModeHandler gm)
		{
			Miscs.Log("\n[GearUp] OnPickEnd()");
			CardUtils.RarityDelta.UndoAll();
			yield return new WaitForSecondsRealtime(0.1f);
			if (isCardExtraDrawPhase || CardDrawTracker.extraDrawPlayerQueue.Count <= 0)
			{
				yield break;
			}
			isCardExtraDrawPhase = true;
			Miscs.Log("[GearUp] Extra draw locked in");
			for (int i = 0; i < CardDrawTracker.extraDrawPlayerQueue.Count; i++)
			{
				string text = ((Int32)(ref i)).ToString();
				Player obj = CardDrawTracker.extraDrawPlayerQueue[i];
				Miscs.Log(String.Concat("Checking ", text, " | ", (obj != null) ? ((Object)obj).ToString() : null));
				CardDrawTracker component = ((Component)CardDrawTracker.extraDrawPlayerQueue[i]).gameObject.GetComponent<CardDrawTracker>();
				if ((Object)(object)component != (Object)null)
				{
					yield return component.ResolveExtraDraws();
					yield return new WaitForSecondsRealtime(0.1f);
				}
				string text2 = ((Int32)(ref i)).ToString();
				Player obj2 = CardDrawTracker.extraDrawPlayerQueue[i];
				Miscs.Log(String.Concat("Checked! ", text2, " | ", (obj2 != null) ? ((Object)obj2).ToString() : null));
			}
			CardDrawTracker.extraDrawPlayerQueue.Clear();
			if (CardDrawTracker.extraDrawPlayerQueue_Late.Count > 0)
			{
				Enumerator<Player> enumerator = CardDrawTracker.extraDrawPlayerQueue_Late.GetEnumerator();
				try
				{
					while (enumerator.MoveNext())
					{
						Player current = enumerator.Current;
						CardDrawTracker.extraDrawPlayerQueue.Add(current);
					}
				}
				finally
				{
					((IDisposable)enumerator).Dispose();
				}
				CardDrawTracker.extraDrawPlayerQueue_Late.Clear();
			}
			isCardExtraDrawPhase = false;
			Miscs.Log("[GearUp] Extra draw unlocked");
		}

		[IteratorStateMachine(/*Could not decode attribute arguments.*/)]
		private IEnumerator LateExtraDrawEvent(IGameModeHandler gm)
		{
			Miscs.Log("\n[GearUp] LateExtraDrawEvent()");
			yield return new WaitForSecondsRealtime(0.1f);
			if (!isCardExtraDrawPhase && CardDrawTracker.extraDrawPlayerQueue.Count > 0)
			{
				isCardExtraDrawPhase = true;
				Miscs.Log("[GearUp] Late Extra draw locked in");
				for (int i = 0; i < CardDrawTracker.extraDrawPlayerQueue.Count; i++)
				{
					string text = ((Int32)(ref i)).ToString();
					Player obj = CardDrawTracker.extraDrawPlayerQueue[i];
					Miscs.Log(String.Concat("Checking ", text, " | ", (obj != null) ? ((Object)obj).ToString() : null));
					CardDrawTracker component = ((Component)CardDrawTracker.extraDrawPlayerQueue[i]).gameObject.GetComponent<CardDrawTracker>();
					if ((Object)(object)component != (Object)null)
					{
						yield return component.ResolveExtraDraws(resolveLateDraw: true);
						yield return new WaitForSecondsRealtime(0.1f);
					}
					string text2 = ((Int32)(ref i)).ToString();
					Player obj2 = CardDrawTracker.extraDrawPlayerQueue[i];
					Miscs.Log(String.Concat("Checked! ", text2, " | ", (obj2 != null) ? ((Object)obj2).ToString() : null));
				}
				CardDrawTracker.extraDrawPlayerQueue.Clear();
				isCardExtraDrawPhase = false;
				Miscs.Log("[GearUp] Late Extra draw unlocked");
			}
			GearUpPreRoundEffects.TriggerStatsMods();
		}

		[IteratorStateMachine(/*Could not decode attribute arguments.*/)]
		private IEnumerator PointEnd(IGameModeHandler gm)
		{
			MapUtils.ClearMapObjectsList();
			yield break;
		}

		[IteratorStateMachine(/*Could not decode attribute arguments.*/)]
		private IEnumerator PointStart(IGameModeHandler gm)
		{
			isCardPickingPhase = false;
			yield break;
		}
	}
}
namespace GearUpCards.Utils
{
	public class CardUtils : Object
	{
		public static class GearCategory : Object
		{
			public static CardCategory noType = CustomCardCategories.instance.CardCategory("GearUp_Unspecified");

			public static CardCategory uniqueCardSheriff = CustomCardCategories.instance.CardCategory("GearUp_Unique-Sheriff");

			public static CardCategory typeGunMod = CustomCardCategories.instance.CardCategory("GearUp_Gun-Mod");

			public static CardCategory typeBlockMod = CustomCardCategories.instance.CardCategory("GearUp_Block-Mod");

			public static CardCategory typeSizeMod = CustomCardCategories.instance.CardCategory("GearUp_Size-Mod");

			public static CardCategory typeUniqueMagick = CustomCardCategories.instance.CardCategory("GearUp_Unique-Magick");

			public static CardCategory typeUniqueGunSpread = CustomCardCategories.instance.CardCategory("GearUp_Unique-Gun-Spread");

			public static CardCategory typeUniqueCAD = CustomCardCategories.instance.CardCategory("GearUp_Unique-CAD");

			public static CardCategory typeParts = CustomCardCategories.instance.CardCategory("GearUp_Parts");

			public static CardCategory typeCharm = CustomCardCategories.instance.CardCategory("GearUp_Charm");

			public static CardCategory typeGear = CustomCardCategories.instance.CardCategory("GearUp_Gear");

			public static CardCategory typeGlyph = CustomCardCategories.instance.CardCategory("GearUp_Glyph");

			public static CardCategory typeSpell = CustomCardCategories.instance.CardCategory("GearUp_Spell");

			public static CardCategory typeCadModule = CustomCardCategories.instance.CardCategory("GearUp_CAD-Module");

			public static CardCategory typeBoosterPack = CustomCardCategories.instance.CardCategory("GearUp_Booster-Pack");

			public static CardCategory typeCardShuffle = CustomCardCategories.instance.CardCategory("GearUp_Card-Shuffle");

			public static CardCategory tagCardManipulation = CustomCardCategories.instance.CardCategory("CardManipulation");

			public static CardCategory tagNoGlitch = CustomCardCategories.instance.CardCategory("NoRandom");

			public static CardCategory tagNoRemove = CustomCardCategories.instance.CardCategory("NoRemove");

			public static CardCategory tagNoTableFlip = CustomCardCategories.instance.CardCategory("NoFlip");

			public static CardCategory tagNoEternity = CustomCardCategories.instance.CardCategory("cantEternity");

			public static CardCategory tagSpellOnlyAugment = CustomCardCategories.instance.CardCategory("GearUp_Spell-Only-Augment");

			internal static List<CardCategory> __gearCategories = null;

			public static List<CardCategory> GearCategories
			{
				get
				{
					if (__gearCategories == null)
					{
						List<CardCategory> obj = new List<CardCategory>();
						obj.Add(noType);
						obj.Add(typeBoosterPack);
						obj.Add(typeCardShuffle);
						obj.Add(typeGunMod);
						obj.Add(typeBlockMod);
						obj.Add(typeSizeMod);
						obj.Add(typeUniqueMagick);
						obj.Add(typeUniqueGunSpread);
						obj.Add(typeUniqueCAD);
						obj.Add(typeParts);
						obj.Add(typeCharm);
						obj.Add(typeGear);
						obj.Add(typeGlyph);
						obj.Add(typeSpell);
						obj.Add(typeCadModule);
						__gearCategories = obj;
					}
					return __gearCategories;
				}
			}
		}

		public class PlayerCardData : Object
		{
			public CardInfo cardInfo;

			public Player owner;

			public int index;

			public PlayerCardData(CardInfo cardInfo, Player owner, int index)
			{
				this.cardInfo = cardInfo;
				this.owner = owner;
				this.index = index;
			}
		}

		public class RarityDelta : Object
		{
			private static List<RarityDelta> rarityDeltas = new List<RarityDelta>();

			private CardInfo cardInfo;

			private float addDelta;

			private float mulDelta;

			private RarityDelta(CardInfo cardInfo, float add = 0f, float mul = 0f)
			{
				this.cardInfo = cardInfo;
				addDelta = add;
				mulDelta = mul;
			}

			private void Undo()
			{
				if ((Object)(object)cardInfo != (Object)null)
				{
					RarityUtils.AjustCardRarityModifier(cardInfo, -1f * addDelta, -1f * mulDelta);
					addDelta = 0f;
					mulDelta = 0f;
				}
			}

			public static void AdjustRarityModifier(CardInfo cardInfo, float add = 0f, float mul = 0f)
			{
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)cardInfo == (Object)null)
				{
					return;
				}
				RarityUtils.AjustCardRarityModifier(cardInfo, add, mul);
				RarityDelta rarityDelta = null;
				Enumerator<RarityDelta> enumerator = rarityDeltas.GetEnumerator();
				try
				{
					while (enumerator.MoveNext())
					{
						RarityDelta current = enumerator.Current;
						if ((Object)(object)current.cardInfo == (Object)(object)cardInfo)
						{
							rarityDelta = current;
							break;
						}
					}
				}
				finally
				{
					((IDisposable)enumerator).Dispose();
				}
				if (rarityDelta == null)
				{
					rarityDeltas.Add(new RarityDelta(cardInfo, add, mul));
					return;
				}
				rarityDelta.addDelta += add;
				rarityDelta.mulDelta += mul;
			}

			public static void UndoAll()
			{
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				if (rarityDeltas == null)
				{
					return;
				}
				Enumerator<RarityDelta> enumerator = rarityDeltas.GetEnumerator();
				try
				{
					while (enumerator.MoveNext())
					{
						enumerator.Current.Undo();
					}
				}
				finally
				{
					((IDisposable)enumerator).Dispose();
				}
				rarityDeltas.Clear();
			}
		}

		public class DestroyOnUnparent : MonoBehaviour
		{
			private void LateUpdate()
			{
				if ((Object)(object)((Component)this).gameObject.transform.parent == (Object)null)
				{
					Object.Destroy((Object)(object)((Component)this).gameObject);
				}
			}
		}

		internal class ExtraName : MonoBehaviour
		{
			private static GameObject _extraTextObj;

			public string text = "";

			internal static GameObject extraTextObj
			{
				get
				{
					//IL_0038: Unknown result type (might be due to invalid IL or missing references)
					//IL_0042: Expected O, but got Unknown
					if ((Object)(object)_extraTextObj != (Object)null)
					{
						return _extraTextObj;
					}
					_extraTextObj = new GameObject("ExtraCardText", (Type[])(object)new Type[2]
					{
						typeof(TextMeshProUGUI),
						typeof(DestroyOnUnparent)
					});
					Object.DontDestroyOnLoad((Object)(object)_extraTextObj);
					return _extraTextObj;
				}
				private set
				{
				}
			}

			public void Start()
			{
				//IL_0045: Unknown result type (might be due to invalid IL or missing references)
				//IL_0050: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
				GameObject gameObject = ((Component)Enumerable.FirstOrDefault<RectTransform>(Enumerable.Where<RectTransform>((IEnumerable<RectTransform>)(object)((Component)this).gameObject.GetComponentsInChildren<RectTransform>(), (Func<RectTransform, bool>)((RectTransform obj) => ((Object)((Component)obj).gameObject).name == "EdgePart (1)")))).gameObject;
				GameObject obj2 = Object.Instantiate<GameObject>(extraTextObj, gameObject.transform.position, gameObject.transform.rotation, gameObject.transform);
				TextMeshProUGUI component = obj2.gameObject.GetComponent<TextMeshProUGUI>();
				((TMP_Text)component).text = text;
				((TMP_Text)component).enableWordWrapping = false;
				obj2.transform.Rotate(0f, 0f, 135f);
				obj2.transform.localScale = new Vector3(1f, 1f, 1f);
				obj2.transform.localPosition = new Vector3(-50f, -50f, 0f);
				((TMP_Text)component).alignment = (TextAlignmentOptions)1026;
				((TMP_Text)component).alpha = 0.1f;
				((TMP_Text)component).fontSize = 50f;
			}
		}

		public static bool cardCategoryHasRarity = false;

		public static Dictionary<Rarity, CardCategory> rarityCategories = new Dictionary<Rarity, CardCategory>();

		public static Dictionary<string, CardCategory> packCategories = new Dictionary<string, CardCategory>();

		public static List<string> gearUpRarityChecklist;

		public static Dictionary<string, float> raritySnapshot;

		public static List<string> cardListSpells;

		public static List<string> cardListGlyph;

		public static List<string> cardListVanillaBlocks;

		public static List<string> cardListModdedBlocks;

		public static Rarity TryQueryRarity(string query, string failSafe)
		{
			//IL_0011: 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_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			List<Rarity> val = new List<Rarity>((IEnumerable<Rarity>)(object)rarityCategories.Keys);
			Enumerator<Rarity> enumerator = val.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					Rarity current = enumerator.Current;
					if (current.name == query)
					{
						return current;
					}
				}
			}
			finally
			{
				((IDisposable)enumerator).Dispose();
			}
			enumerator = val.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					Rarity current2 = enumerator.Current;
					if (current2.name == failSafe)
					{
						return current2;
					}
				}
			}
			finally
			{
				((IDisposable)enumerator).Dispose();
			}
			return RarityUtils.GetRarityData((Rarity)0);
		}

		public static bool PlayerHasCard(Player player, string cardName)
		{
			return GetPlayerCardsWithName(player, cardName).Count > 0;
		}

		public static bool PlayerHasCardCategory(Player player, CardCategory cardCategory)
		{
			return GetPlayerCardsWithCategory(player, cardCategory).Count > 0;
		}

		public static List<PlayerCardData> GetPlayerCardsWithName(Player player, string targetCardName)
		{
			targetCardName = targetCardName.ToUpper();
			List<PlayerCardData> val = new List<PlayerCardData>();
			List<CardInfo> currentCards = player.data.currentCards;
			for (int i = 0; i < currentCards.Count; i++)
			{
				if (currentCards[i].cardName.ToUpper().Equals(targetCardName))
				{
					val.Add(new PlayerCardData(currentCards[i], player, i));
				}
			}
			return val;
		}

		public static List<PlayerCardData> GetPlayerCardsWithCategory(Player player, CardCategory targetCategory)
		{
			List<PlayerCardData> val = new List<PlayerCardData>();
			List<CardInfo> currentCards = player.data.currentCards;
			for (int i = 0; i < currentCards.Count; i++)
			{
				bool flag = false;
				CardCategory[] categoriesFromCard = CustomCardCategories.instance.GetCategoriesFromCard(currentCards[i]);
				foreach (CardCategory val2 in categoriesFromCard)
				{
					if ((Object)(object)targetCategory == (Object)(object)val2)
					{
						flag = true;
						break;
					}
				}
				if (flag)
				{
					val.Add(new PlayerCardData(currentCards[i], player, i));
				}
			}
			return val;
		}

		public static CardInfo GetCardInfo(string modInitial, string cardNameExact)
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			string text = String.Concat("__", modInitial, "__", cardNameExact);
			List<CardInfo> obj = Enumerable.ToList<CardInfo>(Enumerable.Select<Card, CardInfo>((IEnumerable<Card>)(object)CardManager.cards.Values, (Func<Card, CardInfo>)((Card c) => c.cardInfo)));
			CardInfo result = null;
			Enumerator<CardInfo> enumerator = obj.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					CardInfo current = enumerator.Current;
					if (((Object)((Component)current).gameObject).name.Contains(text))
					{
						result = current;
						break;
					}
				}
			}
			finally
			{
				((IDisposable)enumerator).Dispose();
			}
			return result;
		}

		public static CardInfo GetCardInfo(string query, bool searchVanillaOnly = false)
		{
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			if (query.Contains("@"))
			{
				List<string> val = Miscs.StringSplit(query, '@');
				if (val.Count == 2)
				{
					if (val[0] == "")
					{
						return GetCardInfo(val[1]);
					}
					if (val[0] == "Vanilla")
					{
						return GetCardInfo(val[1], searchVanillaOnly: true);
					}
					return GetCardInfo(val[0], val[1]);
				}
				Miscs.LogWarn(">> query splitting failed");
				query = val[0];
			}
			query = CardNameSanitize(query, removeWhitespaces: true);
			List<CardInfo> obj = Enumerable.ToList<CardInfo>(Enumerable.Select<Card, CardInfo>((IEnumerable<Card>)(object)CardManager.cards.Values, (Func<Card, CardInfo>)((Card c) => c.cardInfo)));
			CardInfo result = null;
			int num = 0;
			Enumerator<CardInfo> enumerator = obj.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					CardInfo current = enumerator.Current;
					string text = CardNameSanitize(((Object)((Component)current).gameObject).name, removeWhitespaces: true);
					if (searchVanillaOnly && text.Contains("__"))
					{
						continue;
					}
					text = CardNameSanitize(current.cardName, removeWhitespaces: true);
					if (text.Equals(query))
					{
						result = current;
						num = 9999;
						break;
					}
					if (text.Contains(query))
					{
						int num2 = Miscs.ValidateStringQuery(text, query);
						if (num2 > num)
						{
							num = num2;
							result = current;
						}
					}
				}
			}
			finally
			{
				((IDisposable)enumerator).Dispose();
			}
			return result;
		}

		public static List<PlayerCardData> GetPlayerCardsWithCardInfo(Player player, CardInfo cardInfo)
		{
			string text = ((Object)((Component)cardInfo).gameObject).name.ToUpper();
			List<PlayerCardData> val = new List<PlayerCardData>();
			List<CardInfo> currentCards = player.data.currentCards;
			for (int i = 0; i < currentCards.Count; i++)
			{
				if (((Object)((Component)currentCards[i]).gameObject).name.ToUpper().Equals(text))
				{
					val.Add(new PlayerCardData(currentCards[i], player, i));
				}
			}
			return val;
		}

		public static List<PlayerCardData> GetPlayerCardsWithStringList(Player player, List<string> checkList)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			List<PlayerCardData> val = new List<PlayerCardData>();
			_ = player.data.currentCards;
			Enumerator<string> enumerator = checkList.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					CardInfo cardInfo = GetCardInfo(enumerator.Current);
					if (!((Object)(object)cardInfo == (Object)null))
					{
						val = Enumerable.ToList<PlayerCardData>(Enumerable.Concat<PlayerCardData>((IEnumerable<PlayerCardData>)(object)val, (IEnumerable<PlayerCardData>)(object)GetPlayerCardsWithCardInfo(player, cardInfo)));
					}
				}
				return val;
			}
			finally
			{
				((IDisposable)enumerator).Dispose();
			}
		}

		public static void SaveCardRarity()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: 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_00c3: Unknown result type (might be due to invalid IL or missing references)
			Miscs.Log("[GearUp] SaveGearUpCardRarity()");
			Enumerator<string> enumerator = gearUpRarityChecklist.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					string current = enumerator.Current;
					string text = String.Concat("GearUP@", current);
					CardInfo cardInfo = GetCardInfo(text);
					if (!((Object)(object)cardInfo == (Object)null))
					{
						raritySnapshot[text] = RarityUtils.GetCardRarityModifier(cardInfo);
					}
				}
			}
			finally
			{
				((IDisposable)enumerator).Dispose();
			}
			enumerator = cardListVanillaBlocks.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					string current2 = enumerator.Current;
					CardInfo cardInfo = GetCardInfo(current2);
					if (!((Object)(object)cardInfo == (Object)null))
					{
						raritySnapshot[current2] = RarityUtils.GetCardRarityModifier(cardInfo);
					}
				}
			}
			finally
			{
				((IDisposable)enumerator).Dispose();
			}
			enumerator = cardListModdedBlocks.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					string current3 = enumerator.Current;
					CardInfo cardInfo = GetCardInfo(current3);
					if (!((Object)(object)cardInfo == (Object)null))
					{
						raritySnapshot[current3] = RarityUtils.GetCardRarityModifier(cardInfo);
					}
				}
			}
			finally
			{
				((IDisposable)enumerator).Dispose();
			}
		}

		public static void RestoreGearUpCardRarity()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			Miscs.Log("[GearUp] RestoreGearUpCardRarity()");
			Enumerator<string, float> enumerator = raritySnapshot.Keys.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					string current = enumerator.Current;
					CardInfo cardInfo = GetCardInfo(current);
					if (!((Object)(object)cardInfo == (Object)null))
					{
						float cardRarityModifier = RarityUtils.GetCardRarityModifier(cardInfo);
						RarityUtils.AjustCardRarityModifier(cardInfo, 0f, -1f * (cardRarityModifier / raritySnapshot[current] - 1f));
					}
				}
			}
			finally
			{
				((IDisposable)enumerator).Dispose();
			}
		}

		public static void BatchAdjustCardRarity(List<string> cardList, float add = 0f, float mul = 0f)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			Enumerator<string> enumerator = cardList.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					CardInfo cardInfo = GetCardInfo(enumerator.Current);
					if (!((Object)(object)cardInfo == (Object)null))
					{
						RarityDelta.AdjustRarityModifier(cardInfo, add, mul);
					}
				}
			}
			finally
			{
				((IDisposable)enumerator).Dispose();
			}
		}

		public static void ModifyPerPlayerCardRarity(int pickerID)
		{
			//IL_0011: 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)
			Player val = null;
			if (pickerID <= -1)
			{
				return;
			}
			Enumerator<Player> enumerator = PlayerManager.instance.players.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					Player current = enumerator.Current;
					if (current.playerID == pickerID)
					{
						val = current;
						break;
					}
				}
			}
			finally
			{
				((IDisposable)enumerator).Dispose();
			}
			if (!((Object)(object)val == (Object)null))
			{
				CharacterStatModifiersGearData gearData = ((Component)val).gameObject.GetComponent<CharacterStatModifiers>().GetGearData();
				float num = 0f;
				num += (float)gearData.glyphDivination * 2f;
				num += (float)gearData.glyphGeometric * 0.5f;
				num += (float)gearData.glyphInfluence * 2.5f;
				num += (float)gearData.glyphPotency * 0.5f;
				num += (float)gearData.glyphMagickFragment * 0.75f;
				num += (float)gearData.glyphTime * 0.5f;
				num += (float)gearData.glyphReplication * 0.5f;
				if (gearData.addOnList.Contains(GearUpConstants.AddOnType.cadModuleGlyph))
				{
					BatchAdjustCardRarity(cardListGlyph, 0f, 2f);
				}
				else
				{
					RarityDelta.AdjustRarityModifier(GetCardInfo("GearUP", "Glyph CAD Module"), 0f, num * 1.5f - 0.75f);
				}
				BatchAdjustCardRarity(cardListSpells, 0f, num);
				RarityDelta.AdjustRarityModifier(GetCardInfo("GearUP", "Pure Canvas"), 0f, num * 0.5f - 0.5f);
				num = (float)gearData.orbLifeforceDualityStack * 0.5f;
				num += (float)gearData.orbLifeforceBlastStack * 0.5f;
				num += (float)gearData.orbObliterationStack * 0.5f;
				num += (float)gearData.orbRollingBulwarkStack * 0.5f;
				num += (float)gearData.arcaneSunStack * 0.5f;
				num += (float)gearData.mysticMissileStack * 0.5f;
				if (gearData.uniqueMagick != GearUpConstants.ModType.disabled && gearData.uniqueMagick != GearUpConstants.ModType.none)
				{
					num += 2f;
				}
				BatchAdjustCardRarity(cardListGlyph, 0f, num);
				RarityDelta.AdjustRarityModifier(GetCardInfo("GearUP", "Pure Canvas"), 0f, num * 0.5f);
				num = (float)gearData.shieldBatteryStack * 0.25f;
				num += (float)GetPlayerCardsWithName(val, "Empower").Count * 0.25f;
				num += (float)gearData.glyphMagickFragment * 0.5f;
				RarityDelta.AdjustRarityModifier(GetCardInfo("GearUP", "Shield Battery"), 0f, num * 2f);
				RarityDelta.AdjustRarityModifier(GetCardInfo("Empower", searchVanillaOnly: true), 0f, num * 2f);
				if (gearData.addOnList.Contains(GearUpConstants.AddOnType.charmGuardian))
				{
					BatchAdjustCardRarity(cardListVanillaBlocks, 0f, num * 2f);
					BatchAdjustCardRarity(cardListModdedBlocks, 0f, num);
				}
				List<PlayerCardData> playerCardsWithStringList = GetPlayerCardsWithStringList(val, cardListVanillaBlocks);
				num = (float)playerCardsWithStringList.Count * 0.2f;
				playerCardsWithStringList = GetPlayerCardsWithStringList(val, cardListModdedBlocks);
				num += (float)playerCardsWithStringList.Count * 0.1f;
				RarityDelta.AdjustRarityModifier(GetCardInfo("GearUP", "Shield Battery"), 0f, num);
				RarityDelta.AdjustRarityModifier(GetCardInfo("Empower", searchVanillaOnly: true), 0f, num);
				if (gearData.addOnList.Contains(GearUpConstants.AddOnType.charmGuardian))
				{
					BatchAdjustCardRarity(cardListVanillaBlocks, 0f, num * 2f + 3f);
					BatchAdjustCardRarity(cardListModdedBlocks, 0f, num + 1.5f);
				}
				num = 0f;
				float maxHealth = PlayerManager.instance.players[pickerID].data.maxHealth;
				if (maxHealth < 100f)
				{
					num += 2f * (100f - maxHealth) / 100f;
				}
				else if (maxHealth > 500f)
				{
					num -= (maxHealth - 500f) / 500f;
				}
				num = Mathf.Clamp(num, -0.999f, 3f);
				Miscs.Log(String.Concat("[GearUp] MEDIC!!! weight mul delta : ", ((Single)(ref num)).ToString()));
				RarityDelta.AdjustRarityModifier(GetCardInfo("GearUP", "Medic!!!"), 0f, num);
				float cardRarityModifier = RarityUtils.GetCardRarityModifier(GetCardInfo("GearUP", "Medic!!!"));
				Miscs.Log(String.Concat("[GearUp] MEDIC!!! current weight : ", ((Single)(ref cardRarityModifier)).ToString()));
				if (cardRarityModifier < 0f)
				{
					RarityDelta.AdjustRarityModifier(GetCardInfo("GearUP", "Medic!!!"), 0.0001f - cardRarityModifier);
					Miscs.LogWarn("[GearUp] MEDIC!!! weight gone negative!");
				}
			}
		}

		public static string CardNameSanitize(string name, bool removeWhitespaces = false)
		{
			string text = name.ToLower();
			if (removeWhitespaces)
			{
				text = text.Replace(" ", "");
			}
			return text;
		}

		public static void MakeExclusive(string cardA, string cardB)
		{
			CardInfo cardInfo = GetCardInfo(cardA);
			CardInfo cardInfo2 = GetCardInfo(cardB);
			if ((Object)(object)cardInfo != (Object)null && (Object)(object)cardInfo2 != (Object)null)
			{
				CustomCardCategories.instance.MakeCardsExclusive(cardInfo, cardInfo2);
				Miscs.LogInfo(String.Concat((string[])(object)new String[5] { "[GearUp] MakeExclusive: card [", cardA, "] and card [", cardB, "] made exclusive" }));
			}
			else
			{
				if ((Object)(object)cardInfo == (Object)null)
				{
					Miscs.Log(String.Concat("[GearUp] MakeExclusive: card [", cardA, "] not found"));
				}
				if ((Object)(object)cardInfo2 == (Object)null)
				{
					Miscs.Log(String.Concat("[GearUp] MakeExclusive: card [", cardB, "] not found"));
				}
			}
		}

		static CardUtils()
		{
			List<string> obj = new List<string>();
			obj.Add("Anti-Bullet Magick");
			obj.Add("Orb-literation!");
			obj.Add("Rolling Borbwark");
			obj.Add("Lifeforce Duorbity");
			obj.Add("Lifeforce Blast!");
			obj.Add("Arcane Sun");
			obj.Add("Mystic Missile!");
			obj.Add("Divination Glyph");
			obj.Add("Geometric Glyph");
			obj.Add("Influence Glyph");
			obj.Add("Magick Fragments");
			obj.Add("Potency Glyph");
			obj.Add("Time Glyph");
			obj.Add("Replication Glyph");
			obj.Add("Protection Glyph");
			obj.Add("Tiberium Bullet");
			obj.Add("Glyph CAD Module");
			obj.Add("Shield Battery");
			obj.Add("Pure Canvas");
			gearUpRarityChecklist = obj;
			raritySnapshot = new Dictionary<string, float>();
			List<string> obj2 = new List<string>();
			obj2.Add("Anti-Bullet Magick");
			obj2.Add("Orb-literation!");
			obj2.Add("Rolling Borbwark");
			obj2.Add("Lifeforce Duorbity");
			obj2.Add("Lifeforce Blast!");
			obj2.Add("Arcane Sun");
			obj2.Add("Mystic Missile!");
			cardListSpells = obj2;
			List<string> obj3 = new List<string>();
			obj3.Add("Divination Glyph");
			obj3.Add("Geometric Glyph");
			obj3.Add("Influence Glyph");
			obj3.Add("Magick Fragments");
			obj3.Add("Potency Glyph");
			obj3.Add("Time Glyph");
			obj3.Add("Replication Glyph");
			obj3.Add("Protection Glyph");
			cardListGlyph = obj3;
			List<string> obj4 = new List<string>();
			obj4.Add("Vanilla@Empower");
			obj4.Add("Vanilla@Bombs Away");
			obj4.Add("Vanilla@Defender");
			obj4.Add("Vanilla@EMP");
			obj4.Add("Vanilla@Frost Slam");
			obj4.Add("Vanilla@Healing Field");
			obj4.Add("Vanilla@Implode");
			obj4.Add("Vanilla@Overpower");
			obj4.Add("Vanilla@Radar Shot");
			obj4.Add("Vanilla@Saw");
			obj4.Add("Vanilla@Shield Charge");
			obj4.Add("Vanilla@Shockwave");
			obj4.Add("Vanilla@Silence");
			obj4.Add("Vanilla@Static Field");
			obj4.Add("Vanilla@Supernova");
			obj4.Add("Vanilla@Teleport");
			cardListVanillaBlocks = obj4;
			List<string> obj5 = new List<string>();
			obj5.Add("GearUP@Magick Fragments");
			obj5.Add("GearUP@Shield Battery");
			obj5.Add("GearUP@Tactical Scanner");
			obj5.Add("GearUP@Desolation");
			obj5.Add("GearUP@Rolling Borbwark");
			obj5.Add("GearUP@Protection Glyph");
			obj5.Add("Cards+@Turtle");
			obj5.Add("CR@Aqua Ring");
			obj5.Add("CR@Barrier");
			obj5.Add("CR@Gravity");
			obj5.Add("CR@Halo");
			obj5.Add("CR@Heartition");
			obj5.Add("CR@Hive");
			obj5.Add("CR@Holster");
			obj5.Add("CR@Ignite");
			obj5.Add("CR@Mitosis");
			obj5.Add("CR@Ping");
			obj5.Add("CR@Speed Up");
			obj5.Add("HDC@Divine Blessing");
			obj5.Add("HDC@Lil Defensive");
			obj5.Add("Root@Quick Shield");
			obj5.Add("PCE@Discombobulate");
			obj5.Add("PCE@Super Jump");
			cardListModdedBlocks = obj5;
		}
	}
	public class MapUtils : MonoBehaviour
	{
		public class MapObject : Object
		{
			public enum MapObjectType : Enum
			{
				invalid = -1,
				generic,
				background,
				buzzSaw,
				boxDestructible,
				mapExtendedWWMOZones
			}

			public GameObject gameObject;

			public MapObjectType type;

			public MapObject(GameObject gameObject, MapObjectType type)
			{
				this.gameObject = gameObject;
				this.type = type;
			}

			public static MapObjectType CheckMapObject(GameObject gameObject)
			{
				if (!gameObject.activeInHierarchy)
				{
					return MapObjectType.invalid;
				}
				if (Object.op_Implicit((Object)(object)gameObject.GetComponent<CircleCollider2D>()) && Object.op_Implicit((Object)(object)gameObject.GetComponent<DamageBox>()))
				{
					return MapObjectType.buzzSaw;
				}
				if (Object.op_Implicit((Object)(object)gameObject.GetComponent<PolygonCollider2D>()) && Object.op_Implicit((Object)(object)gameObject.GetComponent<DamageBox>()))
				{
					return MapObjectType.buzzSaw;
				}
				if (Object.op_Implicit((Object)(object)gameObject.GetComponent<BoxCollider2D>()) && Object.op_Implicit((Object)(object)gameObject.GetComponent<DestructibleBoxDestruction>()))
				{
					return MapObjectType.boxDestructible;
				}
				if (Object.op_Implicit((Object)(object)gameObject.GetComponent<SpriteRenderer>()) && ((Object)gameObject).name.Contains("WWMO.MapObjects") && Object.op_Implicit((Object)(object)gameObject.GetComponent<BoxCollider2D>()))
				{
					return MapObjectType.mapExtendedWWMOZones;
				}
				if (Object.op_Implicit((Object)(object)gameObject.GetComponent<SpriteRenderer>()) && Object.op_Implicit((Object)(object)gameObject.GetComponent<BoxCollider2D>()))
				{
					if (!((Behaviour)gameObject.GetComponent<SFPolygon>()).isActiveAndEnabled)
					{
						return MapObjectType.background;
					}
					return MapObjectType.generic;
				}
				if (Object.op_Implicit((Object)(object)gameObject.GetComponent<SpriteRenderer>()) && Object.op_Implicit((Object)(object)gameObject.GetComponent<CircleCollider2D>()))
				{
					if (!((Behaviour)gameObject.GetComponent<SFPolygon>()).isActiveAndEnabled)
					{
						return MapObjectType.background;
					}
					return MapObjectType.generic;
				}
				if (Object.op_Implicit((Object)(object)gameObject.GetComponent<SpriteRenderer>()) && Object.op_Implicit((Object)(object)gameObject.GetComponent<PolygonCollider2D>()))
				{
					if (!((Behaviour)gameObject.GetComponent<SFPolygon>()).isActiveAndEnabled)
					{
						return MapObjectType.background;
					}
					return MapObjectType.generic;
				}
				return MapObjectType.invalid;
			}
		}

		public static List<MapObject> mapObjects;

		public static Scene mapScene;

		[PunRPC]
		public static bool RPCA_UpdateMapObjectsList()
		{
			//IL_00a7: Expected O, but got Unknown
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (mapObjects != null)
				{
					ClearMapObjectsList();
				}
				mapScene = SceneManager.GetSceneAt(1);
				if (!((Scene)(ref mapScene)).IsValid())
				{
					return false;
				}
				GameObject val = ((Scene)(ref mapScene)).GetRootGameObjects()[0];
				if (!Object.op_Implicit((Object)(object)val))
				{
					return false;
				}
				Transform[] componentsInChildren = val.GetComponentsInChildren<Transform>();
				mapObjects = new List<MapObject>();
				Transform[] array = componentsInChildren;
				foreach (Transform val2 in array)
				{
					MapObject.MapObjectType mapObjectType = MapObject.CheckMapObject(((Component)val2).gameObject);
					if (mapObjectType != MapObject.MapObjectType.invalid)
					{
						mapObjects.Add(new MapObject(((Component)val2).gameObject, mapObjectType));
					}
				}
				return true;
			}
			catch (Exception val3)
			{
				Miscs.LogError("[GearUp] MapDestructionMono.RPCA_UpdateMapObjectsList failed and caught!");
				Miscs.LogError((object)val3);
				return false;
			}
		}

		[PunRPC]
		public static bool RPCA_DestroyMapObject(GameObject gameObject)
		{
			//IL_0026: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)gameObject == (Object)null)
			{
				Miscs.Log("[GearUp] RPCA_DestroyMapObject: Game object not loaded!");
				return false;
			}
			bool flag = RPCA_UpdateMapObjectsList();
			string name = ((Scene)(ref mapScene)).name;
			Scene scene = gameObject.scene;
			if (!name.Equals(((Scene)(ref scene)).name))
			{
				Miscs.Log("[GearUp] RPCA_DestroyMapObject: Not a map game object!");
				return false;
			}
			if (flag)
			{
				bool flag2 = false;
				Enumerator<MapObject> enumerator = mapObjects.GetEnumerator();
				try
				{
					while (enumerator.MoveNext())
					{
						if (enumerator.Current.gameObject == gameObject)
						{
							flag2 = true;
							break;
						}
					}
				}
				finally
				{
					((IDisposable)enumerator).Dispose();
				}
				if (flag2)
				{
					Miscs.Log(String.Concat("[GearUp] RPCA_DestroyMapObject: destroying [", ((Object)gameObject).name, "]"));
					Object.Destroy((Object)(object)gameObject);
					return true;
				}
				Miscs.Log("[GearUp] RPCA_DestroyMapObject: target game object not exist/valid!");
				return false;
			}
			return false;
		}

		public static bool RPCA_DestroyMapObjectsAtArea(Vector3 groundZero, float radius)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: 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_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			if (RPCA_UpdateMapObjectsList())
			{
				Miscs.Log(String.Format("[GearUp] Area Map Destroy Ground Zero: [{0}]", (object)groundZero));
				Enumerator<MapObject> enumerator = mapObjects.GetEnumerator();
				try
				{
					while (enumerator.MoveNext())
					{
						MapObject current = enumerator.Current;
						if (!((Object)(object)current.gameObject == (Object)null) && current.gameObject.activeInHierarchy)
						{
							Vector3 val = Vector3.Scale(current.gameObject.transform.position, new Vector3(1f, 1f, 0f)) - groundZero;
							if (((Vector3)(ref val)).magnitude <= radius)
							{
								Miscs.Log(String.Concat("[GearUp] RPCA_DestroyMapObject: destroying [", ((Object)current.gameObject).name, "]"));
								Object.Destroy((Object)(object)current.gameObject);
								current.gameObject = null;
							}
						}
					}
				}
				finally
				{
					((IDisposable)enumerator).Dispose();
				}
				return true;
			}
			return false;
		}

		public static void ClearMapObjectsList()
		{
			if (mapObjects != null)
			{
				mapObjects.Clear();
			}
			mapObjects = null;
		}

		public static bool CheckPointInMapObject(Vector3 position, List<MapObject.MapObjectType> ignoreList)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(position.x, position.y);
			bool result = false;
			if (ignoreList == null)
			{
				ignoreList = new List<MapObject.MapObjectType>();
			}
			Enumerator<MapObject> enumerator = mapObjects.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					MapObject current = enumerator.Current;
					if (!ignoreList.Contains(current.type))
					{
						Collider2D component = current.gameObject.GetComponent<Collider2D>();
						if ((Object)(object)component != (Object)null && component.OverlapPoint(val))
						{
							result = true;
							break;
						}
					}
				}
			}
			finally
			{
				((IDisposable)enumerator).Dispose();
			}
			return result;
		}
	}
	internal class Miscs : Object
	{
		public class RemoveAfterSpawn : MonoBehaviour
		{
			public float timeToRemove;

			private void Update()
			{
				if (!((Object)(object)((Component)this).gameObject.GetComponent<SpawnedAttack>() == (Object)null))
				{
					RemoveAfterSeconds orAddComponent = ExtensionMethods.GetOrAddComponent<RemoveAfterSeconds>(((Component)this).gameObject, false);
					orAddComponent.seconds = timeToRemove;
					((Behaviour)orAddComponent).enabled = true;
					Object.Destroy((Object)(object)this);
				}
			}
		}

		public class SetColorToParticles : MonoBehaviour
		{
			public List<ParticleSystem> particleSystems = new List<ParticleSystem>();

			private Dictionary<ParticleSystem, Gradient> backupGradients = new Dictionary<ParticleSystem, Gradient>();

			public Color targetColor;

			public bool overrideHue = true;

			private void Awake()
			{
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				//IL_0045: Unknown result type (might be due to invalid IL or missing references)
				//IL_004b: Expected O, but got Unknown
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0051: Unknown result type (might be due to invalid IL or missing references)
				//IL_0055: Unknown result type (might be due to invalid IL or missing references)
				//IL_005a: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
				//IL_0108: 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)
				particleSystems.Clear();
				backupGradients.Clear();
				particleSystems.AddRange((IEnumerable<ParticleSystem>)(object)((Component)this).gameObject.GetComponentsInChildren<ParticleSystem>());
				Enumerator<ParticleSystem> enumerator = particleSystems.GetEnumerator();
				try
				{
					while (enumerator.MoveNext())
					{
						ParticleSystem current = enumerator.Current;
						Gradient val = new Gradient();
						ColorOverLifetimeModule colorOverLifetime = current.colorOverLifetime;
						MinMaxGradient color = ((ColorOverLifetimeModule)(ref colorOverLifetime)).color;
						Gradient gradient = ((MinMaxGradient)(ref color)).gradient;
						val.alphaKeys = (GradientAlphaKey[])(object)new GradientAlphaKey[gradient.alphaKeys.Length];
						for (int i = 0; i < gradient.alphaKeys.Length; i++)
						{
							val.alphaKeys[i] = new GradientAlphaKey(gradient.alphaKeys[i].alpha, gradient.alphaKeys[i].time);
						}
						val.colorKeys = (GradientColorKey[])(object)new GradientColorKey[gradient.colorKeys.Length];
						for (int j = 0; j < gradient.colorKeys.Length; j++)
						{
							val.colorKeys[j] = new GradientColorKey(gradient.colorKeys[j].color, gradient.colorKeys[j].time);
						}
						if (!backupGradients.ContainsKey(current))
						{
							backupGradients.Add(current, val);
						}
					}
				}
				finally
				{
					((IDisposable)enumerator).Dispose();
				}
			}

			private void Update()
			{
				if (overrideHue)
				{
					SetHueAll();
				}
			}

			public void SetHueAll()
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				//IL_001f: 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_0028: Unknown result type (might be due to invalid IL or missing references)
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				//IL_0038: Expected O, but got Unknown
				//IL_0059: Unknown result type (might be due to invalid IL or missing references)
				//IL_006a: 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_009b: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c6: 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)
				//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
				Enumerator<ParticleSystem> enumerator = particleSystems.GetEnumerator();
				try
				{
					float num = default(float);
					float num2 = default(float);
					float num3 = default(float);
					float num4 = default(float);
					float num5 = default(float);
					while (enumerator.MoveNext())
					{
						ParticleSystem current = enumerator.Current;
						ColorOverLifetimeModule colorOverLifetime = current.colorOverLifetime;
						MinMaxGradient color = ((ColorOverLifetimeModule)(ref colorOverLifetime)).color;
						Gradient gradient = ((MinMaxGradient)(ref color)).gradient;
						Gradient val = new Gradient();
						GradientColorKey[] array = (GradientColorKey[])(object)new GradientColorKey[gradient.colorKeys.Length];
						for (int i = 0; i < gradient.colorKeys.Length; i++)
						{
							Color.RGBToHSV(gradient.colorKeys[i].color, ref num, ref num2, ref num3);
							Color.RGBToHSV(targetColor, ref num4, ref num, ref num5);
							array[i] = new GradientColorKey(Color.HSVToRGB(num4, num2, num3), gradient.colorKeys[i].time);
						}
						val.SetKeys(array, gradient.alphaKeys);
						ColorOverLifetimeModule colorOverLifetime2 = current.colorOverLifetime;
						((ColorOverLifetimeModule)(ref colorOverLifetime2)).color = MinMaxGradient.op_Implicit(val);
					}
				}
				finally
				{
					((IDisposable)enumerator).Dispose();
				}
			}
		}

		public class SimpleRemoveAfterUnparent : MonoBehaviour
		{
			public GameObject parent;

			public bool triggered;

			public float delayTime = 3f;

			public float timer;

			private void Start()
			{
				if ((Object)(object)parent == (Object)null)
				{
					parent = ((Component)((Component)this).transform.parent).gameObject;
				}
			}

			private void Update()
			{
				if ((Object)(object)parent == (Object)null)
				{
					triggered = true;
				}
				if (triggered)
				{
					timer += TimeHandler.deltaTime;
					if (timer >= delayTime)
					{
						Object.Destroy((Object)(object)((Component)this).gameObject);
					}
				}
			}
		}

		[Serializable]
		[CompilerGenerated]
		private sealed class <>c : Object
		{
			public static readonly <>c <>9 = new <>c();

			public static Action<GameObject> <>9__23_0;

			public static Action <>9__23_1;

			internal void <CopyGunStatsNoActions>b__23_0(GameObject _)
			{
			}

			internal void <CopyGunStatsNoActions>b__23_1()
			{
			}
		}

		public static bool debugLog = false;

		public static bool infoLog = true;

		public static bool suppressError = false;

		public static float compensateBase = 0f;

		public static float compensatePower = 1f;

		public static float compensateThreshold = 50f;

		public static void LogInfo(object message)
		{
			if (infoLog)
			{
				Debug.Log(message);
			}
		}

		public static void Log(object message)
		{
			if (debugLog)
			{
				Debug.Log(message);
			}
		}

		public static void LogWarn(object message)
		{
			if (!suppressError)
			{
				Debug.LogWarning(message);
			}
		}

		public static void LogError(object message)
		{
			if (!suppressError)
			{
				Debug.LogError(message);
			}
		}

		public static void KillOneLife(Player player)
		{
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: 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_0055: Unknown result type (might be due to invalid IL or missing references)
			if (player.data.stats.remainingRespawns > 0)
			{
				ExtensionMethods.InvokeMethod((object)((Component)player).gameObject.GetComponent<HealthHandler>(), "RPCA_Die_Phoenix", (object[])(object)new Object[1] { (object)Vector2.up });
				player.data.view.RPC("RPCA_Die_Phoenix", (RpcTarget)1, (object[])(object)new Object[1] { (object)Vector2.up });
			}
			else
			{
				ExtensionMethods.InvokeMethod((object)((Component)player).gameObject.GetComponent<HealthHandler>(), "RPCA_Die", (object[])(object)new Object[1] { (object)Vector2.up });
				player.data.view.RPC("RPCA_Die", (RpcTarget)1, (object[])(object)new Object[1] { (object)Vector2.up });
			}
		}

		public static void GodKill(Player player)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			ExtensionMethods.InvokeMethod((object)((Component)player).gameObject.GetComponent<HealthHandler>(), "RPCA_Die", (object[])(object)new Object[1] { (object)Vector2.up });
			player.data.view.RPC("RPCA_Die", (RpcTarget)1, (object[])(object)new Object[1] { (object)Vector2.up });
		}

		public static float TimeSpeedCalc(float durationFrom, float durationInto)
		{
			return durationFrom / durationInto;
		}

		public static Vector3 RotateVector(Vector3 vector, float degree)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			float num = Mathf.Sin(degree * ((float)Math.PI / 180f));
			float num2 = Mathf.Cos(degree * ((float)Math.PI / 180f));
			float x = vector.x;
			float y = vector.y;
			vector.x = num2 * x - num * y;
			vector.y = num * x + num2 * y;
			return vector;
		}

		public static Vector3 ScaleNormalize(Vector3 scale)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			float num = Mathf.Max((float[])(object)new Single[3] { scale.x, scale.y, scale.z });
			return new Vector3(scale.x / num, scale.y / num, scale.z / num);
		}

		public static Vector2 BulletDropCorrection(Vector2 toward, Vector2 velocity, float gravitySum)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: 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_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: 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)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_0251: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_0249: Unknown result type (might be due to invalid IL or missing references)
			if (StatsMath.ApproxEqual(velocity.x, 0f) || StatsMath.ApproxEqual(gravitySum, 0f))
			{
				return velocity;
			}
			Vector2 zero = Vector2.zero;
			float magnitude = ((Vector2)(ref velocity)).magnitude;
			float num = magnitude + Mathf.Pow((compensateThreshold - magnitude) * compensateBase, compensatePower);
			Vector2 val = Vector2.op_Implicit(Vector3.Project(Vector2.op_Implicit(gravitySum * Vector2.down), Vector2.op_Implicit(toward)));
			Log(String.Format("gravSplit = {0} / {1} = {2}", (object)(gravitySum * Vector2.down), (object)toward, (object)val));
			float num2 = Mathf.Sqrt(num * num + 2f * ((Vector2)(ref val)).magnitude * ((Vector2)(ref toward)).magnitude);
			float num3 = (num2 - num) / ((Vector2)(ref val)).magnitude;
			Log(String.Format("bulletTime = ({0} - {1}) / {2} = {3}", (object[])(object)new Object[4]
			{
				(object)num2,
				(object)num,
				(object)val.x,
				(object)num3
			}));
			if ((double)num3 < 0.02)
			{
				return velocity;
			}
			zero.x = toward.x / num3;
			Log(String.Format("newVel.x = {0} / {1} = {2}", (object)toward.x, (object)num3, (object)zero.x));
			if (Single.IsNaN(zero.x))
			{
				LogWarn("newVel.x is NaN!");
				return velocity;
			}
			zero.y = Mathf.Sqrt(magnitude * magnitude - zero.x * zero.x) * Mathf.Sign(gravitySum);
			Log(String.Format("newVel.y^2 = ({0})^2 - ({1})^2 = {2}", (object)magnitude, (object)zero.x, (object)zero.y));
			if (Single.IsNaN(zero.y))
			{
				LogWarn("newVel.y is NaN!");
				zero.y = Mathf.Sqrt(num2 * num2 - zero.x * zero.x) * Mathf.Sign(gravitySum);
				Log(String.Format("newVel.y^2 = ({0})^2 - ({1})^2 = {2}", (object)num2, (object)zero.x, (object)zero.y));
			}
			if (Single.IsNaN(zero.y))
			{
				LogWarn("newVel.y is NaN!!!");
				return ((Vector2)(ref toward)).normalized * magnitude;
			}
			return ((Vector2)(ref zero)).normalized * magnitude;
		}

		public static GameObject GetChildByHierachy(GameObject queryFrom, string path)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			List<string> obj = StringSplit(path, '\\');
			Transform val = queryFrom.transform;
			Enumerator<string> enumerator = obj.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					string current = enumerator.Current;
					bool flag = false;
					for (int i = 0; i < val.childCount; i++)
					{
						if (((Object)val.GetChild(i)).name.Equals(current))
						{
							val = val.GetChild(i);
							flag = true;
							break;
						}
					}
					if (!flag)
					{
						break;
					}
				}
			}
			finally
			{
				((IDisposable)enumerator).Dispose();
			}
			return ((Component)val).gameObject;
		}

		public static List<string> StringSplit(string input, char splitAt)
		{
			List<string> val = new List<string>();
			string text = "";
			for (int i = 0; i < input.Length; i++)
			{
				if (input[i] != splitAt)
				{
					string text2 = text;
					char c = input[i];
					text = String.Concat(text2, ((Char)(ref c)).ToString());
				}
				else
				{
					val.Add(text);
					text = "";
				}
			}
			if (text != "")
			{
				val.Add(text);
			}
			return val;
		}

		public static int ValidateStringQuery(string targetString, string query)
		{
			int num = 15;
			int num2 = 0;
			int num3 = 0;
			bool flag = true;
			for (int i = 0; i < targetString.Length; i++)
			{
				if (targetString[i] == query[num2])
				{
					num3 += num;
					num2++;
				}
				else
				{
					flag = false;
					num--;
					num2++;
				}
				if (num2 == query.Length)
				{
					if (flag)
					{
						num3 += num * 10;
					}
					break;
				}
			}
			return num3;
		}

		public static void CopyGunStats(Gun copyFromGun, Gun copyToGun)
		{
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: 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_0088: Expected O, but got Unknown
			Log("CopyGunStats() : calling base");
			CopyGunStatsBase(copyFromGun, copyToGun);
			Log("CopyGunStats() : cloning ShootPojectileAction");
			if (copyFromGun.ShootPojectileAction != null)
			{
				copyToGun.ShootPojectileAction = (Action<GameObject>)((Delegate)copyFromGun.ShootPojectileAction).Clone();
			}
			copyToGun.shootPosition = copyFromGun.shootPosition;
			Log("CopyGunStats() : cloning attackAction");
			Action value = Traverse.Create((object)copyFromGun).Field("attackAction").GetValue<Action>();
			if (value != null)
			{
				Traverse.Create((object)copyToGun).Field("attackAction").SetValue((object)(Action)((Delegate)value).Clone());
			}
			Log("CopyGunStats() : finishing");
			Traverse.Create((object)copyToGun).Field("spreadOfLastBullet").SetValue((object)(Single)Traverse.Create((object)copyFromGun).Field("spreadOfLastBullet").GetValue());
			Traverse.Create((object)copyToGun).Field("forceShootDir").SetValue((object)(Vector3)Traverse.Create((object)copyFromGun).Field("forceShootDir").GetValue());
		}

		public static void CopyGunStatsNoActions(Gun copyFromGun, Gun copyToGun)
		{
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			CopyGunStatsBase(copyFromGun, copyToGun);
			((Weapon)copyToGun).holdable = null;
			copyToGun.ShootPojectileAction = delegate
			{
			};
			object obj = <>c.<>9__23_1;
			if (obj == null)
			{
				Action val = delegate
				{
				};
				<>c.<>9__23_1 = val;
				obj = (object)val;
			}
			Action value = (Action)obj;
			Traverse.Create((object)copyToGun).Field("attackAction").SetValue((object)value);
			Traverse.Create((object)copyToGun).Field("spreadOfLastBullet").SetValue((object)(Single)Traverse.Create((object)copyFromGun).Field("spreadOfLastBullet").GetValue());
			Traverse.Create((object)copyToGun).Field("forceShootDir").SetValue((object)(Vector3)Traverse.Create((object)copyFromGun).Field("forceShootDir").GetValue());
		}

		public static void CopyGunStatsBase(Gun copyFromGun, Gun copyToGun)
		{
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			copyToGun.ammo = copyFromGun.ammo;
			copyToGun.ammoReg = copyFromGun.ammoReg;
			copyToGun.attackID = copyFromGun.attackID;
			copyToGun.attackSpeed = copyFromGun.attackSpeed;
			copyToGun.attackSpeedMultiplier = copyFromGun.attackSpeedMultiplier;
			copyToGun.bodyRecoil = copyFromGun.bodyRecoil;
			copyToGun.bulletDamageMultiplier = copyFromGun.bulletDamageMultiplier;
			copyToGun.bulletPortal = copyFromGun.bulletPortal;
			copyToGun.bursts = copyFromGun.bursts;
			copyToGun.chargeDamageMultiplier = copyFromGun.chargeDamageMultiplier;
			copyToGun.chargeEvenSpreadTo = copyFromGun.chargeEvenSpreadTo;
			copyToGun.chargeNumberOfProjectilesTo = copyFromGun.chargeNumberOfProjectilesTo;
			copyToGun.chargeRecoilTo = copyFromGun.chargeRecoilTo;
			copyToGun.chargeSpeedTo = copyFromGun.chargeSpeedTo;
			copyToGun.chargeSpreadTo = copyFromGun.chargeSpreadTo;
			copyToGun.cos = copyFromGun.cos;
			copyToGun.currentCharge = copyFromGun.currentCharge;
			copyToGun.damage = copyFromGun.damage;
			copyToGun.damageAfterDistanceMultiplier = copyFromGun.damageAfterDistanceMultiplier;
			copyToGun.defaultCooldown = copyFromGun.defaultCooldown;
			copyToGun.destroyBulletAfter = copyFromGun.destroyBulletAfter;
			copyToGun.dmgMOnBounce = copyFromGun.dmgMOnBounce;
			copyToGun.dontAllowAutoFire = copyFromGun.dontAllowAutoFire;
			copyToGun.drag = copyFromGun.drag;
			copyToGun.dragMinSpeed = copyFromGun.dragMinSpeed;
			copyToGun.evenSpread = copyFromGun.evenSpread;
			copyToGun.explodeNearEnemyDamage = copyFromGun.explodeNearEnemyDamage;
			copyToGun.explodeNearEnemyRange = copyFromGun.explodeNearEnemyRange;
			copyToGun.forceSpecificAttackSpeed = copyFromGun.forceSpecificAttackSpeed;
			copyToGun.forceSpecificShake = copyFromGun.forceSpecificShake;
			copyToGun.gravity = copyFromGun.gravity;
			copyToGun.hitMovementMultiplier = copyFromGun.hitMovementMultiplier;
			copyToGun.ignoreWalls = copyFromGun.ignoreWalls;
			copyToGun.isProjectileGun = copyFromGun.isProjectileGun;
			copyToGun.isReloading = copyFromGun.isReloading;
			copyToGun.knockback = copyFromGun.knockback;
			copyToGun.lockGunToDefault = copyFromGun.lockGunToDefault;
			copyToGun.multiplySpread = copyFromGun.multiplySpread;
			copyToGun.numberOfProjectiles = copyFromGun.numberOfProjectiles;
			copyToGun.overheatMultiplier = copyFromGun.overheatMultiplier;
			copyToGun.percentageDamage = copyFromGun.percentageDamage;
			copyToGun.player = copyFromGun.player;
			copyToGun.projectielSimulatonSpeed = copyFromGun.projectielSimulatonSpeed;
			copyToGun.projectileColor = copyFromGun.projectileColor;
			copyToGun.projectileSize = copyFromGun.projectileSize;
			copyToGun.projectileSpeed = copyFromGun.projectileSpeed;
			copyToGun.randomBounces = copyFromGun.randomBounces;
			copyToGun.recoil = copyFromGun.recoil;
			copyToGun.recoilMuiltiplier = copyFromGun.recoilMuiltiplier;
			copyToGun.reflects = copyFromGun.reflects;
			copyToGun.reloadTime = copyFromGun.reloadTime;
			copyToGun.reloadTimeAdd = copyFromGun.reloadTimeAdd;
			copyToGun.shake = copyFromGun.shake;
			copyToGun.shakeM = copyFromGun.shakeM;
			((Weapon)copyToGun).sinceAttack = ((Weapon)copyFromGun).sinceAttack;
			copyToGun.size = copyFromGun.size;
			copyToGun.slow = copyFromGun.slow;
			copyToGun.smartBounce = copyFromGun.smartBounce;
			copyToGun.spawnSkelletonSquare = copyFromGun.spawnSkelletonSquare;
			copyToGun.speedMOnBounce = copyFromGun.speedMOnBounce;
			copyToGun.spread = copyFromGun.spread;
			copyToGun.teleport = copyFromGun.teleport;
			copyToGun.timeBetweenBullets = copyFromGun.timeBetweenBullets;
			copyToGun.timeToReachFullMovementMultiplier = copyFromGun.timeToReachFullMovementMultiplier;
			copyToGun.unblockable = copyFromGun.unblockable;
			copyToGun.useCharge = copyFromGun.useCharge;
			copyToGun.waveMovement = copyFromGun.waveMovement;
			copyToGun.objectsToSpawn = Enumerable.ToList<ObjectsToSpawn>((IEnumerable<ObjectsToSpawn>)(object)copyFromGun.objectsToSpawn).ToArray();
			copyToGun.projectiles = Enumerable.ToList<ProjectilesToSpawn>((IEnumerable<ProjectilesToSpawn>)(object)copyFromGun.projectiles).ToArray();
		}
	}
	public class MoveTransformSimulator : Object
	{
		public float gravity = 100f;

		public float drag = 0.1f;

		public float dragMinSpeed = 1f;

		public float velocitySpread;

		public float spread;

		public Vector3 localForce = new Vector3(0f, 0f, 50f);

		public Vector3 worldForce = new Vector3(0f, 5f, 0f);

		public float multiplier = 1f;

		public Vector3 velocity;

		public float distanceTravelled;

		public bool DontRunStart;

		public float selectedSpread;

		public bool allowStop;

		public int simulateGravity;

		public float simulationSpeed = 1f;

		public Vector3 position;

		public MoveTransformSimulator(MoveTransform moveTransform)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			gravity = moveTransform.gravity;
			drag = moveTransform.drag;
			dragMinSpeed = moveTransform.dragMinSpeed;
			velocitySpread = moveTransform.velocitySpread;
			spread = moveTransform.spread;
			localForce = moveTransform.localForce;
			worldForce = moveTransform.worldForce;
			multiplier = moveTransform.multiplier;
			velocity = moveTransform.velocity;
			distanceTravelled = moveTransform.distanceTravelled;
			allowStop = moveTransform.allowStop;
			simulateGravity = moveTransform.simulateGravity;
			simulationSpeed = Traverse.Create((object)moveTransform).Field("simulationSpeed").GetValue<float>();
			position = ((Component)moveTransform).transform.position;
		}

		public MoveTransformSimulator(Gun gun)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: 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_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			localForce *= gun.projectileSpeed;
			simulationSpeed *= gun.projectielSimulatonSpeed;
			gravity *= gun.gravity;
			worldForce *= gun.gravity;
			drag = gun.drag;
			drag = Mathf.Clamp(drag, 0f, 45f);
			velocitySpread = Mathf.Clamp(spread * 50f, 0f, 50f);
			dragMinSpeed = dragMinSpeed;
			selectedSpread = 0f;
			float magnitude = ((Vector3)(ref localForce)).magnitude;
			Vector3 forward = gun.shootPosition.forward;
			velocity = magnitude * ((Vector3)(ref forward)).normalized + worldForce;
			position = gun.shootPosition.position;
		}

		public void Update()
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			float num = Mathf.Clamp(TimeHandler.deltaTime, 0f, 0.02f);
			float deltaTime = TimeHandler.deltaTime;
			num *= simulationSpeed;
			deltaTime *= simulationSpeed;
			if (simulateGravity == 0)
			{
				velocity += gravity * Vector3.down * deltaTime * multiplier;
			}
			if ((((Vector3)(ref velocity)).magnitude > 2f || allowStop) && ((Vector3)(ref velocity)).magnitude > dragMinSpeed)
			{
				velocity -= velocity * Mathf.Clamp(drag * num * Mathf.Clamp(multiplier, 0f, 1f), 0f, 1f);
			}
			position += velocity * deltaTime * multiplier;
			distanceTravelled += ((Vector3)(ref velocity)).magnitude * deltaTime * multiplier;
		}

		public void Update(float deltaTime)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: 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_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			float num = Mathf.Clamp(deltaTime, 0f, 0.02f);
			num *= simulationSpeed;
			deltaTime *= simulationSpeed;
			if (simulateGravity == 0)
			{
				velocity += gravity * Vector3.down * deltaTime * multiplier;
			}
			if ((((Vector3)(ref velocity)).magnitude > 2f || allowStop) && ((Vector3)(ref velocity)).magnitude > dragMinSpeed)
			{
				velocity -= velocity * Mathf.Clamp(drag * num * Mathf.Clamp(multiplier, 0f, 1f), 0f, 1f);
			}
			position += velocity * deltaTime * multiplier;
			distanceTravelled += ((Vector3)(ref velocity)).magnitude * deltaTime * multiplier;
		}
	}
	internal class PlayerCardResolver : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass1_0 : Object
		{
			public string cardNameToAdd;

			internal bool <ResolveCardCategory>b__0(CardInfo card)
			{
				return ((Object)card).name == cardNameToAdd;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass2_0 : Object
		{
			public CardCategory categoryToCheck;

			internal bool <UpdateCategoryBlacklist>b__0(CardCategory category)
			{
				return (Object)(object)category == (Object)(object)categoryToCheck;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass3_0 : Object
		{
			public CardCategory categoryToCheck;

			internal bool <UpdateCategoryWhitelist>b__0(CardCategory category)
			{
				return (Object)(object)category == (Object)(object)categoryToCheck;
			}
		}

		[IteratorStateMachine(/*Could not decode