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 System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Logging;
using ExtraLethalCompany.Extra.Creatures;
using ExtraLethalCompany.Extra.ExtraTraitor;
using ExtraLethalCompany.Extra.Furniture.ExtraItemCharger;
using ExtraLethalCompany.Patches;
using GameNetcodeStuff;
using HarmonyLib;
using LC_API.ClientAPI;
using LC_API.Data;
using LC_API.GameInterfaceAPI;
using LC_API.ServerAPI;
using Microsoft.CodeAnalysis;
using Steamworks.Data;
using TMPro;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using UnityEngine.Rendering.HighDefinition;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("ExtraLethalCompany")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("My first plugin")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("ExtraLethalCompany")]
[assembly: AssemblyTitle("ExtraLethalCompany")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.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.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace ExtraLethalCompany
{
	internal static class Disabler
	{
		public static int MinimumToExplode;

		internal static void Init()
		{
			foreach (PluginInfo value in Chainloader.PluginInfos.Values)
			{
				MethodInfo method = typeof(Disabler).GetMethod(value.Metadata.GUID.Replace('.', '_').Replace(' ', '_'), BindingFlags.Static | BindingFlags.NonPublic);
				if (method != null)
				{
					ExtraLethalCompany.LogSource.LogInfo((object)("Disabling: " + ((object)value.Instance).GetType().Name));
					method.Invoke(typeof(Disabler), new object[1] { value.Instance });
				}
			}
		}

		private static void LethalCompanyMinimap(object inst)
		{
			DisableHarmony(inst, "harmony");
			Object.DestroyImmediate((Object)(object)GameObject.Find("MinimapGUI"));
		}

		private static void dev_alexanderdiaz_biggerbattery(object _)
		{
			MinimumToExplode = -3;
		}

		private static void stormytuna_RouteRandom(object inst)
		{
			DisableHarmony(inst, "harmony");
		}

		private static void NoPenalty(object inst)
		{
			DisableHarmony(inst, "harmonymain");
		}

		private static void DisableHarmony(object inst, string harmonyName)
		{
			Traverse.Create(inst).Field(harmonyName).GetValue<Harmony>()
				.UnpatchSelf();
		}
	}
	[BepInPlugin("ExtraLethalCompany", "ExtraLethalCompany", "1.1.5")]
	[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.*/)]
	public class ExtraLethalCompany : BaseUnityPlugin
	{
		public static ManualLogSource LogSource;

		private static readonly Harmony Harmony = new Harmony("ExtraLethalCompany");

		private void Awake()
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			if (((Object)((Component)this).gameObject).name != "ExtraLethalCompany")
			{
				GameObject val = new GameObject("ExtraLethalCompany");
				val.AddComponent<ExtraLethalCompany>();
				val.AddComponent<ExtraSporeLizzard>();
				val.AddComponent<ExtraTraitor>();
				Object.DontDestroyOnLoad((Object)(object)val);
				((Object)val).hideFlags = (HideFlags)61;
			}
			else
			{
				LogSource = ((BaseUnityPlugin)this).Logger;
				ModdedServer.SetServerModdedOnly();
				Disabler.Init();
				Harmony.PatchAll(typeof(HUDManager_Patch));
				Harmony.PatchAll(typeof(Terminal_Patch));
				Harmony.PatchAll(typeof(ItemCharger_Patch));
				Harmony.PatchAll(typeof(StartOfRound_Patch));
				Harmony.PatchAll(typeof(TimeOfDay_Patch));
				Harmony.PatchAll(typeof(BlobAI_Patch));
				((BaseUnityPlugin)this).Logger.LogInfo((object)"Plugin ExtraLethalCompany is loaded!");
			}
		}

		private void Update()
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Invalid comparison between Unknown and I4
			BlobAI[] array = Object.FindObjectsOfType<BlobAI>();
			foreach (BlobAI val in array)
			{
				GameObject gameObject = ((Component)val).gameObject;
				if ((Object)(object)gameObject.GetComponent<ExtraBlob>() == (Object)null)
				{
					gameObject.AddComponent<ExtraBlob>();
				}
			}
			if ((int)GameState.ShipState != 0 && (int)GameState.ShipState != 1)
			{
				return;
			}
			ItemCharger[] array2 = Object.FindObjectsOfType<ItemCharger>();
			foreach (ItemCharger val2 in array2)
			{
				GameObject gameObject2 = ((Component)val2).gameObject;
				if ((Object)(object)gameObject2.GetComponent<ExtraItemCharger>() == (Object)null)
				{
					gameObject2.AddComponent<ExtraItemCharger>();
				}
			}
		}

		private void LobbyEntered(Lobby lobby)
		{
			throw new NotImplementedException();
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "ExtraLethalCompany";

		public const string PLUGIN_NAME = "ExtraLethalCompany";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}
