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 BepInEx.Bootstrap;
using CardChoiceSpawnUniqueCardPatch.CustomCategories;
using HarmonyLib;
using InControl;
using Jotunn.Utils;
using Microsoft.CodeAnalysis;
using ModdingUtils.Extensions;
using ModdingUtils.Utils;
using Photon.Pun;
using RSCards.Cards;
using RSCards.Utilities;
using RarityLib.Utils;
using Sonigon;
using UnboundLib;
using UnboundLib.Cards;
using UnboundLib.GameModes;
using UnboundLib.Utils;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[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(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

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

		public List<GameObject> HiddenCards;

		public List<string> AprilFoolsCards;

		public List<string> NonAprilFoolsCards;

		public static Dictionary<string, CardInfo> cards = new Dictionary<string, CardInfo>();

		public CardCategory BounceAbsorptionCategory;

		public CardCategory RepentanceCategory;

		internal void RegisterCards()
		{
			foreach (GameObject card in Cards)
			{
				card.AddComponent<Template>();
				if ((!RSCards.RSClasses || !(((Object)card).name == "Twin Scythe")) && (DateTools.WeekOf(new DateTime(DateTime.UtcNow.Year, 4, 1)) || !AprilFoolsCards.Contains(((Object)card).name)) && (!DateTools.WeekOf(new DateTime(DateTime.UtcNow.Year, 4, 1)) || !NonAprilFoolsCards.Contains(((Object)card).name)))
				{
					CustomCard.RegisterUnityCard(card, "RSC", card.GetComponent<CardInfo>().cardName, true, (Action<CardInfo>)null);
					CustomCardCategories.instance.UpdateAndPullCategoriesFromCard(card.GetComponent<CardInfo>());
					cards.Add(card.GetComponent<CardInfo>().cardName, card.GetComponent<CardInfo>());
				}
			}
			foreach (GameObject hiddenCard in HiddenCards)
			{
				hiddenCard.AddComponent<Template>();
				if (DateTools.WeekOf(new DateTime(DateTime.UtcNow.Year, 4, 1)) || !AprilFoolsCards.Contains(((Object)hiddenCard).name))
				{
					CustomCard.RegisterUnityCard(hiddenCard, "RSC", hiddenCard.GetComponent<CardInfo>().cardName, false, (Action<CardInfo>)null);
					CustomCardCategories.instance.UpdateAndPullCategoriesFromCard(hiddenCard.GetComponent<CardInfo>());
					Cards.instance.AddHiddenCard(hiddenCard.GetComponent<CardInfo>());
					cards.Add(hiddenCard.GetComponent<CardInfo>().cardName, hiddenCard.GetComponent<CardInfo>());
				}
			}
		}
	}
	[HarmonyPatch(typeof(ExtraPlayerSkins))]
	public class RSMindTeam
	{
		private static PlayerSkin Skin;

		private static readonly PlayerSkin SkinPrefeb = new PlayerSkin
		{
			color = new Color(0.4117647f, 0f, 0.55f, 1f),
			backgroundColor = new Color(0f, 0f, 0f, 1f),
			winText = new Color(0.4117647f, 0f, 0.55f, 1f),
			particleEffect = new Color(0f, 0f, 0f, 1f)
		};

		private const int TeamID = 165;

		[HarmonyPatch("GetTeamColorName")]
		[HarmonyPostfix]
		public static void PatchName(int teamID, ref string __result)
		{
			if (teamID == 165)
			{
				__result = "<b><color=#6900bfff>RS</color><color=#000000ff>_Mind</color></b>";
			}
		}

		[HarmonyPatch("GetPlayerSkinColors")]
		[HarmonyPrefix]
		public static bool PatchGetSkin(int colorID, ref PlayerSkin __result)
		{
			if (colorID != 165)
			{
				return true;
			}
			if ((Object)(object)Skin == (Object)null)
			{
				Skin = CreateSkins(colorID, SkinPrefeb);
			}
			__result = Skin;
			return false;
		}

		private static PlayerSkin CreateSkins(int colorID, PlayerSkin skinPrefab)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: 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_0097: 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_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			PropertyInfo property = typeof(PlayerSkinBank).GetProperty("Instance", BindingFlags.Static | BindingFlags.NonPublic);
			PlayerSkinBank val = (PlayerSkinBank)((property != null) ? property.GetValue(null, null) : null);
			PlayerSkin val2 = (((Object)(object)val != (Object)null) ? val.skins[colorID % 4].currentPlayerSkin : null);
			PlayerSkin component = ((Component)Object.Instantiate<PlayerSkin>(val2)).gameObject.GetComponent<PlayerSkin>();
			Object.DontDestroyOnLoad((Object)(object)component);
			component.color = skinPrefab.color;
			component.backgroundColor = skinPrefab.backgroundColor;
			component.winText = skinPrefab.winText;
			component.particleEffect = skinPrefab.particleEffect;
			PlayerSkinParticle componentInChildren = ((Component)component).GetComponentInChildren<PlayerSkinParticle>();
			ParticleSystem component2 = ((Component)componentInChildren).GetComponent<ParticleSystem>();
			MainModule main = component2.main;
			MinMaxGradient startColor = ((MainModule)(ref main)).startColor;
			((MinMaxGradient)(ref startColor)).colorMin = skinPrefab.backgroundColor;
			((MinMaxGradient)(ref startColor)).colorMax = skinPrefab.color;
			((MainModule)(ref main)).startColor = startColor;
			ExtensionMethods.SetFieldValue((object)componentInChildren, "startColor1", (object)skinPrefab.backgroundColor);
			ExtensionMethods.SetFieldValue((object)componentInChildren, "startColor2", (object)skinPrefab.color);
			return component;
		}
	}
	[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.rsmind.rounds.RSCards", "RSCards", "1.7.2")]
	[BepInProcess("Rounds.exe")]
	public class RSCards : BaseUnityPlugin
	{
		private const string ModId = "com.rsmind.rounds.RSCards";

		private const string ModName = "RSCards";

		public const string Version = "1.7.2";

		public const string ModInitials = "RSC";

		private CardHolder cardHolder;

		internal static bool RSClasses;

		public static bool Debug;

		internal static AssetBundle assets;

		public static RSCards instance { get; private set; }

		private void Awake()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			Harmony val = new Harmony("com.rsmind.rounds.RSCards");
			val.PatchAll();
		}

		private void Start()
		{
			foreach (KeyValuePair<string, PluginInfo> pluginInfo in Chainloader.PluginInfos)
			{
				if (pluginInfo.Value.Metadata.GUID == "com.rsmind.rounds.RSClasses")
				{
					RSClasses = true;
					break;
				}
			}
			instance = this;
			assets = AssetUtils.LoadAssetBundleFromResources("rscardart", typeof(RSCards).Assembly);
			if ((Object)(object)assets == (Object)null)
			{
				Debug.Log((object)"Failed to load RSCards asset bundle");
			}
			cardHolder = assets.LoadAsset<GameObject>("CardHolder").GetComponent<CardHolder>();
			cardHolder.RegisterCards();
			CustomCardCategories.instance.MakeCardsExclusive(CardHolder.cards["Hitscan"], CardHolder.cards["Mortar"]);
			GameModeManager.AddHook("PlayerPickStart", (Func<IGameModeHandler, IEnumerator>)PlayerPickStart);
		}

		private IEnumerator PlayerPickStart(IGameModeHandler gm)
		{
			foreach (Player player in PlayerManager.instance.players)
			{
				if (((Component)((Component)player.data).GetComponent<Holding>().holdable).GetComponent<Gun>().reflects >= 2 && CharacterStatModifiersExtension.GetAdditionalData(player.data.stats).blacklistedCategories.Contains(cardHolder.BounceAbsorptionCategory))
				{
					CharacterStatModifiersExtension.GetAdditionalData(player.data.stats).blacklistedCategories.Remove(cardHolder.BounceAbsorptionCategory);
				}
				else if (!CharacterStatModifiersExtension.GetAdditionalData(player.data.stats).blacklistedCategories.Contains(cardHolder.BounceAbsorptionCategory))
				{
					CharacterStatModifiersExtension.GetAdditionalData(player.data.stats).blacklistedCategories.Add(cardHolder.BounceAbsorptionCategory);
				}
				if (((Component)player).GetComponent<CharacterStatModifiers>().lifeSteal >= 0.5f && CharacterStatModifiersExtension.GetAdditionalData(player.data.stats).blacklistedCategories.Contains(cardHolder.RepentanceCategory))
				{
					CharacterStatModifiersExtension.GetAdditionalData(player.data.stats).blacklistedCategories.Remove(cardHolder.RepentanceCategory);
				}
				else if (!CharacterStatModifiersExtension.GetAdditionalData(player.data.stats).blacklistedCategories.Contains(cardHolder.RepentanceCategory))
				{
					CharacterStatModifiersExtension.GetAdditionalData(player.data.stats).blacklistedCategories.Add(cardHolder.RepentanceCategory);
				}
			}
			yield break;
		}
	}
}
namespace RSCards.Utilities
{
	internal static class DateTools
	{
		public static bool DayOf(DateTime holiday)
		{
			double num = DateTime.UtcNow.ToOADate();
			double num2 = holiday.AddHours(-12.0).ToOADate();
			double num3 = holiday.AddHours(36.0).ToOADate();
			return num > num2 && num < num3;
		}

