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 System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using CriticalBlowgun.Behaviours;
using CriticalBlowgun.Patchers;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using PEAKLib.Core;
using Photon.Pun;
using Photon.Realtime;
using PhotonCustomPropsUtils;
using TMPro;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.TextCore;
using UnityEngine.UI;
using Zorro.Core;
using pworld.Scripts.Extensions;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("com.github.MiiMii1205.CriticalBlowgun")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("2.0.2.0")]
[assembly: AssemblyInformationalVersion("2.0.2+778c8177c0e16a0b4197cc7f6079a83456d67d5a")]
[assembly: AssemblyProduct("com.github.MiiMii1205.CriticalBlowgun")]
[assembly: AssemblyTitle("CriticalBlowgun")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("2.0.2.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.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 BepInEx
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	internal sealed class BepInAutoPluginAttribute : Attribute
	{
		public BepInAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace BepInEx.Preloader.Core.Patching
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	internal sealed class PatcherAutoPluginAttribute : Attribute
	{
		public PatcherAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace CriticalBlowgun
{
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("com.github.MiiMii1205.CriticalBlowgun", "CriticalBlowgun", "2.0.2")]
	public class Plugin : BaseUnityPlugin
	{
		private static ConfigEntry<float>? _baseCritChance;

		private static ConfigEntry<bool>? _showGUIIndicator;

		private static ConfigEntry<bool>? _playSoundIndicator;

		public static float BaseCritRate = 0.125f;

		private static bool? _unnamedEnabled;

		private static TMP_FontAsset? _darumaFontAsset;

		private static Material? _darumaShadowMaterial;

		private static readonly int UnderlayDilate = Shader.PropertyToID("_UnderlayDilate");

		private static readonly int UnderlayOffsetY = Shader.PropertyToID("_UnderlayOffsetY");

		private static readonly int UnderlaySoftness = Shader.PropertyToID("_UnderlaySoftness");

		private static readonly int UnderlayColor = Shader.PropertyToID("_UnderlayColor");

		public const string Id = "com.github.MiiMii1205.CriticalBlowgun";

		internal static ManualLogSource Log
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get;
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			private set;
		} = null;


		public static GameObject HitPrefab
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get;
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			private set;
		} = null;


		public static PhotonScopedManager? Manager
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get;
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			private set;
		}

		internal static bool ShowGUIIndicator
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return _showGUIIndicator?.Value ?? true;
			}
		}

		internal static bool PlaySoundIndicator
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return _playSoundIndicator?.Value ?? true;
			}
		}

		internal static float BaseCritChance
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return _baseCritChance?.Value ?? 0.125f;
			}
		}

		public static bool HasUnnamedMod
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				if (!_unnamedEnabled.HasValue)
				{
					_unnamedEnabled = Chainloader.PluginInfos.ContainsKey("com.github.MiiMii1205.UnnamedProducts");
				}
				return _unnamedEnabled.Value;
			}
		}

		public static SFX_Instance CritHitSfxi
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get;
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			private set;
		} = null;


		public static SFX_Instance CritReceivedSfxi
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get;
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			private set;
		} = null;


		public static TMP_FontAsset DarumaDropOne
		{
			get
			{
				if ((Object)(object)_darumaFontAsset == (Object)null)
				{
					TMP_FontAsset[] source = Resources.FindObjectsOfTypeAll<TMP_FontAsset>();
					_darumaFontAsset = ((IEnumerable<TMP_FontAsset>)source).FirstOrDefault((Func<TMP_FontAsset, bool>)delegate(TMP_FontAsset fontAsset)
					{
						//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)
						FaceInfo faceInfo = ((TMP_Asset)fontAsset).faceInfo;
						return ((FaceInfo)(ref faceInfo)).familyName == "Daruma Drop One";
					});
					Log.LogInfo((object)"Daruma Drop One font found!");
				}
				return _darumaFontAsset;
			}
		}

		public static Material DarumaDropOneShadowMaterial
		{
			get
			{
				//IL_0097: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)_darumaShadowMaterial == (Object)null)
				{
					_darumaShadowMaterial = ThrowHelper.ThrowIfArgumentNull<Material>(Object.Instantiate<Material>(((TMP_Asset)DarumaDropOne).material), "Object.Instantiate(DarumaDropOne.material)");
					_darumaShadowMaterial.EnableKeyword("UNDERLAY_ON");
					_darumaShadowMaterial.SetFloat(UnderlayDilate, 1f);
					_darumaShadowMaterial.SetFloat(UnderlayOffsetY, -0.7f);
					_darumaShadowMaterial.SetFloat(UnderlaySoftness, 1f);
					_darumaShadowMaterial.SetColor(UnderlayColor, new Color(0.11f, 0.25f, 0.1f, 0.1961f));
					Log.LogInfo((object)"Shadow material for Critial Hit indicator was successfully generated!");
				}
				return _darumaShadowMaterial;
			}
		}

		private static bool IsRunStarted
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return RunManager.Instance?.runStarted ?? false;
			}
		}

		public static string Name => "CriticalBlowgun";

		public static string Version => "2.0.2";

		private void Awake()
		{
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			Log = ((BaseUnityPlugin)this).Logger;
			Manager = PhotonCustomPropsUtilsPlugin.GetManager("com.github.MiiMii1205.CriticalBlowgun");
			_baseCritChance = ((BaseUnityPlugin)this).Config.Bind<float>("General", "BaseCritRate", 0.125f, "The base Crit rate the blowgun has. Durring runs this setting will get overriden to the host's settings. If the host doesn't have the mod, it will default to 12.5%");
			_showGUIIndicator = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "ShowIndicator", true, "Show the 'CRITCAL HIT!!!' indicator when a crit has hit");
			_playSoundIndicator = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "PlaySoundIndicator", true, "Whether to play the 'CRITCAL HIT!!!' SXF or not");
			_baseCritChance.SettingChanged += UpdateCriticalRate;
			BundleLoader.LoadBundleWithName((BaseUnityPlugin)(object)this, "criticalblowgun.peakbundle", (Action<PeakBundle>)delegate(PeakBundle bundle)
			{
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				GameObject val = bundle.LoadAsset<GameObject>("CriticalHit.prefab");
				CriticalHitEffectController orAddComponent = ExtGameObject.GetOrAddComponent<CriticalHitEffectController>(val);
				orAddComponent.m_duration = 1f;
				orAddComponent.m_rectTransform = val.GetComponent<RectTransform>();
				orAddComponent.m_textMeshPro = val.GetComponentInChildren<TextMeshProUGUI>();
				((TMP_Text)orAddComponent.m_textMeshPro).font = DarumaDropOne;
				((Graphic)orAddComponent.m_textMeshPro).color = new Color(0.71f, 0.88f, 0.16f);
				Log.LogInfo((object)"Critical Hit bundle is loaded!");
				bundle.Mod.RegisterContent();
				HitPrefab = val;
				CritHitSfxi = bundle.LoadAsset<SFX_Instance>("SFXI Critical Hit.asset");
				CritReceivedSfxi = bundle.LoadAsset<SFX_Instance>("SFXI Critical Received.asset");
			});
			Manager.RegisterRoomProperty<float>("BaseCritRate", (RoomEventType)2, (Action<float>)delegate(float v)
			{
				if (!PhotonNetwork.IsMasterClient)
				{
					Log.LogInfo((object)$"Received {v:P1} as new crit rate!");
					BaseCritRate = v;
				}
			});
			Manager.RegisterOnJoinedRoom((Action<Player>)SetupCriticalRate);
			new Harmony("com.github.MiiMii1205.CriticalBlowgun").PatchAll(typeof(BlowgunPatcher));
			Log.LogInfo((object)("Plugin " + Name + " is loaded!"));
		}

		private static void SetupCriticalRate(Player player)
		{
			if (PhotonNetwork.InRoom && player.IsMasterClient && Manager != null)
			{
				Log.LogInfo((object)$"Sending our current crit rate of {BaseCritChance:P1}...");
				Manager.SetRoomProperty("BaseCritRate", (object)BaseCritChance);
			}
		}

		private static void UpdateCriticalRate(object sender, EventArgs e)
		{
			if (!IsRunStarted)
			{
				SetupCriticalRate(PhotonNetwork.LocalPlayer);
			}
			else
			{
				Log.LogWarning((object)"Run has already started. Can't change the crit rate mid-run...");
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static string GetLoggableCharacterName(Character character)
		{
			if (!character.isBot)
			{
				return character.characterName;
			}
			return ((Object)((Component)character).gameObject).name;
		}

		private void Update()
		{
		}
	}
}
namespace CriticalBlowgun.Patchers
{
	public static class BlowgunPatcher
	{
		private const float CRITICAL_HIT_FORCE = 125f;

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool IsItemABlowgun(Item item)
		{
			if (item.itemID != 70)
			{
				if (Plugin.HasUnnamedMod)
				{
					return item.UIData.itemName == "Blowgun";
				}
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(Action_RaycastDart), "DartImpact")]
		[HarmonyPostfix]
		public static void DartImpactPostfix(Action_RaycastDart __instance, Character hitCharacter, Vector3 origin, Vector3 endpoint)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: 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)
			if (Object.op_Implicit((Object)(object)hitCharacter) && Object.op_Implicit((Object)(object)((ItemActionBase)__instance).item) && IsItemABlowgun(((ItemActionBase)__instance).item) && ShouldInflictCriticalHit(hitCharacter))
			{
				ApplyCriticalHit(hitCharacter, origin, endpoint);
				((MonoBehaviourPun)__instance).photonView.RPC("RPC_DartCriticalImpact", (RpcTarget)0, new object[3]
				{
					((MonoBehaviourPun)hitCharacter).photonView.ViewID,
					origin,
					endpoint
				});
			}
		}

		[HarmonyPatch(typeof(Item), "Awake")]
		[HarmonyPostfix]
		public static void BlowStartPostfix(Item __instance)
		{
			if (__instance.itemID == 70)
			{
				CriticalDartPunController orAddComponent = ExtGameObject.GetOrAddComponent<CriticalDartPunController>(((Component)__instance).gameObject);
				if (!Object.op_Implicit((Object)(object)orAddComponent))
				{
					throw new ArgumentNullException("dartExtend");
				}
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool ShouldInflictCriticalHit(Character hitCharacter)
		{
			return Random.value < CalculateCritChance(hitCharacter);
		}

		private static float CalculateCritChance(Character hitChar)
		{
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: 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_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_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			float baseCritRate = Plugin.BaseCritRate;
			float num = baseCritRate * 0.95f / 0.125f;
			if (hitChar.isZombie || hitChar.isScoutmaster)
			{
				Plugin.Log.LogDebug((object)$"{Plugin.GetLoggableCharacterName(hitChar)} is an enemy. Setting crit rate to {num:P1}.");
				return num;
			}
			if ((Object)(object)Singleton<MapHandler>.Instance == (Object)null)
			{
				Plugin.Log.LogWarning((object)$"No run was started yet. Setting crit rate to {baseCritRate:P1}.");
				return baseCritRate;
			}
			List<Character> allPlayerCharacters = PlayerHandler.GetAllPlayerCharacters();
			if (allPlayerCharacters.Count <= 0)
			{
				Plugin.Log.LogError((object)$"No players were found. Setting crit rate to {baseCritRate:P1}.");
				return baseCritRate;
			}
			MapSegment val = Singleton<MapHandler>.Instance.segments[Singleton<MapHandler>.Instance.currentSegment];
			GameObject segmentCampfire = val.segmentCampfire;
			Vector3 position;
			if (!Object.op_Implicit((Object)(object)segmentCampfire))
			{
				Transform val2 = ((Component)Singleton<PeakHandler>.Instance).transform.Find("Box");
				position = ((Component)val2).transform.position;
			}
			else
			{
				position = segmentCampfire.transform.position;
			}
			Vector3 position2 = val.reconnectSpawnPos.position;
			float num2 = 0f;
			float num3 = Vector3.Distance(position2, position);
			int num4 = 0;
			foreach (Character item in allPlayerCharacters)
			{
				if (Object.op_Implicit((Object)(object)item) && !item.IsGhost)
				{
					num2 += Vector3.Distance(item.Center, position);
					num4++;
				}
			}
			if (num4 != 0)
			{
				num2 /= (float)num4;
				float num5 = Mathf.Lerp(1f, 0f, num2 / num3);
				Plugin.Log.LogDebug((object)$"Segment {Singleton<MapHandler>.Instance.GetCurrentSegment()} is {num5:P1} completed.");
				float num6 = Mathf.Lerp(baseCritRate, num, ((float)Singleton<MapHandler>.Instance.currentSegment + num5) / (float)Singleton<MapHandler>.Instance.segments.Length);
				Plugin.Log.LogDebug((object)$"Crit rate is {num6:P1}.");
				return num6;
			}
			Plugin.Log.LogError((object)$"No alive players were found. Setting crit rate to {baseCritRate:P1}.");
			return baseCritRate;
		}

		public static GameObject SpawnCriticalHitEffect(Vector3 position)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			GameObject val = new GameObject("CriticalHitEffect");
			val.transform.position = position;
			GameObject val2 = val;
			GameObject val3 = Object.Instantiate<GameObject>(Plugin.HitPrefab, ((Component)GUIManager.instance.hudCanvas).transform, true);
			CriticalHitEffectController orAddComponent = ExtGameObject.GetOrAddComponent<CriticalHitEffectController>(val3);
			orAddComponent.m_trackerTransform = val2.transform;
			return val2;
		}

		public static void ApplyCriticalHit(Character target, Vector3 origin, Vector3 endpoint)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: 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_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: 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_0075: 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_0085: 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_0091: 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_00a5: 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_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = endpoint - origin;
			Vector3 normalized = ((Vector3)(ref val)).normalized;
			Plugin.Log.LogInfo((object)("CRITICAL HIT!!! on " + Plugin.GetLoggableCharacterName(target) + "!"));
			Bodypart val2 = ExtCollections.FindClosest<Bodypart>(target.refs.ragdoll.partList, endpoint);
			if (val2 != null)
			{
				Plugin.Log.LogDebug((object)$"Found {Plugin.GetLoggableCharacterName(target)}'s {val2.partType}.");
				Rigidbody rig = val2.rig;
				Vector3 val3 = normalized * 125f / Time.fixedDeltaTime;
				val = normalized + ((Component)target).transform.up * 0.125f;
				target.AddForceToBodyPart(rig, val3, ((Vector3)(ref val)).normalized * 15.625f / Time.fixedDeltaTime);
			}
			else
			{
				Plugin.Log.LogDebug((object)("Found no closest bodypart on " + Plugin.GetLoggableCharacterName(target) + "."));
				target.AddForce(normalized * 125f / Time.fixedDeltaTime, 1f, 1f);
			}
			target.Fall(4f, 0f);
		}
	}
}
namespace CriticalBlowgun.Behaviours
{
	public class CriticalDartPunController : MonoBehaviourPun
	{
		[PunRPC]
		public void RPC_DartCriticalImpact(int characterID, Vector3 origin, Vector3 endpoint)
		{
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			if (characterID == -1)
			{
				return;
			}
			Character component = ((Component)PhotonNetwork.GetPhotonView(characterID)).gameObject.GetComponent<Character>();
			if ((Object)(object)component != (Object)null && ((MonoBehaviourPun)component).photonView.IsMine && component.IsObserved)
			{
				Plugin.Log.LogInfo((object)("I (" + Plugin.GetLoggableCharacterName(component) + ") AM CRITICALLY HIT!"));
				if (Plugin.PlaySoundIndicator)
				{
					Plugin.CritReceivedSfxi.Play(endpoint);
				}
				return;
			}
			Plugin.Log.LogInfo((object)((Object.op_Implicit((Object)(object)component) ? Plugin.GetLoggableCharacterName(component) : "SOMEONE") + " WAS CRITICALLY HIT!"));
			if (Plugin.ShowGUIIndicator)
			{
				BlowgunPatcher.SpawnCriticalHitEffect(endpoint);
			}
			if (Plugin.PlaySoundIndicator)
			{
				Plugin.CritHitSfxi.Play(origin);
			}
		}
	}
	public class CriticalHitEffectController : UIBehaviour
	{
		[NonSerialized]
		public Transform? m_trackerTransform;