namespace ExtraLethalCompany.Patches
{
	internal static class HUDManager_Patch
	{
		[HarmonyPatch(typeof(HUDManager), "ApplyPenalty")]
		[HarmonyPrefix]
		private static bool ApplyPenaltyPrefix(HUDManager __instance, int playersDead, ref int bodiesInsured)
		{
			Terminal val = Object.FindObjectOfType<Terminal>();
			int profitQuota = TimeOfDay.Instance.profitQuota;
			int num = (int)((float)profitQuota * ((float)(playersDead - bodiesInsured) * 0.2f) + (float)profitQuota * ((float)bodiesInsured * 0.08f));
			int num2 = -Math.Min(val.groupCredits - num, 0);
			val.groupCredits -= num - num2;
			TimeOfDay instance = TimeOfDay.Instance;
			instance.profitQuota += num2;
			((TMP_Text)__instance.statsUIElements.penaltyAddition).text = $"{playersDead} casualties: -{20f * (float)(playersDead - bodiesInsured)}%\n" + $"{bodiesInsured} injuries: -{8f * (float)bodiesInsured}%\n" + "\nAll unpaid fines will be added to your quota.";
			((TMP_Text)__instance.statsUIElements.penaltyTotal).text = $"PAID: {num - num2}" + "\n" + $"DUE: {num2}";
			return false;
		}
	}
	internal static class StartOfRound_Patch
	{
		[HarmonyPatch(typeof(StartOfRound), "PowerSurgeShip")]
		[HarmonyPrefix]
		private static bool PowerSurgeShipPrefix(StartOfRound __instance)
		{
			__instance.mapScreen.SwitchScreenOn(false);
			if (!((NetworkBehaviour)__instance).IsServer)
			{
				return false;
			}
			CollectionExtensions.Do<TVScript>((IEnumerable<TVScript>)Object.FindObjectsOfType<TVScript>(), (Action<TVScript>)delegate(TVScript obj)
			{
				obj.TurnOffTVServerRpc();
			});
			__instance.shipRoomLights.SetShipLightsServerRpc(false);
			if (Random.Range(0, 10) == 0)
			{
				TimeOfDay.Instance.SetShipLeaveEarlyClientRpc(TimeOfDay.Instance.normalizedTimeOfDay + 0.04167f, TimeOfDay.Instance.votesForShipToLeaveEarly);
			}
			return false;
		}

		[HarmonyPatch(typeof(StartOfRound), "SetMapScreenInfoToCurrentLevel")]
		[HarmonyPostfix]
		private static void SetMapScreenInfoToCurrentLevelPrefix(StartOfRound __instance)
		{
			((TMP_Text)__instance.screenLevelDescription).text = "Orbiting: " + __instance.currentLevel.PlanetName + "\n" + __instance.currentLevel.LevelDescription + "\n" + "{Sensor Err}";
		}
	}
	internal static class Terminal_Patch
	{
		[HarmonyPatch(typeof(Terminal), "TextPostProcess")]
		[HarmonyPrefix]
		private static bool TextPostProcessPrefix(Terminal __instance, ref string __result, ref string modifiedDisplayText, TerminalNode node)
		{
			int num = modifiedDisplayText.Split("[planetTime]").Length - 1;
			if (num > 0)
			{
				Regex regex = new Regex(Regex.Escape("[planetTime]"));
				for (int i = 0; i < num && i < __instance.moonsCatalogueList.Length; i++)
				{
					modifiedDisplayText = regex.Replace(modifiedDisplayText, "{SENSOR ERR}", 1);
				}
			}
			if (node == null || node.displayPlanetInfo != -1)
			{
				modifiedDisplayText = modifiedDisplayText?.Replace("[currentPlanetTime]", "{SENSOR ERR}");
			}
			__result = modifiedDisplayText;
			return true;
		}
	}
	internal static class TimeOfDay_Patch
	{
		[HarmonyPatch(typeof(TimeOfDay), "SetBuyingRateForDay")]
		[HarmonyPrefix]
		private static bool SetBuyingRateForDayPrefix(TimeOfDay __instance)
		{
			__instance.daysUntilDeadline = (int)(__instance.timeUntilDeadline / __instance.totalTime);
			StartOfRound.Instance.companyBuyingRate = 1.15f - (float)(__instance.quotaVariables.deadlineDaysAmount - __instance.daysUntilDeadline) * (0.54f / (float)__instance.quotaVariables.deadlineDaysAmount);
			return false;
		}

