using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Peak.Afflictions;
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: AssemblyCompany("AOEHealingFix")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("AOEHealingFix")]
[assembly: AssemblyTitle("AOEHealingFix")]
[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 AOEHealingFix
{
	[BepInPlugin("jill920.aoefix", "AOE Healing Fix", "1.0.0")]
	public class AOEHealingFixPlugin : BaseUnityPlugin
	{
		public const string MOD_GUID = "jill920.aoefix";

		public const string MOD_NAME = "AOE Healing Fix";

		public const string MOD_VERSION = "1.0.0";

		public static AOEHealingFixPlugin Instance;

		public static ManualLogSource Logger;

		private void Awake()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			Instance = this;
			Logger = ((BaseUnityPlugin)this).Logger;
			try
			{
				Harmony val = new Harmony("jill920.aoefix");
				val.PatchAll(Assembly.GetExecutingAssembly());
				Logger.LogInfo((object)"[AOE Healing Fix 1.0.0] Loaded successfully!");
				Logger.LogInfo((object)"  AOE healing now works on carried/downed players");
			}
			catch (Exception ex)
			{
				Logger.LogError((object)("Harmony patch failed: " + ex.Message));
			}
		}
	}
	[HarmonyPatch(typeof(AOE), "Explode")]
	internal static class AOE_Explode_Patch
	{
		[HarmonyPrefix]
		private static bool Prefix(AOE __instance)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0313: Unknown result type (might be due to invalid IL or missing references)
			//IL_031a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0326: Unknown result type (might be due to invalid IL or missing references)
			//IL_032b: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03dc: Expected I4, but got Unknown
			//IL_0406: Unknown result type (might be due to invalid IL or missing references)
			//IL_0429: Unknown result type (might be due to invalid IL or missing references)
			//IL_0430: Expected I4, but got Unknown
			//IL_0486: Unknown result type (might be due to invalid IL or missing references)
			//IL_0490: Expected I4, but got Unknown
			AOEHealingFixPlugin.Logger.LogInfo((object)("[AOE DEBUG] Explode() called on " + ((Object)__instance).name));
			AOEHealingFixPlugin.Logger.LogInfo((object)$"[AOE DEBUG]   statusAmount: {__instance.statusAmount}, statusType: {__instance.statusType}");
			AOEHealingFixPlugin.Logger.LogInfo((object)$"[AOE DEBUG]   range: {__instance.range}, hasAffliction: {__instance.hasAffliction}");
			if (!(__instance.statusAmount < 0f))
			{
				AOEHealingFixPlugin.Logger.LogInfo((object)"[AOE DEBUG] Not a healing AOE (statusAmount >= 0), letting original handle");
				return true;
			}
			AOEHealingFixPlugin.Logger.LogInfo((object)$"[AOE DEBUG] HEALING AOE DETECTED! statusAmount: {__instance.statusAmount}");
			float statusAmount = __instance.statusAmount;
			STATUSTYPE statusType = __instance.statusType;
			STATUSTYPE[] addtlStatus = __instance.addtlStatus;
			bool hasAffliction = __instance.hasAffliction;
			Affliction affliction = __instance.affliction;
			__instance.statusAmount = 0f;
			__instance.hasAffliction = false;
			__instance.affliction = null;
			__instance.Explode();
			__instance.statusAmount = statusAmount;
			__instance.hasAffliction = hasAffliction;
			__instance.affliction = affliction;
			if (!PhotonNetwork.IsMasterClient)
			{
				AOEHealingFixPlugin.Logger.LogInfo((object)"[AOE DEBUG] Skipping healing application - not MasterClient");
				return false;
			}
			AOEHealingFixPlugin.Logger.LogInfo((object)"[AOE DEBUG] MasterClient: Processing healing...");
			float num = Mathf.Abs(statusAmount);
			Collider[] array = Physics.OverlapSphere(((Component)__instance).transform.position, __instance.range, LayerMask.op_Implicit(HelperFunctions.GetMask(__instance.mask)));
			List<Character> list = new List<Character>();
			AOEHealingFixPlugin.Logger.LogInfo((object)$"[AOE DEBUG] Found {array.Length} colliders in range");
			Collider[] array2 = array;
			Character item = default(Character);
			Character val2 = default(Character);
			foreach (Collider val in array2)
			{
				if (CharacterRagdoll.TryGetCharacterFromCollider(val, ref item) && !list.Contains(item))
				{
					list.Add(item);
				}
				if (CharacterRagdoll.TryGetCharacterFromCollider(val, ref val2) && (Object)(object)val2.data.carriedPlayer != (Object)null && !list.Contains(val2.data.carriedPlayer))
				{
					list.Add(val2.data.carriedPlayer);
					AOEHealingFixPlugin.Logger.LogInfo((object)("[AOE DEBUG] Found carried player " + val2.data.carriedPlayer.characterName + " via carrier " + val2.characterName));
				}
			}
			foreach (Character item2 in list)
			{
				float num2 = Vector3.Distance(((Component)__instance).transform.position, item2.Center);
				if (num2 > __instance.range)
				{
					continue;
				}
				float num3 = Mathf.Pow(1f - num2 / __instance.range, __instance.factorPow);
				if (num3 < __instance.minFactor)
				{
					continue;
				}
				if (__instance.requireLineOfSigh)
				{
					RaycastHit val3 = HelperFunctions.LineCheck(((Component)__instance).transform.position, item2.Center, (LayerType)1, 0f, (QueryTriggerInteraction)1);
					if (Object.op_Implicit((Object)(object)((RaycastHit)(ref val3)).transform))
					{
						continue;
					}
				}
				float num4 = num * num3;
				AOEHealingFixPlugin.Logger.LogInfo((object)$"[AOE DEBUG] Healing {item2.characterName} for {num4:F4} (factor: {num3:F4}) | IsCarried: {item2.data.isCarried}");
				HealingReceiver component = ((Component)item2).GetComponent<HealingReceiver>();
				if ((Object)(object)component != (Object)null)
				{
					((MonoBehaviourPun)component).photonView.RPC("RPC_ApplyHealing", ((MonoBehaviourPun)component).photonView.Owner, new object[2]
					{
						(int)statusType,
						num4
					});
					if (addtlStatus != null)
					{
						STATUSTYPE[] array3 = addtlStatus;
						foreach (STATUSTYPE val4 in array3)
						{
							((MonoBehaviourPun)component).photonView.RPC("RPC_ApplyHealing", ((MonoBehaviourPun)component).photonView.Owner, new object[2]
							{
								(int)val4,
								num4
							});
						}
					}
					if (hasAffliction && affliction != null)
					{
						((MonoBehaviourPun)component).photonView.RPC("RPC_ApplyAffliction", ((MonoBehaviourPun)component).photonView.Owner, new object[1] { (int)affliction.GetAfflictionType() });
					}
				}
				else
				{
					AOEHealingFixPlugin.Logger.LogError((object)("[AOE DEBUG] No HealingReceiver on " + item2.characterName + "! Make sure Character_Awake_Patch is running."));
				}
			}
			AOEHealingFixPlugin.Logger.LogInfo((object)$"[AOE DEBUG] Healing applied to {list.Count} characters");
			return false;
		}
	}
	[HarmonyPatch(typeof(Character), "Awake")]
	internal static class Character_Awake_Patch
	{
		[HarmonyPostfix]
		private static void Postfix(Character __instance)
		{
			if ((Object)(object)((Component)__instance).GetComponent<HealingReceiver>() == (Object)null)
			{
				((Component)__instance).gameObject.AddComponent<HealingReceiver>();
				AOEHealingFixPlugin.Logger.LogInfo((object)("Added HealingReceiver to " + __instance.characterName));
			}
		}
	}
	public class HealingReceiver : MonoBehaviourPun
	{
		private Character character;

		private void Awake()
		{
			character = ((Component)this).GetComponent<Character>();
		}

		[PunRPC]
		public void RPC_ApplyHealing(int statusTypeInt, float amount)
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			if (!((MonoBehaviourPun)this).photonView.IsMine)
			{
				ManualLogSource logger = AOEHealingFixPlugin.Logger;
				Character obj = character;
				logger.LogInfo((object)("[HEAL] Skipped " + ((obj != null) ? obj.characterName : null) + " - not owner"));
			}
			else if (!((Object)(object)character == (Object)null) && !(amount <= 0f))
			{
				STATUSTYPE val = (STATUSTYPE)statusTypeInt;
				float currentStatus = character.refs.afflictions.GetCurrentStatus(val);
				character.refs.afflictions.SubtractStatus(val, amount, true, false);
				float currentStatus2 = character.refs.afflictions.GetCurrentStatus(val);
				AOEHealingFixPlugin.Logger.LogInfo((object)($"[HEAL] {character.characterName} healed: {val} " + $"{currentStatus:F3} → {currentStatus2:F3} (-{amount:F3}) | IsCarried: {character.data.isCarried} | " + "Carrier: " + (((Object)(object)character.data.carrier != (Object)null) ? character.data.carrier.characterName : "none")));
			}
		}

		[PunRPC]
		public void RPC_ApplyAffliction(int afflictionTypeInt)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			if (((MonoBehaviourPun)this).photonView.IsMine && !((Object)(object)character == (Object)null))
			{
				AfflictionType val = (AfflictionType)afflictionTypeInt;
				Affliction val2 = Affliction.CreateBlankAffliction(val);
				if (val2 != null)
				{
					character.refs.afflictions.AddAffliction(val2, true);
				}
			}
		}
	}
}