		public static bool DayOf(DateTime[] holidays)
		{
			for (int i = 0; i < holidays.Length; i++)
			{
				if (DayOf(holidays[i]))
				{
					return true;
				}
			}
			return false;
		}

		public static bool WeekOf(DateTime holiday)
		{
			double num = DateTime.UtcNow.ToOADate();
			double num2 = holiday.AddDays(-6.0).AddHours(-12.0).ToOADate();
			double num3 = holiday.AddDays(6.0).AddHours(36.0).ToOADate();
			return num > num2 && num < num3;
		}

		public static bool WeekOf(DateTime[] holidays)
		{
			for (int i = 0; i < holidays.Length; i++)
			{
				if (WeekOf(holidays[i]))
				{
					return true;
				}
			}
			return false;
		}

		public static void DateTest(DateTime testDate)
		{
			if (DayOf(testDate))
			{
				Debug.Log((object)$"It's {testDate.Month}/{testDate.Day} somewhere");
			}
			else if (WeekOf(testDate))
			{
				Debug.Log((object)$"It's the week of {testDate.Month}/{testDate.Day} somewhere");
			}
			else
			{
				Debug.Log((object)$"It's not {testDate.Month}/{testDate.Day} anywhere");
			}
		}
	}
	internal class RarityAdder : MonoBehaviour
	{
		public enum Rarity
		{
			Trinket,
			Common,
			Scarce,
			Uncommon,
			Exotic,
			Rare,
			Epic,
			Legendary,
			Mythical,
			Divine,
			Unique
		}

