using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
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 GameNetcodeStuff;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Unity.Netcode;
using UnityEngine;
using Zaprillator.Behaviors;
using Zaprillator.NetcodePatcher;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Sehelitar")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Sehelitar @ https://sehelitar.tv")]
[assembly: AssemblyDescription("Use your zapgun to turn your dead friend into a living one.")]
[assembly: AssemblyFileVersion("1.0.2")]
[assembly: AssemblyInformationalVersion("1.0.2+e958c1c767064a91860a7580fd36430376fb9681")]
[assembly: AssemblyProduct("Zaprillator")]
[assembly: AssemblyTitle("Zaprillator")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.2.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: NetcodePatchedAssembly]
internal class <Module>
{
	static <Module>()
	{
	}
}
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 Zaprillator
{
	[BepInPlugin("Zaprillator", "Zaprillator", "1.0.2")]
	[BepInProcess("Lethal Company.exe")]
	public class Plugin : BaseUnityPlugin
	{
		private static Harmony _globalHarmony;

		private static ManualLogSource Log { get; set; }

		internal static PluginConfigStruct GameConfig { get; private set; }

		private void Awake()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			Log = ((BaseUnityPlugin)this).Logger;
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Plugin Zaprillator is loaded! ;)");
			PatchNetwork();
			_globalHarmony = new Harmony("Zaprillator");
			_globalHarmony.PatchAll();
			PluginConfigStruct gameConfig = default(PluginConfigStruct);
			gameConfig.RequiresFullCharge = ((BaseUnityPlugin)this).Config.Bind<bool>("Revive", "RequiresFullCharge", false, "A full charge is required to revive a player.");
			gameConfig.RelativeHealth = ((BaseUnityPlugin)this).Config.Bind<bool>("Revive", "RelativeHealth", true, "Define if restored health is relative to the gun's charge.");
			GameConfig = gameConfig;
		}

		private static void PatchNetwork()
		{
			try
			{
				Type[] types = Assembly.GetExecutingAssembly().GetTypes();
				foreach (Type type in types)
				{
					MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);
					foreach (MethodInfo methodInfo in methods)
					{
						if (methodInfo.GetCustomAttributes(typeof(RuntimeInitializeOnLoadMethodAttribute), inherit: false).Length != 0)
						{
							Log.LogInfo((object)("Initialize network patch for " + type.FullName));
							methodInfo.Invoke(null, null);
						}
					}
				}
			}
			catch (Exception)
			{
			}
		}
	}
	internal struct PluginConfigStruct
	{
		public ConfigEntry<bool> RequiresFullCharge;

		public ConfigEntry<bool> RelativeHealth;
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "Zaprillator";

		public const string PLUGIN_NAME = "Zaprillator";

		public const string PLUGIN_VERSION = "1.0.2";
	}
}
namespace Zaprillator.Patches
{
	[HarmonyPatch(typeof(PatcherTool))]
	internal class PatcherToolPatch
	{
		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> ScanGunTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.FirstMethod(typeof(GameObject), (Func<MethodInfo, bool>)((MethodInfo m) => m.Name == "TryGetComponent" && m.GetParameters().Length == 1)).MakeGenericMethod(typeof(IShockableWithGun)), (string)null)
			}).ThrowIfInvalid("Call to GameObject.TryGetComponent not found!").Set(OpCodes.Call, (object)AccessTools.Method(typeof(PatcherToolPatch), "TryGetShockableWithGun", (Type[])null, (Type[])null))
				.ThrowIfInvalid("Could not patch PatcherTool.ScanGun!")
				.InstructionEnumeration();
		}

		private static bool TryGetShockableWithGun(GameObject obj, out Component component)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			component = (Component)obj.GetComponentInChildren<IShockableWithGun>();
			return (Object)(object)component != (Object)null;
		}

		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		public static void Start(ref PatcherTool __instance)
		{
			PatcherTool obj = __instance;
			obj.anomalyMask |= 0x100000;
		}
	}
	[HarmonyPatch(typeof(StartOfRound))]
	public class StartOfRoundPatch
	{
		[HarmonyPatch("Awake")]
		[HarmonyPostfix]
		private static void Awake()
		{
			GameObject val = (from o in Resources.FindObjectsOfTypeAll<GameObject>()
				where ((Object)o).name == "RagdollGrabbableObject"
				select o).FirstOrDefault();
			if (((val != null) ? val.gameObject.GetComponent<RevivablePlayer>() : null) == null && val != null)
			{
				val.gameObject.AddComponent<RevivablePlayer>();
			}
		}
	}
}
namespace Zaprillator.Behaviors
{
	[RequireComponent(typeof(RagdollGrabbableObject))]
	internal class RevivablePlayer : NetworkBehaviour, IShockableWithGun
	{
		private RagdollGrabbableObject _ragdoll;