		public RectTransform? m_rectTransform;

		public TextMeshProUGUI? m_textMeshPro;

		public float m_duration;

		public float m_preDelay = 0.25f;

		private Vector2 m_scaleReferences;

		private Vector2 m_trackerPosition;

		private float m_currentTime;

		protected override void Awake()
		{
			m_rectTransform = ((Component)this).GetComponent<RectTransform>();
			m_textMeshPro = ((Component)this).GetComponentInChildren<TextMeshProUGUI>();
			((TMP_Text)m_textMeshPro).font = Plugin.DarumaDropOne;
			((TMP_Text)m_textMeshPro).lineSpacing = -50f;
			TextMeshProUGUI? textMeshPro = m_textMeshPro;
			TextMeshProUGUI? textMeshPro2 = m_textMeshPro;
			Material val = (((Graphic)m_textMeshPro).material = Plugin.DarumaDropOneShadowMaterial);
			Material fontSharedMaterial = (((TMP_Text)textMeshPro2).fontMaterial = val);
			((TMP_Text)textMeshPro).fontSharedMaterial = fontSharedMaterial;
		}

		protected override void Start()
		{
			//IL_0017: 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_002d: 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)
			((UIBehaviour)this).Start();
			CanvasScaler componentInParent = ((Component)this).GetComponentInParent<CanvasScaler>();
			if (Object.op_Implicit((Object)(object)componentInParent))
			{
				m_scaleReferences = componentInParent.referenceResolution / new Vector2((float)Screen.width, (float)Screen.height);
			}
			((MonoBehaviour)this).StartCoroutine(Disappear());
		}