		private string[] rarityNames = new string[11]
		{
			"Trinket", "Common", "Scarce", "Uncommon", "Exotic", "Rare", "Epic", "Legendary", "Mythical", "Divine",
			"Unique"
		};

		public Rarity rarity = Rarity.Common;

		public void Start()
		{
			//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)
			((Component)this).GetComponent<CardInfo>().rarity = RarityUtils.GetRarity(rarityNames[(int)rarity]);
		}
	}
}
namespace RSCards.Cards
{
	internal class Template : CustomCard
	{
		public override void SetupCard(CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
		{
			if (RSCards.Debug)
			{
				Debug.Log((object)("[RSC][Card] " + ((CustomCard)this).GetTitle() + " has been setup."));
			}
		}

		public override void OnAddCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			if (RSCards.Debug)
			{
				Debug.Log((object)string.Format("[{0}][Card] {1} has been added to player {2}.", "RSC", ((CustomCard)this).GetTitle(), player.playerID));
			}
		}

		public override void OnRemoveCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			if (RSCards.Debug)
			{
				Debug.Log((object)string.Format("[{0}][Card] {1} has been removed from player {2}.", "RSC", ((CustomCard)this).GetTitle(), player.playerID));
			}
		}

		protected override string GetTitle()
		{
			return "CardName";
		}