		private bool _bodyShocked;

		private GrabbableObject _shockedBy;

		private float _batteryLevel;

		private void Start()
		{
			_ragdoll = ((Component)this).gameObject.GetComponent<RagdollGrabbableObject>();
		}

		bool IShockableWithGun.CanBeShocked()
		{
			return (Object)(object)_ragdoll != (Object)null;
		}

		float IShockableWithGun.GetDifficultyMultiplier()
		{
			return 0.1f;
		}

		NetworkObject IShockableWithGun.GetNetworkObject()
		{
			return ((NetworkBehaviour)this).NetworkObject;
		}

		Vector3 IShockableWithGun.GetShockablePosition()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return ((Component)this).transform.position;
		}

		Transform IShockableWithGun.GetShockableTransform()
		{
			return ((Component)this).transform;
		}

		void IShockableWithGun.ShockWithGun(PlayerControllerB shockedByPlayer)
		{
			_bodyShocked = true;
			RoundManager.Instance.FlickerLights(false, false);
			if (((NetworkBehaviour)shockedByPlayer).IsOwner)
			{
				_shockedBy = shockedByPlayer.currentlyHeldObjectServer;
				if (_shockedBy is PatcherTool)
				{
					_batteryLevel = _shockedBy.insertedBattery.charge;
					((MonoBehaviour)this).StartCoroutine(AutoStopShocking());
				}
			}
		}

		private IEnumerator AutoStopShocking()
		{
			yield return (object)new WaitForSeconds(1f);
			PatcherTool val = (PatcherTool)_shockedBy;
			if ((int)val != 0)
			{
				val.StopShockingAnomalyOnClient(false);
			}
		}

		void IShockableWithGun.StopShockingWithGun()
		{
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			if (_bodyShocked)
			{
				_bodyShocked = false;
				RoundManager.Instance.FlickerLights(false, false);
				if (!((Object)(object)_shockedBy == (Object)null))
				{
					int health = Mathf.RoundToInt(_batteryLevel * 100f);
					_shockedBy.UseUpBatteries();
					_shockedBy.SyncBatteryServerRpc(0);
					_shockedBy = null;
					RevivePlayerAtServerRpc(_ragdoll.ragdoll.playerScript.actualClientId, ((Component)_ragdoll.ragdoll).transform.position, health);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		private void RevivePlayerAtServerRpc(ulong clientId, Vector3 position, int health)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: 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_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(2354502692u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, clientId);
				((FastBufferWriter)(ref val2)).WriteValueSafe(ref position);
				BytePacker.WriteValueBitPacked(val2, health);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 2354502692u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost) && (!Plugin.GameConfig.RequiresFullCharge.Value || health >= 100))
			{
				if (!Plugin.GameConfig.RelativeHealth.Value)
				{
					health = 100;
				}
				RevivePlayerAtClientRpc(clientId, position, health);
			}
		}