		[HarmonyPatch(typeof(TimeOfDay), "SetShipLeaveEarlyServerRpc")]
		[HarmonyPostfix]
		private static void SetShipLeaveEarlyServerRpcPostfix(TimeOfDay __insntance)
		{
			int num = StartOfRound.Instance.connectedPlayersAmount + 1 - StartOfRound.Instance.livingPlayers;
			if (__insntance.votesForShipToLeaveEarly >= num)
			{
				__insntance.SetShipLeaveEarlyClientRpc(__insntance.normalizedTimeOfDay + 0.01f, __insntance.votesForShipToLeaveEarly);
			}
		}
	}
}
namespace ExtraLethalCompany.Extra.Furniture.ExtraItemCharger
{
	public class ExtraItemCharger : MonoBehaviour
	{
		private ItemCharger Charger;

		private GrabbableObject Item;

		private Coroutine Coroutine;

		public string ID { get; private set; }

		private void Awake()
		{
			//IL_0018: 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)
			//IL_0024: 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_003c: Unknown result type (might be due to invalid IL or missing references)
			Charger = ((Component)this).gameObject.GetComponent<ItemCharger>();
			Vector3 position = ((Component)this).transform.position;
			ID = $"{(int)position.x}-{(int)position.y}-{(int)position.z}";
			GameState.ShipStartedLeaving += delegate
			{
				Networking.SetSyncVariable("IsBroken" + ID, "False");
			};
		}

		private void Update()
		{
			if (Networking.GetSyncVariable("IsActive" + ID) == "")
			{
				Networking.RegisterSyncVariable("IsActive" + ID);
				Networking.SetSyncVariable("IsActive" + ID, "False");
			}
			if (Networking.GetSyncVariable("IsBroken" + ID) == "")
			{
				Networking.RegisterSyncVariable("IsBroken" + ID);
				Networking.SetSyncVariable("IsBroken" + ID, "False");
			}
			if (Coroutine == null && Networking.GetSyncVariable("IsActive" + ID) == "True")
			{
				Coroutine = ((MonoBehaviour)this).StartCoroutine(ChargeItemDelayed(Charger, Item));
			}
		}

		public void AskStartCharging(GrabbableObject item)
		{
			if (!(Networking.GetSyncVariable("IsBroken" + ID) == "True") && !(Networking.GetSyncVariable("IsActive" + ID) == "True"))
			{
				Item = item;
				bool flag = item.itemProperties.isConductiveMetal || Random.RandomRangeInt(-10, (int)(item.insertedBattery.charge * 10f) + 1) >= Disabler.MinimumToExplode;
				Networking.SetSyncVariable("IsBroken" + ID, flag.ToString());
				Networking.SetSyncVariable("IsActive" + ID, "True");
			}
		}

		private IEnumerator ChargeItemDelayed(ItemCharger inst, GrabbableObject item)
		{
			inst.zapAudio.Play();
			yield return (object)new WaitForSeconds(0.75f);
			inst.chargeStationAnimator.SetTrigger("zap");
			if ((Object)(object)item != (Object)null && item.itemProperties.requiresBattery)
			{
				item.SyncBatteryServerRpc(100);
				Item = null;
			}
			if (Networking.GetSyncVariable("IsBroken" + ID) == "True")
			{
				Landmine.SpawnExplosion(((Component)this).transform.position, true, 2.4f, 5f);
				StartOfRound.Instance.PowerSurgeShip();
			}
			Networking.SetSyncVariable("IsActive" + ID, "False");
			Coroutine = null;
		}
	}
	internal static class ItemCharger_Patch
	{
		[HarmonyPatch(typeof(ItemCharger), "ChargeItem")]
		[HarmonyPrefix]
		private static bool ChargeItemPrefix(ItemCharger __instance)
		{
			if (!StartOfRound.Instance.shipHasLanded)
			{
				return false;
			}
			GrabbableObject currentlyHeldObjectServer = GameNetworkManager.Instance.localPlayerController.currentlyHeldObjectServer;
			if ((Object)(object)currentlyHeldObjectServer == (Object)null)
			{
				return false;
			}
			if (!currentlyHeldObjectServer.itemProperties.requiresBattery && !currentlyHeldObjectServer.itemProperties.isConductiveMetal)
			{
				return false;
			}
			ExtraItemCharger component = ((Component)__instance).gameObject.GetComponent<ExtraItemCharger>();
			component.AskStartCharging(currentlyHeldObjectServer);
			return false;
		}