using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
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: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.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;
		}
	}
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}
namespace BetterFriendJump
{
	[HarmonyPatch(typeof(CharacterMovement), "JumpRpc")]
	public static class PatchJumpRpc
	{
		private const float FRIEND_JUMP_FORCE = 2050f;

		[HarmonyPostfix]
		private static void Postfix(CharacterMovement __instance, bool isPalJump)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			if (!isPalJump)
			{
				return;
			}
			Character component = ((Component)__instance).GetComponent<Character>();
			if ((Object)(object)component == (Object)null)
			{
				return;
			}
			foreach (Bodypart part in component.refs.ragdoll.partList)
			{
				part.AddForce(Vector3.up * 2050f, (ForceMode)5);
			}
		}
	}
	[BepInPlugin("jill920.BetterFriendJump", "BetterFriendJump", "1.0.1")]
	public class Plugin : BaseUnityPlugin
	{
		public const string MOD_GUID = "jill920.BetterFriendJump";

		public const string MOD_NAME = "BetterFriendJump";

		public const string MOD_VERSION = "1.0.1";

		public static ManualLogSource Log;

		private void Awake()
		{
			Log = ((BaseUnityPlugin)this).Logger;
			Harmony.CreateAndPatchAll(Assembly.GetExecutingAssembly(), "jill920.BetterFriendJump");
			Log.LogInfo((object)"[BetterFriendJump 1.0.1] Loaded! Friend jump force: 2000");
		}
	}
}

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
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: AssemblyCompany("BetterFriendPull")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+4d83d2fcd8cc02921a02fe7ced1336060af8c951")]
[assembly: AssemblyProduct("BetterFriendPull")]
[assembly: AssemblyTitle("BetterFriendPull")]
[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 BetterFriendPull
{
	[HarmonyPatch(typeof(CharacterGrabbing), "Reach")]
	public static class PatchReachRange
	{
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Expected O, but got Unknown
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count; i++)
			{
				if (list[i].opcode == OpCodes.Ldc_R4 && Mathf.Approximately((float)list[i].operand, 4f))
				{
					Debug.Log((object)$"[BetterFriendPull] Replacing 4f range with {Plugin.PullRange.Value}f");
					list[i] = new CodeInstruction(OpCodes.Ldc_R4, (object)Plugin.PullRange.Value);
				}
				if (list[i].opcode == OpCodes.Ldc_R4 && Mathf.Approximately((float)list[i].operand, 60f))
				{
					Debug.Log((object)$"[BetterFriendPull] Replacing 60f angle with {Plugin.PullAngle.Value}f");
					list[i] = new CodeInstruction(OpCodes.Ldc_R4, (object)Plugin.PullAngle.Value);
				}
			}
			return list;
		}
	}
	[HarmonyPatch(typeof(CharacterGrabbing), "TargetCanBeHelped")]
	public static class PatchVerticalLimit
	{
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count; i++)
			{
				if (!(list[i].opcode == OpCodes.Ldc_R4) || !Mathf.Approximately((float)list[i].operand, 1f))
				{
					continue;
				}
				bool flag = false;
				for (int j = Mathf.Max(0, i - 8); j < i; j++)
				{
					if (list[j].opcode == OpCodes.Callvirt && list[j].operand.ToString().Contains("get_isClimbing"))
					{
						flag = true;
						break;
					}
				}
				if (flag)
				{
					Debug.Log((object)$"[BetterFriendPull] Replacing vertical limit 1f with {Plugin.PullVerticalLimit.Value}f");
					list[i] = new CodeInstruction(OpCodes.Ldc_R4, (object)Plugin.PullVerticalLimit.Value);
				}
			}
			return list;
		}
	}
	[HarmonyPatch(typeof(Character), "DragTowards")]
	public static class PatchPullForce
	{
		[HarmonyPrefix]
		private static void Prefix(Character __instance, Vector3 target, ref float force)
		{
			if (!Mathf.Approximately(Plugin.PullForceMultiplier.Value, 1f))
			{
				force *= Plugin.PullForceMultiplier.Value;
				if (Plugin.PullForceMultiplier.Value != 1f)
				{
					Debug.Log((object)$"[BetterFriendPull] Pull force multiplied: {force / Plugin.PullForceMultiplier.Value:F0} → {force:F0}");
				}
			}
		}
	}
	public static class StaminaFreezeManager
	{
		private static HashSet<Character> _protectedChars = new HashSet<Character>();

		private static Dictionary<Character, float> _protectUntil = new Dictionary<Character, float>();

		public static void ProtectCharacter(Character c)
		{
			if (Plugin.EnableStaminaFreeze.Value)
			{
				_protectedChars.Add(c);
				_protectUntil[c] = Time.time + Plugin.StaminaFreezeCooldown.Value;
			}
		}

		public static bool IsProtected(Character c)
		{
			if (!Plugin.EnableStaminaFreeze.Value)
			{
				return false;
			}
			float time = Time.time;
			List<Character> list = new List<Character>();
			foreach (KeyValuePair<Character, float> item in _protectUntil)
			{
				if (time > item.Value)
				{
					list.Add(item.Key);
				}
			}
			foreach (Character item2 in list)
			{
				_protectedChars.Remove(item2);
				_protectUntil.Remove(item2);
			}
			return _protectedChars.Contains(c);
		}
	}
	[HarmonyPatch(typeof(Character), "DragTowards")]
	public static class PatchTrackPullSimple
	{
		[HarmonyPrefix]
		private static void Prefix(Character __instance)
		{
			StaminaFreezeManager.ProtectCharacter(__instance);
			if (((MonoBehaviourPun)__instance).photonView.IsMine && Plugin.EnableStaminaFreeze.Value)
			{
				Debug.Log((object)("[BetterFriendPull] Stamina frozen for " + __instance.characterName));
			}
		}
	}
	[HarmonyPatch(typeof(Character), "UseStamina")]
	public static class PatchBlockStamina
	{
		[HarmonyPrefix]
		private static bool Prefix(Character __instance)
		{
			if (StaminaFreezeManager.IsProtected(__instance))
			{
				return false;
			}
			return true;
		}
	}
	[BepInPlugin("jill920.BetterFriendPull", "BetterFriendPull", "1.0.1")]
	public class Plugin : BaseUnityPlugin
	{
		public static ManualLogSource Log;

		public static ConfigEntry<float> PullRange;

		public static ConfigEntry<float> PullAngle;

		public static ConfigEntry<float> PullVerticalLimit;

		public static ConfigEntry<float> PullForceMultiplier;

		public static ConfigEntry<bool> EnableStaminaFreeze;

		public static ConfigEntry<float> StaminaFreezeCooldown;

		public static HashSet<Character> PullProtectedCharacters = new HashSet<Character>();

		public static Dictionary<Character, float> PullProtectionEndTime = new Dictionary<Character, float>();

		private void Awake()
		{
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Expected O, but got Unknown
			Log = ((BaseUnityPlugin)this).Logger;
			PullRange = ((BaseUnityPlugin)this).Config.Bind<float>("Settings", "Pull Range", 6f, "Max distance to detect climbing friends (vanilla: 4)");
			PullAngle = ((BaseUnityPlugin)this).Config.Bind<float>("Settings", "Pull Angle", 60f, "Cone angle in degrees (vanilla: 60)");
			PullVerticalLimit = ((BaseUnityPlugin)this).Config.Bind<float>("Settings", "Vertical Pull Limit", 1f, "Max height difference to pull (vanilla: 1)");
			PullForceMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Settings", "Pull Force Multiplier", 1f, "Multiply pull force (vanilla: 1)");
			EnableStaminaFreeze = ((BaseUnityPlugin)this).Config.Bind<bool>("Stamina", "Enable Stamina Freeze", true, "Prevent stamina drain while being pulled");
			StaminaFreezeCooldown = ((BaseUnityPlugin)this).Config.Bind<float>("Stamina", "Stamina Freeze Cooldown", 0.8f, "Seconds after pull ends to keep stamina frozen (prevents instant drain)");
			Harmony val = new Harmony(((BaseUnityPlugin)this).Info.Metadata.GUID);
			val.PatchAll();
			Log.LogInfo((object)$"BetterFriendPull loaded. Range: {PullRange.Value}m, Stamina Freeze: {EnableStaminaFreeze.Value}, Cooldown: {StaminaFreezeCooldown.Value}s");
		}

		private void Update()
		{
			float time = Time.time;
			List<Character> list = new List<Character>();
			foreach (KeyValuePair<Character, float> item in PullProtectionEndTime)
			{
				if (time > item.Value)
				{
					list.Add(item.Key);
				}
			}
			foreach (Character item2 in list)
			{
				PullProtectedCharacters.Remove(item2);
				PullProtectionEndTime.Remove(item2);
				if ((Object)(object)item2 != (Object)null && ((MonoBehaviourPun)item2).photonView.IsMine)
				{
					Log.LogDebug((object)("Stamina freeze expired for " + item2.characterName));
				}
			}
			if (!Application.isFocused || (Object)(object)Character.localCharacter == (Object)null || (!Input.GetKey((KeyCode)306) && !Input.GetKey((KeyCode)305)))
			{
				return;
			}
			if (Input.GetKeyDown((KeyCode)273))
			{
				ConfigEntry<float> pullRange = PullRange;
				pullRange.Value += 0.5f;
				Log.LogInfo((object)$"↑ Pull Range increased to {PullRange.Value}m");
			}
			if (Input.GetKeyDown((KeyCode)274))
			{
				ConfigEntry<float> pullRange2 = PullRange;
				pullRange2.Value -= 0.5f;
				Log.LogInfo((object)$"↓ Pull Range decreased to {PullRange.Value}m");
			}
			if (Input.GetKeyDown((KeyCode)275))
			{
				ConfigEntry<float> pullAngle = PullAngle;
				pullAngle.Value += 5f;
				Log.LogInfo((object)$"→ Pull Angle increased to {PullAngle.Value}°");
			}
			if (Input.GetKeyDown((KeyCode)276))
			{
				ConfigEntry<float> pullAngle2 = PullAngle;
				pullAngle2.Value -= 5f;
				Log.LogInfo((object)$"← Pull Angle decreased to {PullAngle.Value}°");
			}
			if (Input.GetKeyDown((KeyCode)280))
			{
				ConfigEntry<float> pullVerticalLimit = PullVerticalLimit;
				pullVerticalLimit.Value += 0.5f;
				Log.LogInfo((object)$"PgUp Vertical Limit increased to {PullVerticalLimit.Value}m");
			}
			if (Input.GetKeyDown((KeyCode)281))
			{
				ConfigEntry<float> pullVerticalLimit2 = PullVerticalLimit;
				pullVerticalLimit2.Value -= 0.5f;
				Log.LogInfo((object)$"PgDn Vertical Limit decreased to {PullVerticalLimit.Value}m");
			}
			if (Input.GetKey((KeyCode)304) || Input.GetKey((KeyCode)303))
			{
				if (Input.GetKeyDown((KeyCode)273))
				{
					ConfigEntry<float> pullForceMultiplier = PullForceMultiplier;
					pullForceMultiplier.Value += 0.25f;
					Log.LogInfo((object)$"↑ Pull Force increased to {PullForceMultiplier.Value}x");
				}
				if (Input.GetKeyDown((KeyCode)274))
				{
					ConfigEntry<float> pullForceMultiplier2 = PullForceMultiplier;
					pullForceMultiplier2.Value -= 0.25f;
					Log.LogInfo((object)$"↓ Pull Force decreased to {PullForceMultiplier.Value}x");
				}
			}
			if (Input.GetKeyDown((KeyCode)115))
			{
				EnableStaminaFreeze.Value = !EnableStaminaFreeze.Value;
				Log.LogInfo((object)("Stamina Freeze: " + (EnableStaminaFreeze.Value ? "ENABLED" : "DISABLED")));
			}
		}
	}
}