		[ClientRpc]
		private void RevivePlayerAtClientRpc(ulong clientId, Vector3 position, int health)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: 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_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1265580350u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, clientId);
				((FastBufferWriter)(ref val2)).WriteValueSafe(ref position);
				BytePacker.WriteValueBitPacked(val2, health);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1265580350u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost))
			{
				ulong clientId2 = clientId;
				PlayerControllerB val3 = StartOfRound.Instance.allPlayerScripts.Where((PlayerControllerB playerScript) => playerScript.actualClientId == clientId2).FirstOrDefault();
				if ((Object)(object)val3 != (Object)null)
				{
					((MonoBehaviour)StartOfRound.Instance).StartCoroutine(RevivePlayerCoroutine(val3, position + new Vector3(0f, 0.5f, 0f), health));
				}
			}
		}

		private static IEnumerator RevivePlayerCoroutine(PlayerControllerB targetPlayer, Vector3? reviveAt = null, int health = 100)
		{
			if (!targetPlayer.isPlayerDead)
			{
				yield break;
			}
			int num = Array.IndexOf(StartOfRound.Instance.allPlayerScripts, targetPlayer);
			PlayerControllerB localPlayerController = GameNetworkManager.Instance.localPlayerController;
			bool flag = (Object)(object)targetPlayer == (Object)(object)localPlayerController;
			targetPlayer.ResetPlayerBloodObjects(targetPlayer.isPlayerDead);
			targetPlayer.isClimbingLadder = false;
			targetPlayer.ResetZAndXRotation();
			((Collider)targetPlayer.thisController).enabled = true;
			targetPlayer.health = health;
			targetPlayer.disableLookInput = false;
			targetPlayer.isPlayerDead = false;
			targetPlayer.isPlayerControlled = true;
			targetPlayer.isInElevator = true;
			targetPlayer.isInHangarShipRoom = true;
			targetPlayer.isInsideFactory = false;
			if (flag)
			{
				StartOfRound.Instance.SetPlayerObjectExtrapolate(false);
			}
			targetPlayer.TeleportPlayer((Vector3)(((??)reviveAt) ?? StartOfRound.Instance.GetPlayerSpawnPosition(num, false)), false, 0f, false, true);
			targetPlayer.setPositionOfDeadPlayer = false;
			targetPlayer.DisablePlayerModel(StartOfRound.Instance.allPlayerObjects[num], true, true);
			((Behaviour)targetPlayer.helmetLight).enabled = false;
			targetPlayer.Crouch(false);
			targetPlayer.criticallyInjured = false;
			Animator playerBodyAnimator = targetPlayer.playerBodyAnimator;
			if (playerBodyAnimator != null)
			{
				playerBodyAnimator.SetBool("Limp", false);
			}
			targetPlayer.bleedingHeavily = false;
			targetPlayer.activatingItem = false;
			targetPlayer.twoHanded = false;
			targetPlayer.inSpecialInteractAnimation = false;
			targetPlayer.disableSyncInAnimation = false;
			targetPlayer.inAnimationWithEnemy = null;
			targetPlayer.holdingWalkieTalkie = false;
			targetPlayer.speakingToWalkieTalkie = false;
			targetPlayer.isSinking = false;
			targetPlayer.isUnderwater = false;
			targetPlayer.sinkingValue = 0f;
			targetPlayer.statusEffectAudio.Stop();
			targetPlayer.DisableJetpackControlsLocally();
			targetPlayer.health = health;
			targetPlayer.mapRadarDotAnimator.SetBool("dead", false);
			if (((NetworkBehaviour)targetPlayer).IsOwner && flag)
			{
				HUDManager.Instance.gasHelmetAnimator.SetBool("gasEmitting", false);
				targetPlayer.hasBegunSpectating = false;
				HUDManager.Instance.RemoveSpectateUI();
				HUDManager.Instance.gameOverAnimator.SetTrigger("revive");
				targetPlayer.hinderedMultiplier = 1f;
				targetPlayer.isMovementHindered = 0;
				targetPlayer.sourcesCausingSinking = 0;
				targetPlayer.reverbPreset = StartOfRound.Instance.shipReverb;
			}
			if (flag)
			{
				SoundManager.Instance.earsRingingTimer = 0f;
			}
			targetPlayer.voiceMuffledByEnemy = false;
			SoundManager.Instance.playerVoicePitchTargets[num] = 1f;
			SoundManager.Instance.SetPlayerPitch(1f, num);
			if ((Object)(object)targetPlayer.currentVoiceChatIngameSettings == (Object)null)
			{
				StartOfRound.Instance.RefreshPlayerVoicePlaybackObjects();
			}
			if ((Object)(object)targetPlayer.currentVoiceChatIngameSettings != (Object)null)
			{
				if ((Object)(object)targetPlayer.currentVoiceChatIngameSettings.voiceAudio == (Object)null)
				{
					targetPlayer.currentVoiceChatIngameSettings.InitializeComponents();
				}
				if ((Object)(object)targetPlayer.currentVoiceChatIngameSettings.voiceAudio == (Object)null)
				{
					yield break;
				}
				((Component)targetPlayer.currentVoiceChatIngameSettings.voiceAudio).GetComponent<OccludeAudio>().overridingLowPass = false;
			}
			if (flag)
			{
				HUDManager.Instance.UpdateHealthUI(100, false);
				localPlayerController.spectatedPlayerScript = null;
				((Behaviour)HUDManager.Instance.audioListenerLowPass).enabled = false;
				StartOfRound.Instance.SetSpectateCameraToGameOverMode(false, localPlayerController);
			}
			RagdollGrabbableObject[] array = Object.FindObjectsOfType<RagdollGrabbableObject>();
			for (int i = 0; i < array.Length; i++)
			{
				if ((Object)(object)array[i].ragdoll.playerScript == (Object)(object)targetPlayer && ((GrabbableObject)array[i]).isHeld && (Object)(object)((GrabbableObject)array[i]).playerHeldBy != (Object)null)
				{
					((GrabbableObject)array[i]).playerHeldBy.DropAllHeldItems(true, false);
				}
			}
			DeadBodyInfo[] array2 = Object.FindObjectsOfType<DeadBodyInfo>();
			foreach (DeadBodyInfo val in array2)
			{
				if ((Object)(object)val.playerScript == (Object)(object)targetPlayer)
				{
					Object.Destroy((Object)(object)((Component)val).gameObject);
				}
			}
			StartOfRound instance = StartOfRound.Instance;
			instance.livingPlayers++;
			StartOfRound.Instance.UpdatePlayerVoiceEffects();
			if (flag)
			{
				yield return (object)new WaitForSeconds(2f);
				HUDManager.Instance.HideHUD(false);
			}
		}

		protected override void __initializeVariables()
		{
			((NetworkBehaviour)this).__initializeVariables();
		}

		[RuntimeInitializeOnLoadMethod]
		internal static void InitializeRPCS_RevivablePlayer()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			NetworkManager.__rpc_func_table.Add(2354502692u, new RpcReceiveHandler(__rpc_handler_2354502692));
			NetworkManager.__rpc_func_table.Add(1265580350u, new RpcReceiveHandler(__rpc_handler_1265580350));
		}

		private static void __rpc_handler_2354502692(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong clientId = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref clientId);
				Vector3 position = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref position);
				int health = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref health);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((RevivablePlayer)(object)target).RevivePlayerAtServerRpc(clientId, position, health);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1265580350(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong clientId = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref clientId);
				Vector3 position = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref position);
				int health = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref health);
				target.__rpc_exec_stage = (__RpcExecStage)2;
				((RevivablePlayer)(object)target).RevivePlayerAtClientRpc(clientId, position, health);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		protected internal override string __getTypeName()
		{
			return "RevivablePlayer";
		}
	}
}
namespace Zaprillator.NetcodePatcher
{
	[AttributeUsage(AttributeTargets.Module)]
	internal class NetcodePatchedAssemblyAttribute : Attribute
	{
	}
}