		protected override string GetDescription()
		{
			return "CardDescription";
		}

		protected override GameObject GetCardArt()
		{
			return null;
		}

		protected override Rarity GetRarity()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return (Rarity)0;
		}

		protected override CardInfoStat[] GetStats()
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			return (CardInfoStat[])(object)new CardInfoStat[1]
			{
				new CardInfoStat
				{
					positive = true,
					stat = "Effect",
					amount = "No",
					simepleAmount = (SimpleAmount)0
				}
			};
		}

		protected override CardThemeColorType GetTheme()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return (CardThemeColorType)7;
		}

		public override string GetModName()
		{
			return "RSC";
		}
	}
}
namespace RSCards.MonoBehaviors
{
	public class Hitscan_Bullet_Mono : MonoBehaviour
	{
		private GameObject trail;

		private void OnDestroy()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			trail.transform.SetPositionAndRotation(((Component)this).transform.position, ((Component)this).transform.rotation);
			ExtensionMethods.ExecuteAfterSeconds((MonoBehaviour)(object)RSCards.instance, 2f, (Action)delegate
			{
				Object.Destroy((Object)(object)trail);
			});
		}

		private void Start()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			trail = new GameObject("Hitscan_Trail", new Type[1] { typeof(TrailRenderer) });
			trail.transform.SetPositionAndRotation(((Component)this).transform.position, ((Component)this).transform.rotation);
			trail.GetComponent<TrailRenderer>().startWidth = 0.1f;
			trail.GetComponent<TrailRenderer>().endWidth = 0.1f;
			trail.GetComponent<TrailRenderer>().time = 1f;
			((Renderer)trail.GetComponent<TrailRenderer>()).sharedMaterial = RSCards.assets.LoadAsset<Material>("Material");
			RayHitReflect componentInParent = ((Component)this).GetComponentInParent<RayHitReflect>();
			if (componentInParent != null)
			{
				componentInParent.reflects = 0;
			}
		}

		private void Update()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			trail.transform.SetPositionAndRotation(((Component)this).transform.position, ((Component)this).transform.rotation);
		}
	}
	public class Mortar_Mono : MonoBehaviour
	{
		public bool snap;

		public bool trigger;

		public float rotateSpeed = 1000f;

		private SpawnedAttack spawned;

		private MoveTransform move;

		private float startVelocity;

		private bool isOn;

		private ProjectileHit hit;

		private float c;

		private PhotonView view;

		private ChildRPC childRPC;

		private void OnDestroy()
		{
		}

		private void Start()
		{
			childRPC = ((Component)this).GetComponentInParent<ChildRPC>();
			view = ((Component)this).GetComponentInParent<PhotonView>();
			hit = ((Component)this).GetComponentInParent<ProjectileHit>();
			move = ((Component)this).GetComponentInParent<MoveTransform>();
			spawned = ((Component)this).GetComponentInParent<SpawnedAttack>();
			startVelocity = ((Vector3)(ref move.velocity)).magnitude;
			((Component)this).GetComponentInParent<SyncProjectile>().active = true;
		}

		private void Update()
		{
			//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_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_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//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)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: 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_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: 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_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!view.IsMine)
				{
					return;
				}
				Vector3 val = Vector3.zero;
				if (((PlayerActionSet)spawned.spawner.data.playerActions).Device != null)
				{
					val = spawned.spawner.data.input.aimDirection;
				}
				else
				{
					val = MainCam.instance.cam.ScreenToWorldPoint(Input.mousePosition) - ((Component)this).transform.position;
					val.z = 0f;
					((Vector3)(ref val)).Normalize();
				}
				trigger = spawned.spawner.data.weaponHandler.gun.ReadyAmount() < 0.01f;
				val += Vector3.Cross(Vector3.forward, val) * move.selectedSpread;
				c += TimeHandler.deltaTime;
				if (!trigger)
				{
					return;
				}
				if (snap)
				{
					if (spawned.spawner.data.block.blockedThisFrame)
					{
						move.velocity *= -1f;
						((Behaviour)this).enabled = false;
					}
				}
				else if (((Vector3)(ref val)).magnitude > 0.2f && hit.sinceReflect > 2f)
				{
					move.velocity = Vector3.RotateTowards(move.velocity, ((Vector3)(ref val)).normalized * startVelocity, rotateSpeed * TimeHandler.deltaTime, rotateSpeed * TimeHandler.deltaTime * 10f);
					if (c > 0.1f)
					{
						c = 0f;
					}
					if (!isOn)
					{
						MoveTransform obj = move;
						obj.simulateGravity++;
					}
					isOn = true;
				}
				else
				{
					if (isOn)
					{
						MoveTransform obj2 = move;
						obj2.simulateGravity--;
					}
					isOn = false;
				}
			}
			catch
			{
			}
		}
	}
	public class Repentence_Mono : MonoBehaviour
	{
		private void Start()
		{
			Player componentInParent = ((Component)this).GetComponentInParent<Player>();
			int num = 0;
			foreach (CardInfo currentCard in componentInParent.data.currentCards)
			{
				if (currentCard.cardName == "Repentence")
				{
					num++;
				}
			}
			if (num == 9)
			{
				Cards.instance.AddCardToPlayer(componentInParent, Cards.instance.GetCardWithName("Repen10ce"), false, "", 0f, 0f);
			}
		}
	}
	internal class Scythe : MonoBehaviour
	{
		public bool ableToHit = true;

		public bool active = true;

		public float damage = 65f;

		private Player player;

		private Dictionary<int, float> recent = new Dictionary<int, float>();

		private GameObject scythe;

		private void OnDestroy()
		{
			Object.Destroy((Object)(object)scythe);
		}

		private void Start()
		{
			player = ((Component)this).GetComponentInParent<Player>();
			scythe = Object.Instantiate<GameObject>(RSCards.assets.LoadAsset<GameObject>("Scythe"), ((Component)player).transform);
			scythe.SetActive(true);
		}

		public void DoHit()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Expected O, but got Unknown
			//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_00e8: 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_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			if (!player.data.view.IsMine)
			{
				return;
			}
			float y = ((Component)this).transform.localScale.y;
			Collider2D[] array = Physics2D.OverlapCircleAll(Vector2.op_Implicit(scythe.transform.position), y);
			Collider2D[] array2 = array;
			foreach (Collider2D val in array2)
			{
				ProjectileHit componentInParent = ((Component)val).gameObject.GetComponentInParent<ProjectileHit>();
				Damagable component = ((Component)val).gameObject.GetComponent<Damagable>();
				HealthHandler component2 = ((Component)val).gameObject.GetComponent<HealthHandler>();
				Vector2 val3;
				if (Object.op_Implicit((Object)(object)component2))
				{
					Player val2 = (Player)ExtensionMethods.GetFieldValue((object)component2, "player");
					SoundManager.Instance.PlayAtPosition(component2.soundBounce, ((Component)this).transform, ((Component)component).transform);
					val3 = Vector2.op_Implicit(((Component)val2).transform.position) - Vector2.op_Implicit(scythe.transform.position);
					component2.CallTakeForce(((Vector2)(ref val3)).normalized * 2500f, (ForceMode2D)1, true, false, 0f);
					ableToHit = false;
					if (((Component)(Player)ExtensionMethods.GetFieldValue((object)component2, "player")).GetComponent<Block>().blockedThisFrame)
					{
						continue;
					}
				}
				if (Object.op_Implicit((Object)(object)component))
				{
					val3 = Vector2.op_Implicit(((Component)component).transform.position) - Vector2.op_Implicit(((Component)this).transform.position);
					component.CallTakeDamage(((Vector2)(ref val3)).normalized * damage, Vector2.op_Implicit(((Component)this).transform.position), ((Component)this).gameObject, player, true);
				}
				if (Object.op_Implicit((Object)(object)componentInParent))
				{
					componentInParent.deathEvent.Invoke();
					Object.Destroy((Object)(object)((Component)componentInParent).gameObject);
				}
			}
		}

		public void UpdatePos(double angle, float rotation, float radius)
		{
			//IL_0039: 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_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			double num = angle * Math.PI / 180.0;
			Vector3 localPosition = default(Vector3);
			((Vector3)(ref localPosition))..ctor((float)((double)radius * Math.Sin(num)), (float)((double)radius * Math.Cos(num)), 0f);
			Quaternion rotation2 = default(Quaternion);
			((Quaternion)(ref rotation2)).eulerAngles = new Vector3(0f, 0f, rotation);
			scythe.transform.localPosition = localPosition;
			scythe.transform.rotation = rotation2;
		}

		public void SetColor(Color color)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			scythe.GetComponent<SpriteRenderer>().color = color;
		}
	}
	public class TwinScythe_Mono : MonoBehaviour
	{
		private double angle = 0.0;

		private float rotation = 0f;

		private bool active = false;

		private Color color = new Color(0.5f, 0.5f, 0.5f);

		private List<Scythe> scythes = new List<Scythe>();

		private Player player;

		private void Start()
		{
			player = ((Component)this).GetComponentInParent<Player>();
			TwinScythe_Mono[] componentsInChildren = ((Component)player).GetComponentsInChildren<TwinScythe_Mono>();
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				if (!((Object)(object)componentsInChildren[i] == (Object)(object)this))
				{
					Object.Destroy((Object)(object)this);
				}
			}
			GameModeManager.AddHook("PointStart", (Func<IGameModeHandler, IEnumerator>)PointStart);
			GameModeManager.AddHook("PointEnd", (Func<IGameModeHandler, IEnumerator>)PointEnd);
		}

		private void FixedUpdate()
		{
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: 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)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			angle += 200f * TimeHandler.fixedDeltaTime;
			if (angle > 360.0)
			{
				foreach (Scythe scythe in scythes)
				{
					scythe.ableToHit = true;
				}
				angle -= 360.0;
			}
			rotation = (rotation - 1200f * TimeHandler.fixedDeltaTime) % 360f;
			int num = 0;
			foreach (Scythe scythe2 in scythes)
			{
				double num2 = angle + (double)(360f / (float)scythes.Count() * (float)num);
				scythe2.UpdatePos(num2, rotation, 2f);
				if (active && scythe2.ableToHit)
				{
					scythe2.DoHit();
				}
				if (scythe2.ableToHit)
				{
					Color val = color;
					val.a = 1f;
					scythe2.SetColor(val);
				}
				else
				{
					Color val2 = color;
					val2.a = 0.5f;
					scythe2.SetColor(val2);
				}
				num++;
			}
		}

		public void UpdateStats()
		{
			//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)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Expected O, but got Unknown
			color = player.GetTeamColors().particleEffect;
			int num = 0;
			foreach (CardInfo currentCard in player.data.currentCards)
			{
				if ((Object)(object)currentCard == (Object)(object)CardHolder.cards["Twin Scythe"])
				{
					num++;
				}
			}
			float damage = 55f * (float)Math.Pow(2.0, num - 1);
			num = Math.Min(num, 4);
			while (scythes.Count() < num)
			{
				GameObject val = new GameObject("Scythe", new Type[1] { typeof(Scythe) });
				val.transform.SetParent(((Component)player).transform);
				scythes.Add(val.GetComponent<Scythe>());
			}
			while (scythes.Count() > Math.Max(num, 0))
			{
				Object.Destroy((Object)(object)scythes[0]);
				scythes.Remove(scythes[0]);
			}
			foreach (Scythe scythe in scythes)
			{
				scythe.damage = damage;
			}
		}

		private void OnDestroy()
		{
			GameModeManager.RemoveHook("PointStart", (Func<IGameModeHandler, IEnumerator>)PointStart);
			GameModeManager.RemoveHook("PointEnd", (Func<IGameModeHandler, IEnumerator>)PointEnd);
			while (scythes.Count() > 0)
			{
				Object.Destroy((Object)(object)scythes[0]);
				scythes.Remove(scythes[0]);
			}
		}

		private IEnumerator PointStart(IGameModeHandler gm)
		{
			active = true;
			rotation = 0f;
			angle = 0.0;
			UpdateStats();
			yield break;
		}

		private IEnumerator PointEnd(IGameModeHandler gm)
		{
			active = false;
			yield break;
		}
	}
}