		[HarmonyPatch(typeof(ItemCharger), "Update")]
		[HarmonyPrefix]
		private static bool UpdatePrefix(ItemCharger __instance)
		{
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)NetworkManager.Singleton == (Object)null)
			{
				return false;
			}
			ExtraItemCharger component = ((Component)__instance).gameObject.GetComponent<ExtraItemCharger>();
			Traverse val = Traverse.Create((object)__instance).Field("updateInterval");
			val.SetValue((object)(val.GetValue<float>() + Time.deltaTime));
			if (val.GetValue<float>() > 1f)
			{
				val.SetValue((object)0f);
				ShipState shipState = GameState.ShipState;
				if (!((object)(ShipState)(ref shipState)).Equals((object)(ShipState)1))
				{
					__instance.triggerScript.interactable = false;
					__instance.triggerScript.disabledHoverTip = "[Wait for ship to land]";
					return false;
				}
				if ((Object)(object)component != (Object)null && Networking.GetSyncVariable("IsBroken" + component.ID) == "True")
				{
					__instance.triggerScript.interactable = false;
					__instance.triggerScript.disabledHoverTip = "[Charger broken for the round]";
					return false;
				}
				GrabbableObject val2 = GameNetworkManager.Instance.localPlayerController?.currentlyHeldObjectServer;
				__instance.triggerScript.interactable = (Object)(object)val2 != (Object)null && (val2.itemProperties.requiresBattery || val2.itemProperties.isConductiveMetal);
				__instance.triggerScript.disabledHoverTip = "";
			}
			return false;
		}
	}
}
namespace ExtraLethalCompany.Extra.ExtraTraitor
{
	public class EnemyPlayerController : MonoBehaviour
	{
		public static EnemyPlayerController Instance;

		private Keyboard Keyboard = Keyboard.current;

		private void Awake()
		{
			Instance = this;
		}

		private void Update()
		{
			if (!((ButtonControl)Keyboard.f1Key).wasPressedThisFrame)
			{
			}
		}
	}
	public class ExtraTraitor : MonoBehaviour
	{
		private void Awake()
		{
			Networking.RegisterSyncVariable("TraitorID");
			GameState.LandOnMoon += Landing;
			GameState.ShipStartedLeaving += Leaving;
			CommandHandler.RegisterCommand("morph", (Action<string[]>)delegate(string[] args)
			{
				if (StartOfRound.Instance.thisClientPlayerId == int.Parse(Networking.GetSyncVariable("TraitorID")) && args.Length >= 1)
				{
					ExtraLethalCompany.LogSource.LogInfo((object)args[0]);
					string text = args[0].ToLower();
					string text2 = text;
					if (text2 != null)
					{
						switch (text2.Length)
						{
						case 5:
							switch (text2[1])
							{
							case 'p':
								if (text2 == "spore")
								{
								}
								break;
							case 'l':
								if (text2 == "slime")
								{
								}
								break;
							case 'h':
								if (text2 == "ghost")
								{
								}
								break;
							case 'i':
								if (text2 == "giant")
								{
								}
								break;
							}
							break;
						case 7:
							switch (text2[0])
							{
							case 'h':
								if (text2 == "hoarder")
								{
								}
								break;
							case 'b':
								if (text2 == "bracken")
								{
								}
								break;
							case 't':
								if (text2 == "thumper")
								{
								}
								break;
							}
							break;
						case 6:
							switch (text2[0])
							{
							case 'm':
								if (text2 == "masked")
								{
								}
								break;
							case 's':
								if (text2 == "spider")
								{
								}
								break;
							case 'j':
								if (text2 == "jester")
								{
								}
								break;
							}
							break;
						case 4:
							switch (text2[0])
							{
							case 'f':
								if (text2 == "flea")
								{
								}
								break;
							case 'c':
								if (text2 == "coil")
								{
								}
								break;
							case 'h':
								if (text2 == "hawk")
								{
								}
								break;
							case 'w':
								if (text2 == "worm")
								{
								}
								break;
							}
							break;
						case 10:
							if (text2 == "nutcracker")
							{
							}
							break;
						case 3:
							if (text2 == "dog")
							{
							}
							break;
						case 8:
						case 9:
							break;
						}
					}
				}
			});
		}

