using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using GameNetcodeStuff;
using HarmonyLib;
using Unity.Collections;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.Rendering;
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: AssemblyTitle("NoNaturalRegeneration")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("NoNaturalRegeneration")]
[assembly: AssemblyCopyright("Copyright ©  2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("c959da97-7d2d-475f-8238-c5777767c660")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace NoNaturalRegeneration;

public class CriticalInjuryTrigger : MonoBehaviour
{
	[CompilerGenerated]
	private sealed class <SetupTriggerDelayed>d__5 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public CriticalInjuryTrigger <>4__this;

		private BoxCollider <col>5__1;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <SetupTriggerDelayed>d__5(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<col>5__1 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Expected O, but got Unknown
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0203: Expected O, but got Unknown
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Expected O, but got Unknown
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_022d: Expected O, but got Unknown
			//IL_0238: Unknown result type (might be due to invalid IL or missing references)
			//IL_0242: Expected O, but got Unknown
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>2__current = null;
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				<>4__this.triggerObject = new GameObject("HealTrigger_" + <>4__this.playerController.playerUsername);
				<>4__this.triggerObject.layer = 9;
				<>4__this.triggerObject.tag = "InteractTrigger";
				<col>5__1 = <>4__this.triggerObject.AddComponent<BoxCollider>();
				((Collider)<col>5__1).isTrigger = true;
				<col>5__1.size = new Vector3(1f, 1.5f, 1f);
				<>4__this.interactTrigger = <>4__this.triggerObject.AddComponent<InteractTrigger>();
				<>4__this.interactTrigger.hoverTip = "Heal : [LMB]";
				<>4__this.interactTrigger.disabledHoverTip = "Cannot heal";
				<>4__this.interactTrigger.holdTip = "Stabilizing...";
				<>4__this.interactTrigger.interactable = false;
				<>4__this.interactTrigger.oneHandedItemAllowed = true;
				<>4__this.interactTrigger.twoHandedItemAllowed = false;
				<>4__this.interactTrigger.holdInteraction = true;
				<>4__this.interactTrigger.timeToHold = 5f;
				<>4__this.interactTrigger.interactCooldown = true;
				<>4__this.interactTrigger.cooldownTime = 0.5f;
				<>4__this.interactTrigger.disableTriggerMesh = true;
				<>4__this.interactTrigger.triggerOnce = false;
				<>4__this.interactTrigger.touchTrigger = false;
				<>4__this.interactTrigger.onInteract = new InteractEvent();
				<>4__this.interactTrigger.onInteractEarly = new InteractEvent();
				<>4__this.interactTrigger.onStopInteract = new InteractEvent();
				<>4__this.interactTrigger.onCancelAnimation = new InteractEvent();
				<>4__this.interactTrigger.holdingInteractEvent = new InteractEventFloat();
				<>4__this.interactTrigger.onInteractEarlyOtherClients = new InteractEvent();
				((UnityEvent<PlayerControllerB>)(object)<>4__this.interactTrigger.onInteract).AddListener((UnityAction<PlayerControllerB>)delegate
				{
					<>4__this.OnInteractTriggered();
				});
				<>4__this.triggerObject.SetActive(false);
				return false;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	private PlayerControllerB playerController;

	private InteractTrigger interactTrigger;

	private GameObject triggerObject;

	private const int CRITICAL_HEALTH_THRESHOLD = 20;

	private void Start()
	{
		playerController = ((Component)this).GetComponent<PlayerControllerB>();
		((MonoBehaviour)this).StartCoroutine(SetupTriggerDelayed());
	}

	[IteratorStateMachine(typeof(<SetupTriggerDelayed>d__5))]
	private IEnumerator SetupTriggerDelayed()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <SetupTriggerDelayed>d__5(0)
		{
			<>4__this = this
		};
	}

	private void Update()
	{
		//IL_003d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0051: Unknown result type (might be due to invalid IL or missing references)
		//IL_0056: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)playerController == (Object)null) && !((Object)(object)triggerObject == (Object)null))
		{
			triggerObject.transform.position = ((Component)playerController).transform.position + new Vector3(0f, 1.7f, 0f);
			bool flag = playerController.health < 20 && playerController.health > 0 && !((NetworkBehaviour)playerController).IsOwner && !playerController.isPlayerDead;
			if (interactTrigger.interactable != flag)
			{
				interactTrigger.interactable = flag;
				triggerObject.SetActive(flag);
			}
		}
	}

	private void OnDestroy()
	{
		if ((Object)(object)triggerObject != (Object)null)
		{
			Object.Destroy((Object)(object)triggerObject);
		}
	}

	public void OnInteractTriggered()
	{
		HealNetworkHandler.SendHealRequest(playerController.playerClientId);
	}
}
public static class HealNetworkHandler
{
	public static void SendHealRequest(ulong targetClientId)
	{
		//IL_0025: Unknown result type (might be due to invalid IL or missing references)
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		if (!NetworkManager.Singleton.IsClient)
		{
			return;
		}
		FastBufferWriter val = default(FastBufferWriter);
		((FastBufferWriter)(ref val))..ctor(8, (Allocator)2, -1);
		try
		{
			((FastBufferWriter)(ref val)).WriteValueSafe<ulong>(ref targetClientId, default(ForPrimitives));
			NetworkManager.Singleton.CustomMessagingManager.SendNamedMessage("NoNatRegen_Heal", 0uL, val, (NetworkDelivery)3);
		}
		finally
		{
			((IDisposable)(FastBufferWriter)(ref val)).Dispose();
		}
	}

	public static void ReceiveHealRequestOnServer(ulong senderClientId, FastBufferReader reader)
	{
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
		if (!NetworkManager.Singleton.IsServer && !NetworkManager.Singleton.IsHost)
		{
			return;
		}
		ulong num = default(ulong);
		((FastBufferReader)(ref reader)).ReadValueSafe<ulong>(ref num, default(ForPrimitives));
		PlayerControllerB val = null;
		PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
		foreach (PlayerControllerB val2 in allPlayerScripts)
		{
			if (val2.playerClientId == num)
			{
				val = val2;
				break;
			}
		}
		if ((Object)(object)val == (Object)null)
		{
			return;
		}
		FastBufferWriter val3 = default(FastBufferWriter);
		((FastBufferWriter)(ref val3))..ctor(0, (Allocator)2, -1);
		try
		{
			NetworkManager.Singleton.CustomMessagingManager.SendNamedMessage("NoNatRegen_SelfHeal", val.actualClientId, val3, (NetworkDelivery)3);
		}
		finally
		{
			((IDisposable)(FastBufferWriter)(ref val3)).Dispose();
		}
	}

	public static void ReceiveSelfHealCommand(ulong senderClientId, FastBufferReader reader)
	{
		PlayerControllerB localPlayerController = GameNetworkManager.Instance.localPlayerController;
		if (!((Object)(object)localPlayerController == (Object)null) && ((NetworkBehaviour)localPlayerController).IsOwner)
		{
			localPlayerController.health = 20;
			localPlayerController.criticallyInjured = false;
			localPlayerController.bleedingHeavily = false;
			if ((Object)(object)localPlayerController.playerBodyAnimator != (Object)null)
			{
				localPlayerController.playerBodyAnimator.SetBool("Limp", false);
			}
			localPlayerController.MakeCriticallyInjured(false);
			if ((Object)(object)HUDManager.Instance != (Object)null)
			{
				HUDManager.Instance.UpdateHealthUI(localPlayerController.health, false);
				HUDManager.Instance.gasHelmetAnimator.SetBool("gasLeaking", false);
			}
		}
	}
}
public class LowHpEffect : MonoBehaviour
{
	private PlayerControllerB playerController;

	private Volume localVolume;

	private VolumeProfile localProfile;

	private ColorAdjustments colorAdjustments;

	private const int LOW_HEALTH_THRESHOLD = 5;

	private void Start()
	{
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		//IL_0018: Expected O, but got Unknown
		playerController = ((Component)this).GetComponent<PlayerControllerB>();
		GameObject val = new GameObject("LowHpGrayScaleVolume");
		val.transform.SetParent(((Component)this).transform);
		localVolume = val.AddComponent<Volume>();
		localVolume.isGlobal = true;
		localVolume.priority = 1000f;
		localVolume.weight = 0f;
		localProfile = ScriptableObject.CreateInstance<VolumeProfile>();
		localVolume.profile = localProfile;
		if (!localProfile.TryGet<ColorAdjustments>(ref colorAdjustments))
		{
			colorAdjustments = localProfile.Add<ColorAdjustments>(true);
		}
		((VolumeParameter)colorAdjustments.saturation).overrideState = true;
		((VolumeParameter<float>)(object)colorAdjustments.saturation).value = -100f;
	}

	private void Update()
	{
		if (!((Object)(object)playerController == (Object)null) && !((Object)(object)localVolume == (Object)null))
		{
			if (!((NetworkBehaviour)playerController).IsOwner || playerController.isPlayerDead || ((Object)(object)GameNetworkManager.Instance.localPlayerController != (Object)null && (Object)(object)playerController != (Object)(object)GameNetworkManager.Instance.localPlayerController))
			{
				localVolume.weight = 0f;
			}
			else if (playerController.health <= 5 && playerController.health > 0)
			{
				localVolume.weight = Mathf.Lerp(localVolume.weight, 1f, Time.deltaTime * 5f);
			}
			else
			{
				localVolume.weight = Mathf.Lerp(localVolume.weight, 0f, Time.deltaTime * 5f);
			}
		}
	}

	private void OnDestroy()
	{
		if ((Object)(object)localVolume != (Object)null)
		{
			Object.Destroy((Object)(object)((Component)localVolume).gameObject);
		}
		if ((Object)(object)localProfile != (Object)null)
		{
			Object.Destroy((Object)(object)localProfile);
		}
	}
}
[HarmonyPatch(typeof(PlayerControllerB))]
internal class LowHpEffectPatch
{
	[HarmonyPatch("Start")]
	[HarmonyPostfix]
	private static void AddLowHpEffect(PlayerControllerB __instance)
	{
		if ((Object)(object)((Component)__instance).gameObject.GetComponent<LowHpEffect>() == (Object)null)
		{
			((Component)__instance).gameObject.AddComponent<LowHpEffect>();
		}
	}
}
[BepInPlugin("NoNaturalRegeneration", "No Natural Regeneration", "1.1.1")]
public class Plugin : BaseUnityPlugin
{
	private void Awake()
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Expected O, but got Unknown
		Harmony val = new Harmony("NoNaturalRegeneration");
		val.PatchAll();
		((BaseUnityPlugin)this).Logger.LogInfo((object)"No Natural Regeneration is loaded!");
	}
}
[HarmonyPatch(typeof(PlayerControllerB))]
internal class PlayerControllerPatch
{
	[HarmonyPatch("Start")]
	[HarmonyPostfix]
	private static void AddHealTrigger(PlayerControllerB __instance)
	{
		if ((Object)(object)((Component)__instance).gameObject.GetComponent<CriticalInjuryTrigger>() == (Object)null)
		{
			((Component)__instance).gameObject.AddComponent<CriticalInjuryTrigger>();
		}
	}
}
[HarmonyPatch(typeof(StartOfRound))]
internal class NetworkMessagePatch
{
	[HarmonyPatch("Start")]
	[HarmonyPostfix]
	private static void RegisterMessages()
	{
		//IL_0039: Unknown result type (might be due to invalid IL or missing references)
		//IL_0043: Expected O, but got Unknown
		//IL_005a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0064: Expected O, but got Unknown
		if ((Object)(object)NetworkManager.Singleton != (Object)null && NetworkManager.Singleton.CustomMessagingManager != null)
		{
			NetworkManager.Singleton.CustomMessagingManager.RegisterNamedMessageHandler("NoNatRegen_Heal", new HandleNamedMessageDelegate(HealNetworkHandler.ReceiveHealRequestOnServer));
			NetworkManager.Singleton.CustomMessagingManager.RegisterNamedMessageHandler("NoNatRegen_SelfHeal", new HandleNamedMessageDelegate(HealNetworkHandler.ReceiveSelfHealCommand));
		}
	}
}
[HarmonyPatch(typeof(PlayerControllerB))]
public class LowHpDeathTimer
{
	private class TimerData
	{
		public float deathTimer = -1f;
	}

	private static readonly ConditionalWeakTable<PlayerControllerB, TimerData> timers = new ConditionalWeakTable<PlayerControllerB, TimerData>();

	[HarmonyPatch("Update")]
	[HarmonyPostfix]
	private static void CheckLowHpTimer(PlayerControllerB __instance)
	{
		//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
		if (!((NetworkBehaviour)__instance).IsOwner || __instance.isPlayerDead)
		{
			return;
		}
		timers.TryGetValue(__instance, out var value);
		if (value == null)
		{
			value = new TimerData();
			timers.Add(__instance, value);
		}
		if (__instance.health <= 5 && __instance.health > 0)
		{
			if (value.deathTimer < 0f)
			{
				value.deathTimer = 60f;
				ShowWarningNotification();
			}
			if (value.deathTimer > 0f)
			{
				value.deathTimer -= Time.deltaTime;
				if (value.deathTimer <= 0f)
				{
					__instance.DamagePlayer(5, true, true, (CauseOfDeath)0, 0, false, default(Vector3));
					value.deathTimer = -1f;
				}
			}
		}
		else
		{
			value.deathTimer = -1f;
		}
	}

	private static void ShowWarningNotification()
	{
		if ((Object)(object)HUDManager.Instance != (Object)null)
		{
			HUDManager.Instance.DisplayTip("WARNING!", "Your injury is fatal. Seek immediate medical attention or perish.", true, false, "warning");
		}
	}
}
[HarmonyPatch(typeof(PlayerControllerB))]
public class TimerManipulator
{
	[HarmonyPatch("Update")]
	[HarmonyPostfix]
	private static void ManipulateRegenTimer(PlayerControllerB __instance)
	{
		if (((NetworkBehaviour)__instance).IsOwner && !__instance.isPlayerDead && __instance.health < 20 && __instance.health > 0 && __instance.healthRegenerateTimer <= 1f)
		{
			__instance.healthRegenerateTimer = 1.1f;
		}
	}
}