using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
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: AssemblyCompany("BlowgunEnhanced")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+e2fc2576a986539ed321b56e932194c0a5465ff8")]
[assembly: AssemblyProduct("BlowgunEnhanced")]
[assembly: AssemblyTitle("BlowgunEnhanced")]
[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 BlowgunEnhanced
{
	[BepInPlugin("jill920.blowgunenhanced", "Blowgun Enhanced", "1.0.0")]
	public class BlowgunEnhancedPlugin : BaseUnityPlugin
	{
		public const string MOD_GUID = "jill920.blowgunenhanced";

		public const string MOD_NAME = "Blowgun Enhanced";

		public const string MOD_VERSION = "1.0.0";

		public static BlowgunEnhancedPlugin Instance;

		public static ManualLogSource Logger;

		public static bool IsDizzinessModInstalled;

		public static bool IsFatigueModInstalled;

		public static bool debugMode;

		private void Awake()
		{
			Instance = this;
			Logger = ((BaseUnityPlugin)this).Logger;
			debugMode = ((BaseUnityPlugin)this).Config.Bind<bool>("Debug", "EnableLogs", false, "Enable debug logging").Value;
			CheckForInstalledMods();
			try
			{
				Harmony.CreateAndPatchAll(Assembly.GetExecutingAssembly(), "jill920.blowgunenhanced");
				Logger.LogInfo((object)"[Blowgun Enhanced 1.0.0] Loaded successfully!");
				Logger.LogInfo((object)$"  Dizziness Mod detected (initial): {IsDizzinessModInstalled}");
				Logger.LogInfo((object)$"  Fatigue Mod detected (initial): {IsFatigueModInstalled}");
			}
			catch (Exception ex)
			{
				Logger.LogError((object)("Failed to load: " + ex.Message));
			}
		}

		private void CheckForInstalledMods()
		{
			IsDizzinessModInstalled = false;
			IsFatigueModInstalled = false;
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			foreach (Assembly assembly in assemblies)
			{
				try
				{
					if (assembly.GetType("DizzinessMod.DizzinessTracker") != null)
					{
						IsDizzinessModInstalled = true;
					}
					if (assembly.GetType("FatigueMod.FatigueTracker") != null)
					{
						IsFatigueModInstalled = true;
					}
				}
				catch
				{
				}
			}
		}
	}
}
namespace BlowgunEnhanced.Patches
{
	[HarmonyPatch(typeof(Action_RaycastDart), "RPC_DartImpact")]
	internal static class Action_RaycastDart_Patch
	{
		private static bool _fatigueCheckDone;

		private static bool _fatigueAvailable;

		private static bool _dizzinessCheckDone;

		private static bool _dizzinessAvailable;

		private static bool IsFatigueModPresent()
		{
			if (_fatigueCheckDone)
			{
				return _fatigueAvailable;
			}
			_fatigueCheckDone = true;
			if (BlowgunEnhancedPlugin.IsFatigueModInstalled)
			{
				_fatigueAvailable = true;
				return true;
			}
			try
			{
				Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
				foreach (Assembly assembly in assemblies)
				{
					if (assembly.GetType("FatigueMod.FatigueTracker") != null)
					{
						_fatigueAvailable = true;
						BlowgunEnhancedPlugin.IsFatigueModInstalled = true;
						BlowgunEnhancedPlugin.Logger.LogInfo((object)"Blowgun: Fatigue Mod detected at runtime!");
						return true;
					}
				}
			}
			catch
			{
			}
			return false;
		}

		private static bool IsDizzinessModPresent()
		{
			if (_dizzinessCheckDone)
			{
				return _dizzinessAvailable;
			}
			_dizzinessCheckDone = true;
			if (BlowgunEnhancedPlugin.IsDizzinessModInstalled)
			{
				_dizzinessAvailable = true;
				return true;
			}
			try
			{
				Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
				foreach (Assembly assembly in assemblies)
				{
					if (assembly.GetType("DizzinessMod.DizzinessTracker") != null)
					{
						_dizzinessAvailable = true;
						BlowgunEnhancedPlugin.IsDizzinessModInstalled = true;
						BlowgunEnhancedPlugin.Logger.LogInfo((object)"Blowgun: Dizziness Mod detected at runtime!");
						return true;
					}
				}
			}
			catch
			{
			}
			return false;
		}

		[HarmonyPostfix]
		private static void Postfix(int characterID, Vector3 origin, Vector3 endpoint)
		{
			if (characterID == -1)
			{
				return;
			}
			try
			{
				PhotonView photonView = PhotonNetwork.GetPhotonView(characterID);
				if ((Object)(object)photonView == (Object)null)
				{
					return;
				}
				Character component = ((Component)photonView).GetComponent<Character>();
				if ((Object)(object)component == (Object)null || !component.IsLocal)
				{
					return;
				}
				bool flag = IsDizzinessModPresent();
				bool flag2 = IsFatigueModPresent();
				if (flag || flag2)
				{
					if (flag)
					{
						ClearDizziness(component);
					}
					if (flag2)
					{
						ClearFatigue(component);
					}
					if (BlowgunEnhancedPlugin.debugMode)
					{
						BlowgunEnhancedPlugin.Logger.LogInfo((object)("Blowgun: Cleared Dizziness/Fatigue for " + component.characterName));
					}
				}
			}
			catch (Exception ex)
			{
				BlowgunEnhancedPlugin.Logger.LogWarning((object)("Failed to process blowgun hit: " + ex.Message));
			}
		}

		private static void ClearDizziness(Character character)
		{
			try
			{
				Component component = ((Component)character).GetComponent("DizzinessMod.DizzinessTracker");
				if ((Object)(object)component == (Object)null)
				{
					return;
				}
				FieldInfo field = ((object)component).GetType().GetField("dizzinessValue", BindingFlags.Instance | BindingFlags.Public);
				if (field == null)
				{
					return;
				}
				float num = (float)field.GetValue(component);
				if (num > 0.01f)
				{
					field.SetValue(component, 0f);
					if (BlowgunEnhancedPlugin.debugMode)
					{
						BlowgunEnhancedPlugin.Logger.LogInfo((object)$"Blowgun: Cleared Dizziness: {num:F3} → 0");
					}
				}
			}
			catch (Exception ex)
			{
				BlowgunEnhancedPlugin.Logger.LogWarning((object)("Failed to clear Dizziness: " + ex.Message));
			}
		}

		private static void ClearFatigue(Character character)
		{
			try
			{
				Component component = ((Component)character).GetComponent("FatigueMod.FatigueTracker");
				if ((Object)(object)component == (Object)null)
				{
					return;
				}
				FieldInfo field = ((object)component).GetType().GetField("fatigueValue", BindingFlags.Instance | BindingFlags.Public);
				if (!(field == null))
				{
					float num = (float)field.GetValue(component);
					field.SetValue(component, 0f);
					if (BlowgunEnhancedPlugin.debugMode && num > 0.01f)
					{
						BlowgunEnhancedPlugin.Logger.LogInfo((object)$"Blowgun: Cleared Fatigue: {num:F3} → 0");
					}
				}
			}
			catch (Exception ex)
			{
				BlowgunEnhancedPlugin.Logger.LogWarning((object)("Failed to clear Fatigue: " + ex.Message));
			}
		}
	}
}

using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Peak.Afflictions;
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: AssemblyCompany("CursedSkullEnhanced")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+0a4f7b16fa778ffc5cd0ca73c4eecf8a56cf834e")]
[assembly: AssemblyProduct("CursedSkullEnhanced")]
[assembly: AssemblyTitle("CursedSkullEnhanced")]
[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 CursedSkullEnhanced
{
	[BepInPlugin("jill920.cursedskullenhanced", "Cursed Skull Enhanced", "1.0.0")]
	public class CursedSkullEnhancedPlugin : BaseUnityPlugin
	{
		public const string MOD_GUID = "jill920.cursedskullenhanced";

		public const string MOD_NAME = "Cursed Skull Enhanced";

		public const string MOD_VERSION = "1.0.0";

		public static CursedSkullEnhancedPlugin Instance;

		public static ManualLogSource Logger;

		public static bool IsDizzinessModInstalled;

		public static bool IsFatigueModInstalled;

		public static bool debugMode;

		private void Awake()
		{
			Instance = this;
			Logger = ((BaseUnityPlugin)this).Logger;
			debugMode = ((BaseUnityPlugin)this).Config.Bind<bool>("Debug", "EnableLogs", false, "Enable debug logging").Value;
			Harmony.CreateAndPatchAll(Assembly.GetExecutingAssembly(), "jill920.cursedskullenhanced");
			CheckForInstalledMods();
			Logger.LogInfo((object)"[Cursed Skull Enhanced 1.0.0] Loaded successfully!");
			Logger.LogInfo((object)$"  Dizziness Mod detected: {IsDizzinessModInstalled}");
			Logger.LogInfo((object)$"  Fatigue Mod detected: {IsFatigueModInstalled}");
		}

		private void CheckForInstalledMods()
		{
			IsDizzinessModInstalled = false;
			IsFatigueModInstalled = false;
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			foreach (Assembly assembly in assemblies)
			{
				try
				{
					if (assembly.GetType("DizzinessMod.DizzinessTracker") != null)
					{
						IsDizzinessModInstalled = true;
					}
					if (assembly.GetType("FatigueMod.FatigueTracker") != null)
					{
						IsFatigueModInstalled = true;
					}
				}
				catch
				{
				}
			}
		}
	}
}
namespace CursedSkullEnhanced.Patches
{
	[HarmonyPatch(typeof(Action_ApplyMassAffliction), "TryAddAfflictionToLocalCharacter")]
	internal static class Action_ApplyMassAffliction_Patch
	{
		[HarmonyPostfix]
		private static void Postfix(Action_ApplyMassAffliction __instance)
		{
			Character localCharacter = Character.localCharacter;
			if (!((Object)(object)localCharacter == (Object)null) && ((Action_ApplyAffliction)__instance).affliction is Affliction_ClearAllStatus)
			{
				ClearDizzinessAndFatigue(localCharacter);
				if (CursedSkullEnhancedPlugin.debugMode)
				{
					CursedSkullEnhancedPlugin.Logger.LogInfo((object)("Cursed Skull: Cleared Dizziness/Fatigue for " + localCharacter.characterName));
				}
			}
		}

		private static void ClearDizzinessAndFatigue(Character character)
		{
			if (IsDizzinessModPresent())
			{
				ClearDizziness(character);
			}
			if (IsFatigueModPresent())
			{
				ClearFatigue(character);
			}
		}

		private static bool IsDizzinessModPresent()
		{
			if (CursedSkullEnhancedPlugin.IsDizzinessModInstalled)
			{
				return true;
			}
			try
			{
				Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
				foreach (Assembly assembly in assemblies)
				{
					if (assembly.GetType("DizzinessMod.DizzinessTracker") != null)
					{
						CursedSkullEnhancedPlugin.IsDizzinessModInstalled = true;
						return true;
					}
				}
			}
			catch
			{
			}
			return false;
		}

		private static bool IsFatigueModPresent()
		{
			if (CursedSkullEnhancedPlugin.IsFatigueModInstalled)
			{
				return true;
			}
			try
			{
				Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
				foreach (Assembly assembly in assemblies)
				{
					if (assembly.GetType("FatigueMod.FatigueTracker") != null)
					{
						CursedSkullEnhancedPlugin.IsFatigueModInstalled = true;
						return true;
					}
				}
			}
			catch
			{
			}
			return false;
		}

		private static void ClearDizziness(Character character)
		{
			try
			{
				Component component = ((Component)character).GetComponent("DizzinessMod.DizzinessTracker");
				if ((Object)(object)component == (Object)null)
				{
					return;
				}
				FieldInfo field = ((object)component).GetType().GetField("dizzinessValue", BindingFlags.Instance | BindingFlags.Public);
				if (field == null)
				{
					return;
				}
				float num = (float)field.GetValue(component);
				if (num > 0.01f)
				{
					field.SetValue(component, 0f);
					if (CursedSkullEnhancedPlugin.debugMode)
					{
						CursedSkullEnhancedPlugin.Logger.LogInfo((object)$"Cleared Dizziness: {num:F3} → 0");
					}
				}
			}
			catch (Exception ex)
			{
				CursedSkullEnhancedPlugin.Logger.LogWarning((object)("Failed to clear Dizziness: " + ex.Message));
			}
		}

		private static void ClearFatigue(Character character)
		{
			try
			{
				Component component = ((Component)character).GetComponent("FatigueMod.FatigueTracker");
				if ((Object)(object)component == (Object)null)
				{
					return;
				}
				FieldInfo field = ((object)component).GetType().GetField("fatigueValue", BindingFlags.Instance | BindingFlags.Public);
				if (!(field == null))
				{
					float num = (float)field.GetValue(component);
					field.SetValue(component, 0f);
					if (CursedSkullEnhancedPlugin.debugMode && num > 0.01f)
					{
						CursedSkullEnhancedPlugin.Logger.LogInfo((object)$"Cleared Fatigue: {num:F3} → 0");
					}
				}
			}
			catch (Exception ex)
			{
				CursedSkullEnhancedPlugin.Logger.LogWarning((object)("Failed to clear Fatigue: " + ex.Message));
			}
		}
	}
	[HarmonyPatch(typeof(ItemCooking), "RPC_CookingExplode")]
	internal static class ItemCooking_Explode_Patch
	{
		private const float CURSED_SKULL_RADIUS = 900f;

		private const int CURSED_SKULL_ITEM_ID = 25;

		[HarmonyPrefix]
		private static void Prefix(ItemCooking __instance)
		{
			//IL_0030: 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_005e: 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)
			Item item = ((ItemComponent)__instance).item;
			if ((Object)(object)item == (Object)null || item.itemID != 25)
			{
				return;
			}
			Vector3 position = ((Component)__instance).transform.position;
			foreach (Character allCharacter in Character.AllCharacters)
			{
				if (!((Object)(object)allCharacter == (Object)null))
				{
					float num = Vector3.Distance(position, allCharacter.Center);
					if (!(num > 900f))
					{
						ClearDizzinessAndFatigue(allCharacter);
					}
				}
			}
			CursedSkullEnhancedPlugin.Logger.LogInfo((object)$"Cursed Skull explosion: Cleared Dizziness/Fatigue for players within {900f} units");
		}

		private static void ClearDizzinessAndFatigue(Character character)
		{
			if (CursedSkullEnhancedPlugin.IsDizzinessModInstalled)
			{
				ClearDizziness(character);
			}
			if (CursedSkullEnhancedPlugin.IsFatigueModInstalled)
			{
				ClearFatigue(character);
			}
		}

		private static void ClearDizziness(Character character)
		{
			try
			{
				Component component = ((Component)character).GetComponent("DizzinessMod.DizzinessTracker");
				if ((Object)(object)component == (Object)null)
				{
					return;
				}
				FieldInfo field = ((object)component).GetType().GetField("dizzinessValue", BindingFlags.Instance | BindingFlags.Public);
				if (field == null)
				{
					return;
				}
				float num = (float)field.GetValue(component);
				if (num > 0.01f)
				{
					field.SetValue(component, 0f);
					if (CursedSkullEnhancedPlugin.debugMode)
					{
						CursedSkullEnhancedPlugin.Logger.LogInfo((object)$"Cleared Dizziness for {character.characterName}: {num:F3} → 0");
					}
				}
			}
			catch (Exception ex)
			{
				CursedSkullEnhancedPlugin.Logger.LogWarning((object)("Failed to clear Dizziness: " + ex.Message));
			}
		}

		private static bool IsFatigueModPresent()
		{
			if (CursedSkullEnhancedPlugin.IsFatigueModInstalled)
			{
				return true;
			}
			try
			{
				Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
				foreach (Assembly assembly in assemblies)
				{
					if (assembly.GetType("FatigueMod.FatigueTracker") != null)
					{
						CursedSkullEnhancedPlugin.IsFatigueModInstalled = true;
						return true;
					}
				}
			}
			catch
			{
			}
			return false;
		}

		private static void ClearFatigue(Character character)
		{
			if (!IsFatigueModPresent())
			{
				return;
			}
			try
			{
				Component component = ((Component)character).GetComponent("FatigueMod.FatigueTracker");
				if ((Object)(object)component == (Object)null)
				{
					return;
				}
				FieldInfo field = ((object)component).GetType().GetField("fatigueValue", BindingFlags.Instance | BindingFlags.Public);
				if (!(field == null))
				{
					field.SetValue(component, 0f);
					if (CursedSkullEnhancedPlugin.debugMode)
					{
						CursedSkullEnhancedPlugin.Logger.LogInfo((object)("Cleared Fatigue for " + character.characterName));
					}
				}
			}
			catch (Exception ex)
			{
				CursedSkullEnhancedPlugin.Logger.LogWarning((object)("Failed to clear Fatigue: " + ex.Message));
			}
		}
	}
}