		private void Landing()
		{
			if (((NetworkBehaviour)StartOfRound.Instance).IsHost)
			{
				Networking.SetSyncVariable("TraitorID", Random.RandomRangeInt(-1, StartOfRound.Instance.allPlayerScripts.Length).ToString());
			}
		}

		private void Leaving()
		{
			if (((NetworkBehaviour)StartOfRound.Instance).IsHost)
			{
				Networking.SetSyncVariable("TraitorID", "");
			}
		}
	}
}
namespace ExtraLethalCompany.Extra.Creatures
{
	internal static class BlobAI_Patch
	{
		[HarmonyPatch(typeof(BlobAI), "SlimeKillPlayerEffectServerRpc")]
		[HarmonyPostfix]
		private static void SlimeKillPlayerEffectServerRpc(BlobAI __instance, int playerKilled)
		{
			if (((NetworkBehaviour)__instance).IsHost)
			{
				((Component)__instance).gameObject.GetComponent<ExtraBlob>()?.AskEatPlayerBody(playerKilled);
			}
		}
	}
	public class ExtraBlob : MonoBehaviour
	{
		public Coroutine EatPlayerBodyCoroutine;

		private BlobAI Blob;

		private void Awake()
		{
			Blob = ((Component)this).gameObject.GetComponent<BlobAI>();
		}

		private void OnCollisionEnter(Collision collision)
		{
			//IL_005f: 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)
			if (((NetworkBehaviour)Blob).IsHost && ((EnemyAI)Blob).ventAnimationFinished && !((EnemyAI)Blob).isEnemyDead)
			{
				GrabbableObject component = ((Component)collision.collider).gameObject.GetComponent<GrabbableObject>();
				if ((Object)(object)component != (Object)null)
				{
					Object.DestroyImmediate((Object)(object)component);
					Transform transform = ((Component)this).gameObject.transform;
					transform.localScale *= 1.05f;
				}
			}
		}

		public void AskEatPlayerBody(int playerKilled)
		{
			if (EatPlayerBodyCoroutine == null)
			{
				EatPlayerBodyCoroutine = ((MonoBehaviour)this).StartCoroutine(EatPlayerBody(playerKilled));
			}
		}

		private IEnumerator EatPlayerBody(int playerKilled)
		{
			yield return null;
			PlayerControllerB playerScript = StartOfRound.Instance.allPlayerScripts[playerKilled];
			float startTime = Time.realtimeSinceStartup;
			yield return (object)new WaitUntil((Func<bool>)(() => (Object)(object)playerScript.deadBody != (Object)null || Time.realtimeSinceStartup - startTime > 2f));
			if ((Object)(object)playerScript.deadBody == (Object)null)
			{
				Debug.Log((object)"Blob: Player body was not spawned or found within 2 seconds.");
				yield break;
			}
			yield return (object)new WaitForSeconds(2f);
			Transform transform = ((Component)this).gameObject.transform;
			transform.localScale *= 1.1f;
		}
	}
	public class ExtraSporeLizzard : MonoBehaviour
	{
		private void Update()
		{
			//IL_0075: 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_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: 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_00c1: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)StartOfRound.Instance == (Object)null)
			{
				return;
			}
			LocalVolumetricFog[] array = (from g in Object.FindObjectsOfType<LocalVolumetricFog>()
				where ((Object)g).name.Contains("PufferSmoke", StringComparison.OrdinalIgnoreCase)
				select g).ToArray();
			if (array.Length == 0)
			{
				return;
			}
			PlayerControllerB val = StartOfRound.Instance.allPlayerScripts[StartOfRound.Instance.thisClientPlayerId];
			Vector3 position = ((Component)val).gameObject.transform.position;
			for (int i = 0; i < array.Length; i++)
			{
				if (!(Vector3.Distance(position, ((Component)array[i]).transform.position) >= 1f))
				{
					val.DamagePlayer((int)(15f * Time.deltaTime), true, true, (CauseOfDeath)5, 0, false, default(Vector3));
				}
			}
		}
	}
}