using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Photon.Pun;
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(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("")]
[assembly: AssemblyCompany("REPOJP")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("REPOJP")]
[assembly: AssemblyTitle("REPOJP")]
[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.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 REPOJP.ShadowChildEnhancements
{
	[BepInPlugin("REPOJP.ShadowChildEnhancements", "ShadowChildEnhancements", "1.0.0")]
	public sealed class ShadowChildEnhancementsPlugin : BaseUnityPlugin
	{
		public const string PluginGuid = "REPOJP.ShadowChildEnhancements";

		public const string PluginName = "ShadowChildEnhancements";

		public const string PluginVersion = "1.0.0";

		internal static ShadowChildEnhancementsPlugin Instance;

		internal static ConfigEntry<float> CfgEyeContactSeconds;

		internal static ConfigEntry<float> CfgKnockbackMultiplier;

		internal static ConfigEntry<int> CfgDamage;

		internal static ConfigEntry<float> CfgLookAwayGraceSeconds;

		internal static ConfigEntry<bool> CfgSolidarityAttack;

		private void Awake()
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Expected O, but got Unknown
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Expected O, but got Unknown
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Expected O, but got Unknown
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Expected O, but got Unknown
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Expected O, but got Unknown
			Instance = this;
			CfgEyeContactSeconds = ((BaseUnityPlugin)this).Config.Bind<float>("ShadowChild", "EyeContactSeconds", 3f, new ConfigDescription("Seconds required before attack.攻撃までに必要な目合わせ秒数", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 20f), Array.Empty<object>()));
			CfgKnockbackMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("ShadowChild", "KnockbackMultiplier", 10f, new ConfigDescription("Knockback multiplier toward the enemy.敵方向へ引き寄せるノックバック倍率", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 50f), Array.Empty<object>()));
			CfgDamage = ((BaseUnityPlugin)this).Config.Bind<int>("ShadowChild", "Damage", 50, new ConfigDescription("Damage amount.ダメージ量", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100), Array.Empty<object>()));
			CfgLookAwayGraceSeconds = ((BaseUnityPlugin)this).Config.Bind<float>("ShadowChild", "LookAwayGraceSeconds", 0f, new ConfigDescription("Grace seconds after looking away.目を外した直後の猶予秒数", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 20f), Array.Empty<object>()));
			CfgSolidarityAttack = ((BaseUnityPlugin)this).Config.Bind<bool>("ShadowChild", "SolidarityAttack", true, "Attack all players who entered sight at least once.一瞬でも視界に入ったプレイヤー全員を攻撃対象に含める");
			Harmony val = new Harmony("REPOJP.ShadowChildEnhancements");
			val.PatchAll(typeof(ShadowChildEnhancementsPatches));
		}
	}
	internal static class ShadowChildEnhancementsPatches
	{
		private sealed class RuntimeState
		{
			public float LastOnScreenTime = -99999f;

			public readonly HashSet<int> AccumulatedViewIds = new HashSet<int>();

			public float BaseHitForce;

			public float BaseTumbleForce;

			public float BaseTumbleTorque;

			public bool BaseForceCached;
		}

		private const float FixedLookAwayDecayMultiplier = 0f;

		private const float ExpandedPaddingWidth = 0.35f;

		private const float ExpandedPaddingHeight = 0.35f;

		private const float FastOnScreenPollInterval = 0.02f;

		private static readonly ConditionalWeakTable<EnemyThinMan, RuntimeState> StateTable = new ConditionalWeakTable<EnemyThinMan, RuntimeState>();

		private static readonly FieldRef<EnemyThinMan, Enemy> F_EnemyThinMan_enemy = AccessTools.FieldRefAccess<EnemyThinMan, Enemy>("enemy");

		private static readonly FieldRef<EnemyThinMan, bool> F_EnemyThinMan_stateImpulse = AccessTools.FieldRefAccess<EnemyThinMan, bool>("stateImpulse");

		private static readonly FieldRef<EnemyThinMan, PlayerAvatar> F_EnemyThinMan_playerTarget = AccessTools.FieldRefAccess<EnemyThinMan, PlayerAvatar>("playerTarget");

		private static readonly MethodInfo M_EnemyThinMan_UpdateState = AccessTools.Method(typeof(EnemyThinMan), "UpdateState", new Type[1] { typeof(State) }, (Type[])null);

		private static readonly MethodInfo M_EnemyThinMan_SetTarget = AccessTools.Method(typeof(EnemyThinMan), "SetTarget", new Type[1] { typeof(PlayerAvatar) }, (Type[])null);

		private static readonly FieldRef<Enemy, EnemyOnScreen> F_Enemy_OnScreen = AccessTools.FieldRefAccess<Enemy, EnemyOnScreen>("OnScreen");

		private static readonly FieldInfo FI_EnemyOnScreen_OnScreenTimer = AccessTools.Field(typeof(EnemyOnScreen), "OnScreenTimer");

		private static readonly FieldRef<PlayerAvatar, bool> F_PlayerAvatar_isDisabled = AccessTools.FieldRefAccess<PlayerAvatar, bool>("isDisabled");

		private static readonly FieldRef<PlayerAvatar, bool> F_PlayerAvatar_deadSet = AccessTools.FieldRefAccess<PlayerAvatar, bool>("deadSet");

		private static readonly FieldRef<PlayerHealth, int> F_PlayerHealth_health = AccessTools.FieldRefAccess<PlayerHealth, int>("health");

		private static readonly FieldRef<PlayerTumble, bool> F_PlayerTumble_isTumbling = AccessTools.FieldRefAccess<PlayerTumble, bool>("isTumbling");

		private static bool IsMasterOrSingle()
		{
			if (!SemiFunc.IsMultiplayer())
			{
				return true;
			}
			return PhotonNetwork.IsMasterClient;
		}

		private static RuntimeState GetState(EnemyThinMan thinMan)
		{
			return StateTable.GetOrCreateValue(thinMan);
		}

		private static Enemy GetEnemy(EnemyThinMan thinMan)
		{
			try
			{
				return F_EnemyThinMan_enemy.Invoke(thinMan);
			}
			catch
			{
				return null;
			}
		}

		private static PlayerAvatar GetTarget(EnemyThinMan thinMan)
		{
			try
			{
				return F_EnemyThinMan_playerTarget.Invoke(thinMan);
			}
			catch
			{
				return null;
			}
		}

		private static void SetTarget(EnemyThinMan thinMan, PlayerAvatar target)
		{
			if ((Object)(object)thinMan == (Object)null || M_EnemyThinMan_SetTarget == null)
			{
				return;
			}
			try
			{
				M_EnemyThinMan_SetTarget.Invoke(thinMan, new object[1] { target });
			}
			catch
			{
			}
		}

		private static void UpdateState(EnemyThinMan thinMan, State state)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)thinMan == (Object)null || M_EnemyThinMan_UpdateState == null)
			{
				return;
			}
			try
			{
				M_EnemyThinMan_UpdateState.Invoke(thinMan, new object[1] { state });
			}
			catch
			{
			}
		}

		private static bool HasConfigKey(string section, string key)
		{
			try
			{
				string path = Path.Combine(Paths.ConfigPath, "REPOJP.ShadowChildEnhancements.cfg");
				if (!File.Exists(path))
				{
					return false;
				}
				bool flag = false;
				string[] array = File.ReadAllLines(path);
				for (int i = 0; i < array.Length; i++)
				{
					string text = array[i].Trim();
					if (text.Length == 0 || text.StartsWith("#", StringComparison.Ordinal) || text.StartsWith("//", StringComparison.Ordinal))
					{
						continue;
					}
					if (text.StartsWith("[", StringComparison.Ordinal) && text.EndsWith("]", StringComparison.Ordinal))
					{
						string a = text.Substring(1, text.Length - 2);
						flag = string.Equals(a, section, StringComparison.OrdinalIgnoreCase);
					}
					else
					{
						if (!flag)
						{
							continue;
						}
						int num = text.IndexOf('=');
						if (num > 0)
						{
							string a2 = text.Substring(0, num).Trim();
							if (string.Equals(a2, key, StringComparison.OrdinalIgnoreCase))
							{
								return true;
							}
						}
					}
				}
			}
			catch
			{
			}
			return false;
		}

		private static void TuneOnScreenComponent(EnemyThinMan thinMan)
		{
			Enemy enemy = GetEnemy(thinMan);
			if ((Object)(object)enemy == (Object)null)
			{
				return;
			}
			EnemyOnScreen val = null;
			try
			{
				val = F_Enemy_OnScreen.Invoke(enemy);
			}
			catch
			{
				val = null;
			}
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			try
			{
				val.paddingWidth = 0.35f;
				val.paddingHeight = 0.35f;
			}
			catch
			{
			}
			try
			{
				if (FI_EnemyOnScreen_OnScreenTimer != null)
				{
					FI_EnemyOnScreen_OnScreenTimer.SetValue(val, 0.02f);
				}
			}
			catch
			{
			}
		}

		private static void CacheBaseForces(EnemyThinMan thinMan)
		{
			RuntimeState state = GetState(thinMan);
			if (!state.BaseForceCached && !((Object)(object)thinMan == (Object)null) && !((Object)(object)thinMan.hurtCollider == (Object)null))
			{
				HurtCollider component = thinMan.hurtCollider.GetComponent<HurtCollider>();
				if (!((Object)(object)component == (Object)null))
				{
					state.BaseHitForce = component.playerHitForce;
					state.BaseTumbleForce = component.playerTumbleForce;
					state.BaseTumbleTorque = component.playerTumbleTorque;
					state.BaseForceCached = true;
				}
			}
		}

		private static bool IsAttackable(PlayerAvatar avatar)
		{
			if ((Object)(object)avatar == (Object)null)
			{
				return false;
			}
			if ((Object)(object)avatar.photonView == (Object)null)
			{
				return false;
			}
			bool flag = false;
			bool flag2 = false;
			try
			{
				flag = F_PlayerAvatar_isDisabled.Invoke(avatar);
			}
			catch
			{
				flag = false;
			}
			try
			{
				flag2 = F_PlayerAvatar_deadSet.Invoke(avatar);
			}
			catch
			{
				flag2 = false;
			}
			if (flag || flag2)
			{
				return false;
			}
			if ((Object)(object)avatar.playerHealth == (Object)null)
			{
				return false;
			}
			int num = 1;
			try
			{
				num = F_PlayerHealth_health.Invoke(avatar.playerHealth);
			}
			catch
			{
				num = 1;
			}
			return num > 0;
		}

		private static List<PlayerAvatar> GetVisiblePlayers(EnemyThinMan thinMan)
		{
			List<PlayerAvatar> list = new List<PlayerAvatar>();
			Enemy enemy = GetEnemy(thinMan);
			if ((Object)(object)enemy == (Object)null)
			{
				return list;
			}
			EnemyOnScreen val = null;
			try
			{
				val = F_Enemy_OnScreen.Invoke(enemy);
			}
			catch
			{
				val = null;
			}
			if ((Object)(object)val == (Object)null || (Object)(object)GameDirector.instance == (Object)null || GameDirector.instance.PlayerList == null)
			{
				return list;
			}
			foreach (PlayerAvatar player in GameDirector.instance.PlayerList)
			{
				if (IsAttackable(player))
				{
					bool flag = false;
					try
					{
						flag = val.GetOnScreen(player);
					}
					catch
					{
						flag = false;
					}
					if (flag)
					{
						list.Add(player);
					}
				}
			}
			return list;
		}

		private static bool ContainsPlayer(List<PlayerAvatar> players, PlayerAvatar target)
		{
			if (players == null || (Object)(object)target == (Object)null)
			{
				return false;
			}
			for (int i = 0; i < players.Count; i++)
			{
				if ((Object)(object)players[i] == (Object)(object)target)
				{
					return true;
				}
			}
			return false;
		}

		private static void TrackVisiblePlayers(EnemyThinMan thinMan, List<PlayerAvatar> visiblePlayers)
		{
			if ((Object)(object)thinMan == (Object)null || visiblePlayers == null || visiblePlayers.Count == 0)
			{
				return;
			}
			RuntimeState state = GetState(thinMan);
			for (int i = 0; i < visiblePlayers.Count; i++)
			{
				PlayerAvatar val = visiblePlayers[i];
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val.photonView == (Object)null))
				{
					int viewID = val.photonView.ViewID;
					if (viewID > 0)
					{
						state.AccumulatedViewIds.Add(viewID);
					}
				}
			}
		}

		private static List<PlayerAvatar> CollectVictims(EnemyThinMan thinMan, PlayerAvatar primary)
		{
			List<PlayerAvatar> list = new List<PlayerAvatar>();
			if (!ShadowChildEnhancementsPlugin.CfgSolidarityAttack.Value)
			{
				if (IsAttackable(primary))
				{
					list.Add(primary);
				}
				else
				{
					RuntimeState state = GetState(thinMan);
					foreach (int accumulatedViewId in state.AccumulatedViewIds)
					{
						PhotonView val = null;
						try
						{
							val = PhotonView.Find(accumulatedViewId);
						}
						catch
						{
							val = null;
						}
						if (!((Object)(object)val == (Object)null))
						{
							PlayerAvatar component = ((Component)val).GetComponent<PlayerAvatar>();
							if (IsAttackable(component))
							{
								list.Add(component);
								break;
							}
						}
					}
				}
				return list;
			}
			RuntimeState state2 = GetState(thinMan);
			foreach (int accumulatedViewId2 in state2.AccumulatedViewIds)
			{
				PhotonView val2 = null;
				try
				{
					val2 = PhotonView.Find(accumulatedViewId2);
				}
				catch
				{
					val2 = null;
				}
				if ((Object)(object)val2 == (Object)null)
				{
					continue;
				}
				PlayerAvatar component2 = ((Component)val2).GetComponent<PlayerAvatar>();
				if (!IsAttackable(component2))
				{
					continue;
				}
				bool flag = false;
				for (int i = 0; i < list.Count; i++)
				{
					if ((Object)(object)list[i] == (Object)(object)component2)
					{
						flag = true;
						break;
					}
				}
				if (!flag)
				{
					list.Add(component2);
				}
			}
			if (IsAttackable(primary) && !ContainsPlayer(list, primary))
			{
				list.Insert(0, primary);
			}
			return list;
		}

		private static void ApplyKnockback(PlayerAvatar playerAvatar, Vector3 enemyPosition, float hitForce, float tumbleForce, float tumbleTorque)
		{
			//IL_0012: 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)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00d8: 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_0106: 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_00ab: 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)
			if ((Object)(object)playerAvatar == (Object)null)
			{
				return;
			}
			Vector3 val = enemyPosition - ((Component)playerAvatar).transform.position;
			if (((Vector3)(ref val)).sqrMagnitude <= 0.0001f)
			{
				val = Vector3.forward;
			}
			((Vector3)(ref val)).Normalize();
			bool flag = false;
			try
			{
				if ((Object)(object)playerAvatar.tumble != (Object)null)
				{
					flag = F_PlayerTumble_isTumbling.Invoke(playerAvatar.tumble);
				}
			}
			catch
			{
				flag = false;
			}
			if (flag && (Object)(object)playerAvatar.tumble != (Object)null)
			{
				if (tumbleForce > 0f)
				{
					try
					{
						playerAvatar.tumble.TumbleForce(val * tumbleForce);
					}
					catch
					{
					}
				}
				if (tumbleTorque > 0f)
				{
					try
					{
						playerAvatar.tumble.TumbleTorque(Vector3.up * tumbleTorque);
					}
					catch
					{
					}
				}
			}
			else if (hitForce > 0f)
			{
				try
				{
					playerAvatar.ForceImpulse(val * hitForce);
				}
				catch
				{
				}
			}
		}

		[HarmonyPatch(typeof(EnemyThinMan), "OnSpawn")]
		[HarmonyPostfix]
		private static void EnemyThinMan_OnSpawn_Postfix(EnemyThinMan __instance)
		{
			if (!((Object)(object)__instance == (Object)null))
			{
				RuntimeState state = GetState(__instance);
				state.LastOnScreenTime = -99999f;
				state.AccumulatedViewIds.Clear();
				CacheBaseForces(__instance);
				TuneOnScreenComponent(__instance);
			}
		}

		[HarmonyPatch(typeof(EnemyThinMan), "Awake")]
		[HarmonyPostfix]
		private static void EnemyThinMan_Awake_Postfix(EnemyThinMan __instance)
		{
			if ((Object)(object)__instance == (Object)null)
			{
				return;
			}
			TuneOnScreenComponent(__instance);
			CacheBaseForces(__instance);
			if (!IsMasterOrSingle() || HasConfigKey("ShadowChild", "EyeContactSeconds"))
			{
				return;
			}
			try
			{
				if (!((Object)(object)__instance.anim != (Object)null))
				{
					return;
				}
				float tentacleSpeed = __instance.anim.tentacleSpeed;
				if (tentacleSpeed > 0.0001f)
				{
					ShadowChildEnhancementsPlugin.CfgEyeContactSeconds.Value = Mathf.Clamp(1f / tentacleSpeed, 0f, 20f);
					if ((Object)(object)ShadowChildEnhancementsPlugin.Instance != (Object)null)
					{
						((BaseUnityPlugin)ShadowChildEnhancementsPlugin.Instance).Config.Save();
					}
				}
			}
			catch
			{
			}
		}

		[HarmonyPatch(typeof(EnemyThinMan), "StateStand")]
		[HarmonyPostfix]
		private static void EnemyThinMan_StateStand_Postfix(EnemyThinMan __instance)
		{
			if (IsMasterOrSingle() && !((Object)(object)__instance == (Object)null))
			{
				List<PlayerAvatar> visiblePlayers = GetVisiblePlayers(__instance);
				if (visiblePlayers.Count > 0)
				{
					TrackVisiblePlayers(__instance, visiblePlayers);
				}
			}
		}

		[HarmonyPatch(typeof(EnemyThinMan), "StateOnScreen")]
		[HarmonyPrefix]
		private static bool EnemyThinMan_StateOnScreen_Prefix(EnemyThinMan __instance)
		{
			if (!IsMasterOrSingle() || (Object)(object)__instance == (Object)null)
			{
				return true;
			}
			TuneOnScreenComponent(__instance);
			List<PlayerAvatar> visiblePlayers = GetVisiblePlayers(__instance);
			if (visiblePlayers.Count > 0)
			{
				TrackVisiblePlayers(__instance, visiblePlayers);
				PlayerAvatar target = GetTarget(__instance);
				if ((Object)(object)target == (Object)null || !ContainsPlayer(visiblePlayers, target))
				{
					SetTarget(__instance, visiblePlayers[0]);
				}
			}
			return true;
		}

		[HarmonyPatch(typeof(EnemyThinMan), "StateStunned")]
		[HarmonyPostfix]
		private static void EnemyThinMan_StateStunned_Postfix(EnemyThinMan __instance)
		{
			if (IsMasterOrSingle() && !((Object)(object)__instance == (Object)null))
			{
				RuntimeState state = GetState(__instance);
				state.LastOnScreenTime = -99999f;
				state.AccumulatedViewIds.Clear();
				__instance.tentacleLerp = 0f;
				SetTarget(__instance, null);
			}
		}

		[HarmonyPatch(typeof(EnemyThinMan), "TentacleLogic")]
		[HarmonyPrefix]
		private static bool EnemyThinMan_TentacleLogic_Prefix(EnemyThinMan __instance)
		{
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Invalid comparison between Unknown and I4
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Invalid comparison between Unknown and I4
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Invalid comparison between Unknown and I4
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Invalid comparison between Unknown and I4
			if (!IsMasterOrSingle())
			{
				return true;
			}
			if ((Object)(object)__instance == (Object)null)
			{
				return false;
			}
			RuntimeState state = GetState(__instance);
			List<PlayerAvatar> visiblePlayers = GetVisiblePlayers(__instance);
			bool flag = visiblePlayers.Count > 0;
			if (flag)
			{
				TrackVisiblePlayers(__instance, visiblePlayers);
				state.LastOnScreenTime = Time.time;
				PlayerAvatar target = GetTarget(__instance);
				if ((Object)(object)target == (Object)null || !ContainsPlayer(visiblePlayers, target))
				{
					SetTarget(__instance, visiblePlayers[0]);
				}
			}
			float num = Mathf.Clamp(ShadowChildEnhancementsPlugin.CfgEyeContactSeconds.Value, 0f, 20f);
			float num2 = Mathf.Clamp(ShadowChildEnhancementsPlugin.CfgLookAwayGraceSeconds.Value, 0f, 20f);
			float num3 = ((num <= 0.0001f) ? 9999f : (1f / num));
			float deltaTime = Time.deltaTime;
			float num4 = __instance.tentacleLerp;
			if ((int)__instance.currentState == 1)
			{
				if (flag)
				{
					num4 += num3 * deltaTime;
				}
				else
				{
					float num5 = Time.time - state.LastOnScreenTime;
					if (num5 > num2)
					{
						num4 -= num3 * 0.5f * 0f * deltaTime;
					}
				}
			}
			else if ((int)__instance.currentState != 3)
			{
				if ((int)__instance.currentState == 4)
				{
					num4 -= 10f * deltaTime;
				}
				else if ((int)__instance.currentState == 7)
				{
					num4 = 0f;
					state.AccumulatedViewIds.Clear();
					state.LastOnScreenTime = -99999f;
				}
				else
				{
					float num6 = Time.time - state.LastOnScreenTime;
					if (num6 > num2)
					{
						num4 -= num3 * 0.5f * 0f * deltaTime;
					}
				}
			}
			__instance.tentacleLerp = Mathf.Clamp(num4, 0f, 1f);
			return false;
		}

		[HarmonyPatch(typeof(EnemyThinMan), "StateDamage")]
		[HarmonyPrefix]
		private static bool EnemyThinMan_StateDamage_Prefix(EnemyThinMan __instance)
		{
			//IL_01a2: 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_0141: 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_018a: Unknown result type (might be due to invalid IL or missing references)
			if (!IsMasterOrSingle())
			{
				return true;
			}
			if ((Object)(object)__instance == (Object)null)
			{
				return false;
			}
			bool flag = false;
			try
			{
				flag = F_EnemyThinMan_stateImpulse.Invoke(__instance);
			}
			catch
			{
				flag = false;
			}
			if (!flag)
			{
				return false;
			}
			try
			{
				F_EnemyThinMan_stateImpulse.Invoke(__instance) = false;
			}
			catch
			{
			}
			CacheBaseForces(__instance);
			RuntimeState state = GetState(__instance);
			PlayerAvatar target = GetTarget(__instance);
			List<PlayerAvatar> list = CollectVictims(__instance, target);
			if (list.Count == 0)
			{
				state.AccumulatedViewIds.Clear();
				state.LastOnScreenTime = -99999f;
				SetTarget(__instance, null);
				UpdateState(__instance, (State)6);
				return false;
			}
			int num = Mathf.Clamp(ShadowChildEnhancementsPlugin.CfgDamage.Value, 0, 100);
			float num2 = Mathf.Clamp(ShadowChildEnhancementsPlugin.CfgKnockbackMultiplier.Value, 0f, 50f);
			Enemy enemy = GetEnemy(__instance);
			int num3 = -1;
			if ((Object)(object)enemy != (Object)null)
			{
				try
				{
					num3 = SemiFunc.EnemyGetIndex(enemy);
				}
				catch
				{
					num3 = -1;
				}
			}
			Vector3 enemyPosition = (((Object)(object)__instance.rb != (Object)null) ? __instance.rb.position : ((Component)__instance).transform.position);
			for (int i = 0; i < list.Count; i++)
			{
				PlayerAvatar val = list[i];
				if (IsAttackable(val))
				{
					try
					{
						val.playerHealth.HurtOther(num, ((Component)val).transform.position, false, num3);
					}
					catch
					{
					}
					ApplyKnockback(val, enemyPosition, state.BaseHitForce * num2, state.BaseTumbleForce * num2, state.BaseTumbleTorque * num2);
				}
			}
			state.AccumulatedViewIds.Clear();
			state.LastOnScreenTime = -99999f;
			SetTarget(__instance, null);
			UpdateState(__instance, (State)6);
			return false;
		}
	}
}