		private IEnumerator Disappear()
		{
			m_currentTime = 0f;
			float initialAlpha = ((Graphic)ThrowHelper.ThrowIfArgumentNull<TextMeshProUGUI>(m_textMeshPro, "m_textMeshPro")).color.a;
			while (m_currentTime <= m_preDelay)
			{
				m_currentTime += Time.deltaTime;
				TextMeshProUGUI? textMeshPro = m_textMeshPro;
				Color color = ((Graphic)m_textMeshPro).color;
				color.a = Mathf.Lerp(0f, initialAlpha, m_currentTime / m_preDelay);
				((Graphic)textMeshPro).color = color;
				yield return null;
			}
			yield return (object)new WaitForSeconds(m_preDelay * 0.5f);
			m_currentTime = 0f;
			float initialPos = ((Transform)((TMP_Text)m_textMeshPro).rectTransform).localPosition.y;
			while (m_currentTime <= m_duration)
			{
				m_currentTime += Time.deltaTime;
				TextMeshProUGUI? textMeshPro2 = m_textMeshPro;
				Color color = ((Graphic)m_textMeshPro).color;
				color.a = Mathf.Lerp(initialAlpha, 0f, m_currentTime / m_duration);
				((Graphic)textMeshPro2).color = color;
				RectTransform rectTransform = ((TMP_Text)m_textMeshPro).rectTransform;
				Vector3 localPosition = ((Transform)((TMP_Text)m_textMeshPro).rectTransform).localPosition;
				localPosition.y = Mathf.Lerp(initialPos, 200f, m_currentTime / m_duration);
				((Transform)rectTransform).localPosition = localPosition;
				yield return null;
			}
			Object.Destroy((Object)(object)((Component)this).gameObject);
			Object.Destroy((Object)(object)((Component)ThrowHelper.ThrowIfArgumentNull<Transform>(m_trackerTransform, "m_trackerTransform")).gameObject);
		}

		private void FixedUpdate()
		{
			//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_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: 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_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_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = MainCamera.instance.cam.WorldToScreenPoint(ThrowHelper.ThrowIfArgumentNull<Transform>(m_trackerTransform, "m_trackerTransform").position);
			((Transform)ThrowHelper.ThrowIfArgumentNull<RectTransform>(m_rectTransform, "m_rectTransform")).localScale = ((val.z < 0f) ? Vector3.zero : Vector3.one);
			m_trackerPosition = RectTransformUtility.WorldToScreenPoint(MainCamera.instance.cam, ThrowHelper.ThrowIfArgumentNull<Transform>(m_trackerTransform, "m_trackerTransform").position) - new Vector2((float)Screen.width, (float)Screen.height) * 0.5f;
			((Vector2)(ref m_trackerPosition)).Scale(m_scaleReferences);
		}

		private void OnGUI()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			ThrowHelper.ThrowIfArgumentNull<RectTransform>(m_rectTransform, "m_rectTransform").anchoredPosition = m_trackerPosition;
		}
	}
	public class DebugCriticalHitController : MonoBehaviourPun
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}