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.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Unity.Collections;
using Unity.Netcode;
using UnityEngine;

[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("BrokenLegMod")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("Lethal Company Mod: Beinbruch bei schwerem Fallschaden. Spieler muss kriechen, andere koennen ihn tragen.")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("BrokenLegMod")]
[assembly: AssemblyTitle("BrokenLegMod")]
[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 BrokenLegMod
{
	internal static class BrokenLegNetwork
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static HandleNamedMessageDelegate <0>__OnBreakReceived;

			public static HandleNamedMessageDelegate <1>__OnCarryReceived;

			public static HandleNamedMessageDelegate <2>__OnDropReceived;

			public static HandleNamedMessageDelegate <3>__OnCleanReceived;

			public static HandleNamedMessageDelegate <4>__OnReqBreakReceived;

			public static HandleNamedMessageDelegate <5>__OnReqCarryReceived;

			public static HandleNamedMessageDelegate <6>__OnReqDropReceived;
		}

		private const string MSG_BREAK = "BL_Break";

		private const string MSG_CARRY = "BL_Carry";

		private const string MSG_DROP = "BL_Drop";

		private const string MSG_CLEAN = "BL_Clean";

		private const string MSG_REQ_BREAK = "BL_ReqBreak";

		private const string MSG_REQ_CARRY = "BL_ReqCarry";

		private const string MSG_REQ_DROP = "BL_ReqDrop";

		private static bool _registered;

		internal static bool IsHost
		{
			get
			{
				try
				{
					return (Object)(object)NetworkManager.Singleton != (Object)null && (NetworkManager.Singleton.IsHost || NetworkManager.Singleton.IsServer);
				}
				catch
				{
					return true;
				}
			}
		}

		internal static void Register()
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Expected O, but got Unknown
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Expected O, but got Unknown
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Expected O, but got Unknown
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Expected O, but got Unknown
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Expected O, but got Unknown
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Expected O, but got Unknown
			if (_registered)
			{
				return;
			}
			try
			{
				NetworkManager singleton = NetworkManager.Singleton;
				CustomMessagingManager val = ((singleton != null) ? singleton.CustomMessagingManager : null);
				if (val != null)
				{
					object obj = <>O.<0>__OnBreakReceived;
					if (obj == null)
					{
						HandleNamedMessageDelegate val2 = OnBreakReceived;
						<>O.<0>__OnBreakReceived = val2;
						obj = (object)val2;
					}
					val.RegisterNamedMessageHandler("BL_Break", (HandleNamedMessageDelegate)obj);
					object obj2 = <>O.<1>__OnCarryReceived;
					if (obj2 == null)
					{
						HandleNamedMessageDelegate val3 = OnCarryReceived;
						<>O.<1>__OnCarryReceived = val3;
						obj2 = (object)val3;
					}
					val.RegisterNamedMessageHandler("BL_Carry", (HandleNamedMessageDelegate)obj2);
					object obj3 = <>O.<2>__OnDropReceived;
					if (obj3 == null)
					{
						HandleNamedMessageDelegate val4 = OnDropReceived;
						<>O.<2>__OnDropReceived = val4;
						obj3 = (object)val4;
					}
					val.RegisterNamedMessageHandler("BL_Drop", (HandleNamedMessageDelegate)obj3);
					object obj4 = <>O.<3>__OnCleanReceived;
					if (obj4 == null)
					{
						HandleNamedMessageDelegate val5 = OnCleanReceived;
						<>O.<3>__OnCleanReceived = val5;
						obj4 = (object)val5;
					}
					val.RegisterNamedMessageHandler("BL_Clean", (HandleNamedMessageDelegate)obj4);
					object obj5 = <>O.<4>__OnReqBreakReceived;
					if (obj5 == null)
					{
						HandleNamedMessageDelegate val6 = OnReqBreakReceived;
						<>O.<4>__OnReqBreakReceived = val6;
						obj5 = (object)val6;
					}
					val.RegisterNamedMessageHandler("BL_ReqBreak", (HandleNamedMessageDelegate)obj5);
					object obj6 = <>O.<5>__OnReqCarryReceived;
					if (obj6 == null)
					{
						HandleNamedMessageDelegate val7 = OnReqCarryReceived;
						<>O.<5>__OnReqCarryReceived = val7;
						obj6 = (object)val7;
					}
					val.RegisterNamedMessageHandler("BL_ReqCarry", (HandleNamedMessageDelegate)obj6);
					object obj7 = <>O.<6>__OnReqDropReceived;
					if (obj7 == null)
					{
						HandleNamedMessageDelegate val8 = OnReqDropReceived;
						<>O.<6>__OnReqDropReceived = val8;
						obj7 = (object)val8;
					}
					val.RegisterNamedMessageHandler("BL_ReqDrop", (HandleNamedMessageDelegate)obj7);
					_registered = true;
					Plugin.Logger.LogInfo((object)"[BrokenLegNet] Netzwerk-Handler registriert!");
				}
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogError((object)("[BrokenLegNet] Register Fehler: " + ex.Message));
			}
		}

		internal static void Unregister()
		{
			if (!_registered)
			{
				return;
			}
			try
			{
				NetworkManager singleton = NetworkManager.Singleton;
				CustomMessagingManager val = ((singleton != null) ? singleton.CustomMessagingManager : null);
				if (val != null)
				{
					val.UnregisterNamedMessageHandler("BL_Break");
					val.UnregisterNamedMessageHandler("BL_Carry");
					val.UnregisterNamedMessageHandler("BL_Drop");
					val.UnregisterNamedMessageHandler("BL_Clean");
					val.UnregisterNamedMessageHandler("BL_ReqBreak");
					val.UnregisterNamedMessageHandler("BL_ReqCarry");
					val.UnregisterNamedMessageHandler("BL_ReqDrop");
				}
			}
			catch
			{
			}
			_registered = false;
			Plugin.Logger.LogInfo((object)"[BrokenLegNet] Netzwerk-Handler entfernt.");
		}

		internal static void ClientNotifyBreak(ulong clientId)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			if (IsHost)
			{
				HostBroadcastBreak(clientId);
			}
			else if (_registered)
			{
				try
				{
					FastBufferWriter val = default(FastBufferWriter);
					((FastBufferWriter)(ref val))..ctor(8, (Allocator)2, -1);
					((FastBufferWriter)(ref val)).WriteValueSafe<ulong>(ref clientId, default(ForPrimitives));
					NetworkManager.Singleton.CustomMessagingManager.SendNamedMessage("BL_ReqBreak", 0uL, val, (NetworkDelivery)3);
					((FastBufferWriter)(ref val)).Dispose();
					Debug.Log((object)$"[BrokenLegNet] Break-Request an Host: Spieler {clientId}");
				}
				catch (Exception ex)
				{
					Debug.LogError((object)("[BrokenLegNet] ClientNotifyBreak Fehler: " + ex.Message));
				}
			}
		}

		internal static void ClientNotifyCarry(ulong carrierId, ulong carriedId)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			if (IsHost)
			{
				HostBroadcastCarry(carrierId, carriedId);
			}
			else if (_registered)
			{
				try
				{
					FastBufferWriter val = default(FastBufferWriter);
					((FastBufferWriter)(ref val))..ctor(16, (Allocator)2, -1);
					((FastBufferWriter)(ref val)).WriteValueSafe<ulong>(ref carrierId, default(ForPrimitives));
					((FastBufferWriter)(ref val)).WriteValueSafe<ulong>(ref carriedId, default(ForPrimitives));
					NetworkManager.Singleton.CustomMessagingManager.SendNamedMessage("BL_ReqCarry", 0uL, val, (NetworkDelivery)3);
					((FastBufferWriter)(ref val)).Dispose();
					Debug.Log((object)$"[BrokenLegNet] Carry-Request an Host: {carrierId} → {carriedId}");
				}
				catch (Exception ex)
				{
					Debug.LogError((object)("[BrokenLegNet] ClientNotifyCarry Fehler: " + ex.Message));
				}
			}
		}

		internal static void ClientNotifyDrop(ulong carrierId, ulong carriedId)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			if (IsHost)
			{
				HostBroadcastDrop(carriedId);
			}
			else if (_registered)
			{
				try
				{
					FastBufferWriter val = default(FastBufferWriter);
					((FastBufferWriter)(ref val))..ctor(8, (Allocator)2, -1);
					((FastBufferWriter)(ref val)).WriteValueSafe<ulong>(ref carriedId, default(ForPrimitives));
					NetworkManager.Singleton.CustomMessagingManager.SendNamedMessage("BL_ReqDrop", 0uL, val, (NetworkDelivery)3);
					((FastBufferWriter)(ref val)).Dispose();
					Debug.Log((object)$"[BrokenLegNet] Drop-Request an Host: Spieler {carriedId}");
				}
				catch (Exception ex)
				{
					Debug.LogError((object)("[BrokenLegNet] ClientNotifyDrop Fehler: " + ex.Message));
				}
			}
		}

		internal static void HostBroadcastBreak(ulong clientId)
		{
			if (IsHost)
			{
				SendToAll("BL_Break", delegate(FastBufferWriter w)
				{
					//IL_000a: Unknown result type (might be due to invalid IL or missing references)
					//IL_0010: Unknown result type (might be due to invalid IL or missing references)
					((FastBufferWriter)(ref w)).WriteValueSafe<ulong>(ref clientId, default(ForPrimitives));
				});
				Plugin.BreakPlayerLeg(clientId);
			}
		}

		internal static void HostBroadcastCarry(ulong carrierId, ulong carriedId)
		{
			if (IsHost)
			{
				SendToAll("BL_Carry", delegate(FastBufferWriter w)
				{
					//IL_000a: Unknown result type (might be due to invalid IL or missing references)
					//IL_0010: Unknown result type (might be due to invalid IL or missing references)
					//IL_0020: Unknown result type (might be due to invalid IL or missing references)
					//IL_0026: Unknown result type (might be due to invalid IL or missing references)
					((FastBufferWriter)(ref w)).WriteValueSafe<ulong>(ref carrierId, default(ForPrimitives));
					((FastBufferWriter)(ref w)).WriteValueSafe<ulong>(ref carriedId, default(ForPrimitives));
				});
				Plugin.StartCarry(carriedId, carrierId);
			}
		}

		internal static void HostBroadcastDrop(ulong carriedId)
		{
			if (IsHost)
			{
				SendToAll("BL_Drop", delegate(FastBufferWriter w)
				{
					//IL_000a: Unknown result type (might be due to invalid IL or missing references)
					//IL_0010: Unknown result type (might be due to invalid IL or missing references)
					((FastBufferWriter)(ref w)).WriteValueSafe<ulong>(ref carriedId, default(ForPrimitives));
				});
				Plugin.StopCarry(carriedId);
			}
		}

		internal static void HostBroadcastCleanup()
		{
			if (IsHost)
			{
				SendToAll("BL_Clean", delegate(FastBufferWriter w)
				{
					//IL_0008: Unknown result type (might be due to invalid IL or missing references)
					//IL_000e: Unknown result type (might be due to invalid IL or missing references)
					byte b = 0;
					((FastBufferWriter)(ref w)).WriteValueSafe<byte>(ref b, default(ForPrimitives));
				});
			}
		}

		private static void OnBreakReceived(ulong senderId, FastBufferReader reader)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			if (IsHost)
			{
				return;
			}
			try
			{
				ulong num = default(ulong);
				((FastBufferReader)(ref reader)).ReadValueSafe<ulong>(ref num, default(ForPrimitives));
				Plugin.BreakPlayerLeg(num);
				Debug.Log((object)$"[BrokenLegNet] Break empfangen: Spieler {num}");
			}
			catch (Exception ex)
			{
				Debug.LogError((object)("[BrokenLegNet] OnBreak Fehler: " + ex.Message));
			}
		}

		private static void OnCarryReceived(ulong senderId, FastBufferReader reader)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			if (IsHost)
			{
				return;
			}
			try
			{
				ulong num = default(ulong);
				((FastBufferReader)(ref reader)).ReadValueSafe<ulong>(ref num, default(ForPrimitives));
				ulong num2 = default(ulong);
				((FastBufferReader)(ref reader)).ReadValueSafe<ulong>(ref num2, default(ForPrimitives));
				Plugin.StartCarry(num2, num);
				Debug.Log((object)$"[BrokenLegNet] Carry empfangen: {num} → {num2}");
			}
			catch (Exception ex)
			{
				Debug.LogError((object)("[BrokenLegNet] OnCarry Fehler: " + ex.Message));
			}
		}

		private static void OnDropReceived(ulong senderId, FastBufferReader reader)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			if (IsHost)
			{
				return;
			}
			try
			{
				ulong num = default(ulong);
				((FastBufferReader)(ref reader)).ReadValueSafe<ulong>(ref num, default(ForPrimitives));
				Plugin.StopCarry(num);
				Debug.Log((object)$"[BrokenLegNet] Drop empfangen: Spieler {num}");
			}
			catch (Exception ex)
			{
				Debug.LogError((object)("[BrokenLegNet] OnDrop Fehler: " + ex.Message));
			}
		}

		private static void OnCleanReceived(ulong senderId, FastBufferReader reader)
		{
			if (IsHost)
			{
				return;
			}
			try
			{
				Plugin.CleanupAll();
				Debug.Log((object)"[BrokenLegNet] Cleanup empfangen");
			}
			catch (Exception ex)
			{
				Debug.LogError((object)("[BrokenLegNet] OnClean Fehler: " + ex.Message));
			}
		}

		private static void OnReqBreakReceived(ulong senderId, FastBufferReader reader)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			if (!IsHost)
			{
				return;
			}
			try
			{
				ulong num = default(ulong);
				((FastBufferReader)(ref reader)).ReadValueSafe<ulong>(ref num, default(ForPrimitives));
				Debug.Log((object)$"[BrokenLegNet] Break-Request von Client: Spieler {num}");
				HostBroadcastBreak(num);
			}
			catch (Exception ex)
			{
				Debug.LogError((object)("[BrokenLegNet] OnReqBreak Fehler: " + ex.Message));
			}
		}

		private static void OnReqCarryReceived(ulong senderId, FastBufferReader reader)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			if (!IsHost)
			{
				return;
			}
			try
			{
				ulong num = default(ulong);
				((FastBufferReader)(ref reader)).ReadValueSafe<ulong>(ref num, default(ForPrimitives));
				ulong num2 = default(ulong);
				((FastBufferReader)(ref reader)).ReadValueSafe<ulong>(ref num2, default(ForPrimitives));
				Debug.Log((object)$"[BrokenLegNet] Carry-Request: {num} → {num2}");
				HostBroadcastCarry(num, num2);
			}
			catch (Exception ex)
			{
				Debug.LogError((object)("[BrokenLegNet] OnReqCarry Fehler: " + ex.Message));
			}
		}

		private static void OnReqDropReceived(ulong senderId, FastBufferReader reader)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			if (!IsHost)
			{
				return;
			}
			try
			{
				ulong num = default(ulong);
				((FastBufferReader)(ref reader)).ReadValueSafe<ulong>(ref num, default(ForPrimitives));
				Debug.Log((object)$"[BrokenLegNet] Drop-Request: Spieler {num}");
				HostBroadcastDrop(num);
			}
			catch (Exception ex)
			{
				Debug.LogError((object)("[BrokenLegNet] OnReqDrop Fehler: " + ex.Message));
			}
		}

		internal static PlayerControllerB GetPlayerByClientId(ulong clientId)
		{
			try
			{
				if (StartOfRound.Instance?.allPlayerScripts == null)
				{
					return null;
				}
				PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
				foreach (PlayerControllerB val in allPlayerScripts)
				{
					if ((Object)(object)val != (Object)null && val.actualClientId == clientId)
					{
						return val;
					}
				}
			}
			catch
			{
			}
			return null;
		}

		private static void SendToAll(string msgName, Action<FastBufferWriter> write)
		{
			//IL_0018: 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 (!_registered)
			{
				return;
			}
			try
			{
				FastBufferWriter val = default(FastBufferWriter);
				((FastBufferWriter)(ref val))..ctor(256, (Allocator)2, -1);
				write(val);
				NetworkManager.Singleton.CustomMessagingManager.SendNamedMessageToAll(msgName, val, (NetworkDelivery)3);
				((FastBufferWriter)(ref val)).Dispose();
			}
			catch (Exception ex)
			{
				Debug.LogError((object)("[BrokenLegNet] SendToAll(" + msgName + ") Fehler: " + ex.Message));
			}
		}
	}
	[BepInPlugin("BrokenLegMod", "BrokenLegMod", "1.0.0")]
	public class Plugin : BaseUnityPlugin
	{
		internal static ManualLogSource Logger;

		private Harmony _harmony;

		internal static ConfigEntry<float> cfgLimpSpeed;

		internal static ConfigEntry<float> cfgCarrierSpeedMult;

		internal static ConfigEntry<bool> cfgBlockJump;

		internal static ConfigEntry<bool> cfgBlockSprint;

		internal static ConfigEntry<float> cfgCarryForward;

		internal static ConfigEntry<float> cfgCarryDown;

		internal static ConfigEntry<float> cfgCarryRight;

		internal static ConfigEntry<float> cfgCarryWeight;

		internal static ConfigEntry<KeyCode> cfgDropKey;

		internal static HashSet<ulong> BrokenLegPlayers = new HashSet<ulong>();

		internal static Dictionary<ulong, ulong> CarryState = new Dictionary<ulong, ulong>();

		internal static float CleanupCooldown = 0f;

		private void Awake()
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Expected O, but got Unknown
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Expected O, but got Unknown
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Expected O, but got Unknown
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Expected O, but got Unknown
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Expected O, but got Unknown
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Expected O, but got Unknown
			Logger = ((BaseUnityPlugin)this).Logger;
			Logger.LogInfo((object)"BrokenLegMod v1.0.0 geladen!");
			cfgLimpSpeed = ((BaseUnityPlugin)this).Config.Bind<float>("Gameplay", "Humpel-Geschwindigkeit", 0.8f, new ConfigDescription("Wie schnell der verletzte Spieler humpelt. Niedriger = langsamer. Normal = 1.0", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 1.5f), Array.Empty<object>()));
			cfgCarrierSpeedMult = ((BaseUnityPlugin)this).Config.Bind<float>("Gameplay", "Traeger-Geschwindigkeit", 0.6f, new ConfigDescription("Speed-Multiplikator fuer den Spieler der jemanden traegt. 1.0 = volle Geschwindigkeit", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.2f, 1f), Array.Empty<object>()));
			cfgBlockJump = ((BaseUnityPlugin)this).Config.Bind<bool>("Gameplay", "Springen blockieren", true, "Spieler mit gebrochenem Bein kann nicht springen");
			cfgBlockSprint = ((BaseUnityPlugin)this).Config.Bind<bool>("Gameplay", "Sprinten blockieren", true, "Spieler mit gebrochenem Bein kann nicht sprinten");
			cfgCarryForward = ((BaseUnityPlugin)this).Config.Bind<float>("Tragen", "Position Vorwaerts", 1.2f, new ConfigDescription("Wie weit vor dem Traeger der getragene Spieler ist (in Metern)", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.3f, 2.5f), Array.Empty<object>()));
			cfgCarryDown = ((BaseUnityPlugin)this).Config.Bind<float>("Tragen", "Position Runter", 0.6f, new ConfigDescription("Wie weit nach unten der getragene Spieler haengt (in Metern)", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1.5f), Array.Empty<object>()));
			cfgCarryRight = ((BaseUnityPlugin)this).Config.Bind<float>("Tragen", "Position Rechts", 0.3f, new ConfigDescription("Seitlicher Versatz nach rechts (damit Sicht nicht blockiert). 0 = mittig", (AcceptableValueBase)(object)new AcceptableValueRange<float>(-1f, 1f), Array.Empty<object>()));
			cfgCarryWeight = ((BaseUnityPlugin)this).Config.Bind<float>("Tragen", "Trage-Gewicht", 1.5f, new ConfigDescription("Zusaetzliches Gewicht beim Tragen. Hoeher = langsamer + schwerer", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 3f), Array.Empty<object>()));
			cfgDropKey = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("Controls", "Ablegen-Taste", (KeyCode)103, "Taste zum Ablegen des getragenen Spielers (Standard: G)");
			_harmony = new Harmony("BrokenLegMod");
			_harmony.PatchAll(typeof(MakeCriticallyInjured_Patch));
			_harmony.PatchAll(typeof(PlayerUpdate_Patch));
			_harmony.PatchAll(typeof(PlayerJump_Patch));
			_harmony.PatchAll(typeof(PlayerInteract_Patch));
			_harmony.PatchAll(typeof(PlayerDiscard_Patch));
			_harmony.PatchAll(typeof(Player_KillPlayer_Patch));
			_harmony.PatchAll(typeof(StartOfRound_Start_Patch));
			_harmony.PatchAll(typeof(GameNetworkManager_Disconnect_Patch));
			_harmony.PatchAll(typeof(StartOfRound_ReviveDeadPlayers_Patch));
			_harmony.PatchAll(typeof(StartOfRound_ShipLeave_Patch));
			_harmony.PatchAll(typeof(StartOfRound_ResetShip_Patch));
			Logger.LogInfo((object)"Alle Harmony-Patches angewendet!");
		}

		internal static bool IsLegBroken(PlayerControllerB player)
		{
			if ((Object)(object)player != (Object)null)
			{
				return BrokenLegPlayers.Contains(player.actualClientId);
			}
			return false;
		}

		internal static bool IsBeingCarried(PlayerControllerB player)
		{
			if ((Object)(object)player != (Object)null)
			{
				return CarryState.ContainsKey(player.actualClientId);
			}
			return false;
		}

		internal static bool IsCarrying(PlayerControllerB player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			foreach (KeyValuePair<ulong, ulong> item in CarryState)
			{
				if (item.Value == player.actualClientId)
				{
					return true;
				}
			}
			return false;
		}

		internal static PlayerControllerB GetCarriedPlayer(PlayerControllerB carrier)
		{
			if ((Object)(object)carrier == (Object)null)
			{
				return null;
			}
			foreach (KeyValuePair<ulong, ulong> item in CarryState)
			{
				if (item.Value == carrier.actualClientId)
				{
					return BrokenLegNetwork.GetPlayerByClientId(item.Key);
				}
			}
			return null;
		}

		internal static PlayerControllerB GetCarrier(PlayerControllerB carried)
		{
			if ((Object)(object)carried == (Object)null || !CarryState.ContainsKey(carried.actualClientId))
			{
				return null;
			}
			return BrokenLegNetwork.GetPlayerByClientId(CarryState[carried.actualClientId]);
		}

		internal static PlayerControllerB GetNearbyBrokenPlayer(PlayerControllerB viewer)
		{
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			if (StartOfRound.Instance?.allPlayerScripts == null)
			{
				return null;
			}
			Camera gameplayCamera = viewer.gameplayCamera;
			if ((Object)(object)gameplayCamera == (Object)null)
			{
				return null;
			}
			PlayerControllerB result = null;
			float num = float.MaxValue;
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val in allPlayerScripts)
			{
				if ((Object)(object)val == (Object)null || !val.isPlayerControlled || val.isPlayerDead || val == viewer || !IsLegBroken(val) || IsBeingCarried(val))
				{
					continue;
				}
				float num2 = Vector3.Distance(((Component)gameplayCamera).transform.position, ((Component)val).transform.position);
				if (!(num2 > 5f))
				{
					Vector3 val2 = ((Component)val).transform.position - ((Component)gameplayCamera).transform.position;
					Vector3 normalized = ((Vector3)(ref val2)).normalized;
					if (!(Vector3.Dot(((Component)gameplayCamera).transform.forward, normalized) < 0.5f) && num2 < num)
					{
						result = val;
						num = num2;
					}
				}
			}
			return result;
		}

		internal static void BreakPlayerLeg(ulong clientId)
		{
			if (BrokenLegPlayers.Contains(clientId))
			{
				return;
			}
			BrokenLegPlayers.Add(clientId);
			Logger.LogInfo((object)$"[BrokenLeg] Spieler {clientId}: Bein gebrochen! Dauerhaftes Humpeln!");
			PlayerControllerB val = GameNetworkManager.Instance?.localPlayerController;
			if (!((Object)(object)val != (Object)null) || val.actualClientId != clientId)
			{
				return;
			}
			try
			{
				HUDManager instance = HUDManager.Instance;
				if (instance != null)
				{
					instance.DisplayTip("Bein gebrochen!", "Du humpelst jetzt dauerhaft.\nAndere Spieler koennen dich mit [E] aufheben.", true, false, "BL_Break");
				}
			}
			catch
			{
			}
		}

		internal static void StartCarry(ulong carriedId, ulong carrierId)
		{
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			if (CarryState.ContainsKey(carriedId))
			{
				return;
			}
			CarryState[carriedId] = carrierId;
			Logger.LogInfo((object)$"[BrokenLeg] Spieler {carrierId} traegt Spieler {carriedId}!");
			PlayerControllerB playerByClientId = BrokenLegNetwork.GetPlayerByClientId(carrierId);
			if ((Object)(object)playerByClientId != (Object)null)
			{
				SetCarryAnimation(playerByClientId, enable: true);
			}
			PlayerControllerB val = GameNetworkManager.Instance?.localPlayerController;
			if (!((Object)(object)val != (Object)null))
			{
				return;
			}
			if (val.actualClientId == carrierId)
			{
				try
				{
					HUDManager instance = HUDManager.Instance;
					if (instance != null)
					{
						instance.DisplayTip("Spieler aufgehoben", $"Druecke [{cfgDropKey.Value}] zum Ablegen.", false, false, "BL_Carry");
					}
					return;
				}
				catch
				{
					return;
				}
			}
			if (val.actualClientId != carriedId)
			{
				return;
			}
			try
			{
				HUDManager instance2 = HUDManager.Instance;
				if (instance2 != null)
				{
					instance2.DisplayTip("Du wirst getragen!", "Warte bis du abgelegt wirst.", false, false, "BL_Carried");
				}
			}
			catch
			{
			}
		}

		internal static void StopCarry(ulong carriedId)
		{
			if (CarryState.ContainsKey(carriedId))
			{
				PlayerControllerB playerByClientId = BrokenLegNetwork.GetPlayerByClientId(CarryState[carriedId]);
				if ((Object)(object)playerByClientId != (Object)null)
				{
					SetCarryAnimation(playerByClientId, enable: false);
				}
				CarryState.Remove(carriedId);
				Logger.LogInfo((object)$"[BrokenLeg] Spieler {carriedId} wurde abgelegt!");
			}
		}

		internal static void SetCarryAnimation(PlayerControllerB carrier, bool enable)
		{
			try
			{
				carrier.twoHanded = enable;
				carrier.twoHandedAnimation = enable;
				float value = cfgCarryWeight.Value;
				if (enable)
				{
					carrier.carryWeight = Mathf.Clamp(carrier.carryWeight + value, 1f, 4f);
				}
				else
				{
					carrier.carryWeight = Mathf.Max(carrier.carryWeight - value, 1f);
				}
				if ((Object)(object)carrier.playerBodyAnimator != (Object)null)
				{
					carrier.playerBodyAnimator.SetBool("Grab", enable);
					carrier.playerBodyAnimator.SetBool("GrabValidated", enable);
					carrier.playerBodyAnimator.SetBool("cancelHolding", !enable);
					carrier.playerBodyAnimator.SetBool("GrabInvalidated", false);
					try
					{
						carrier.playerBodyAnimator.SetBool("holdingTwoHandItem", enable);
					}
					catch
					{
					}
				}
				Logger.LogInfo((object)("[BrokenLeg] Trage-Animation " + (enable ? "AN" : "AUS") + " fuer " + carrier.playerUsername));
			}
			catch (Exception ex)
			{
				Logger.LogError((object)("[BrokenLeg] SetCarryAnimation Fehler: " + ex.Message));
			}
		}

		internal static void HealPlayer(ulong clientId)
		{
			BrokenLegPlayers.Remove(clientId);
			if (CarryState.ContainsKey(clientId))
			{
				CarryState.Remove(clientId);
			}
		}

		internal static void CleanupAll()
		{
			try
			{
				foreach (KeyValuePair<ulong, ulong> item in CarryState)
				{
					PlayerControllerB playerByClientId = BrokenLegNetwork.GetPlayerByClientId(item.Value);
					if ((Object)(object)playerByClientId != (Object)null)
					{
						SetCarryAnimation(playerByClientId, enable: false);
					}
				}
			}
			catch
			{
			}
			BrokenLegPlayers.Clear();
			CarryState.Clear();
			CleanupCooldown = 5f;
			try
			{
				if (StartOfRound.Instance?.allPlayerScripts != null)
				{
					PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
					foreach (PlayerControllerB val in allPlayerScripts)
					{
						if ((Object)(object)val != (Object)null)
						{
							val.criticallyInjured = false;
						}
					}
				}
			}
			catch
			{
			}
			Logger.LogInfo((object)"[BrokenLeg] Alle Zustaende zurueckgesetzt.");
		}
	}
	[HarmonyPatch(typeof(PlayerControllerB), "MakeCriticallyInjured")]
	internal static class MakeCriticallyInjured_Patch
	{
		[HarmonyPostfix]
		private static void Postfix(PlayerControllerB __instance, bool enable)
		{
			if (!enable && Plugin.IsLegBroken(__instance))
			{
				__instance.criticallyInjured = true;
				Plugin.Logger.LogInfo((object)("[BrokenLeg] Heilung blockiert fuer " + __instance.playerUsername + "!"));
			}
		}
	}
	[HarmonyPatch(typeof(PlayerControllerB), "Update")]
	internal static class PlayerUpdate_Patch
	{
		private const float NORMAL_SPEED = 4.6f;

		private static FieldInfo _cursorTipField;

		private static PropertyInfo _cursorTipTextProp;

		private static bool _cursorTipResolved;

		private static void SetCursorTip(string text)
		{
			try
			{
				if ((Object)(object)HUDManager.Instance == (Object)null)
				{
					return;
				}
				if (!_cursorTipResolved)
				{
					_cursorTipResolved = true;
					BindingFlags bindingAttr = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
					string[] array = new string[5] { "cursorTip", "tipText", "cursorTooltip", "interactionText", "hoverTip" };
					foreach (string name in array)
					{
						_cursorTipField = typeof(HUDManager).GetField(name, bindingAttr);
						if (_cursorTipField != null)
						{
							break;
						}
					}
					if (_cursorTipField == null)
					{
						FieldInfo[] fields = typeof(HUDManager).GetFields(bindingAttr);
						foreach (FieldInfo fieldInfo in fields)
						{
							if (fieldInfo.Name.ToLower().Contains("tip") || fieldInfo.Name.ToLower().Contains("cursor"))
							{
								object value = fieldInfo.GetValue(HUDManager.Instance);
								if (value != null && value.GetType().GetProperty("text") != null)
								{
									_cursorTipField = fieldInfo;
									break;
								}
							}
						}
					}
					if (_cursorTipField != null)
					{
						object value2 = _cursorTipField.GetValue(HUDManager.Instance);
						if (value2 != null)
						{
							_cursorTipTextProp = value2.GetType().GetProperty("text");
						}
					}
				}
				if (_cursorTipField != null && _cursorTipTextProp != null)
				{
					object value3 = _cursorTipField.GetValue(HUDManager.Instance);
					if (value3 != null)
					{
						_cursorTipTextProp.SetValue(value3, text);
					}
				}
			}
			catch
			{
			}
		}

		[HarmonyPostfix]
		private static void Postfix(PlayerControllerB __instance)
		{
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (__instance.isPlayerDead)
				{
					return;
				}
				if (Plugin.CleanupCooldown > 0f)
				{
					Plugin.CleanupCooldown -= Time.deltaTime;
					return;
				}
				if (__instance.criticallyInjured && !Plugin.IsLegBroken(__instance))
				{
					PlayerControllerB val = GameNetworkManager.Instance?.localPlayerController;
					if ((Object)(object)val != (Object)null && val == __instance)
					{
						Plugin.Logger.LogInfo((object)("[BrokenLeg] " + __instance.playerUsername + " ist kritisch verletzt → Bein bricht!"));
						BrokenLegNetwork.ClientNotifyBreak(__instance.actualClientId);
					}
				}
				if (Plugin.IsLegBroken(__instance))
				{
					__instance.criticallyInjured = true;
					try
					{
						FieldInfo field = typeof(PlayerControllerB).GetField("limpMultiplier", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
						if (field != null)
						{
							field.SetValue(__instance, Plugin.cfgLimpSpeed.Value);
						}
					}
					catch
					{
					}
					if (Plugin.cfgBlockSprint.Value)
					{
						__instance.isSprinting = false;
						__instance.sprintMeter = 0f;
					}
					if (Plugin.IsBeingCarried(__instance))
					{
						__instance.movementSpeed = 0f;
					}
				}
				if (Plugin.IsCarrying(__instance))
				{
					float num = 4.6f * Plugin.cfgCarrierSpeedMult.Value;
					if (__instance.movementSpeed > num)
					{
						__instance.movementSpeed = num;
					}
				}
				PlayerControllerB val2 = GameNetworkManager.Instance?.localPlayerController;
				if ((Object)(object)val2 == (Object)null || __instance != val2)
				{
					return;
				}
				if (Plugin.IsCarrying(__instance) && Input.GetKeyDown(Plugin.cfgDropKey.Value))
				{
					PlayerControllerB carriedPlayer = Plugin.GetCarriedPlayer(__instance);
					if ((Object)(object)carriedPlayer != (Object)null)
					{
						Plugin.Logger.LogInfo((object)"[BrokenLeg] Spieler abgelegt (Taste)!");
						BrokenLegNetwork.ClientNotifyDrop(__instance.actualClientId, carriedPlayer.actualClientId);
					}
				}
				if (!Plugin.IsLegBroken(__instance) && !Plugin.IsCarrying(__instance))
				{
					PlayerControllerB nearbyBrokenPlayer = Plugin.GetNearbyBrokenPlayer(__instance);
					if ((Object)(object)nearbyBrokenPlayer != (Object)null)
					{
						SetCursorTip("Aufheben (" + nearbyBrokenPlayer.playerUsername + ") : [E]");
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogError((object)("[BrokenLeg] Update-Patch Fehler: " + ex.Message));
			}
		}
	}
	[HarmonyPatch(typeof(PlayerControllerB), "Jump_performed")]
	internal static class PlayerJump_Patch
	{
		[HarmonyPrefix]
		private static bool Prefix(PlayerControllerB __instance)
		{
			if (Plugin.IsBeingCarried(__instance))
			{
				return false;
			}
			if (Plugin.IsLegBroken(__instance) && Plugin.cfgBlockJump.Value)
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(PlayerControllerB), "Interact_performed")]
	internal static class PlayerInteract_Patch
	{
		[HarmonyPrefix]
		private static bool Prefix(PlayerControllerB __instance)
		{
			try
			{
				PlayerControllerB val = GameNetworkManager.Instance?.localPlayerController;
				if ((Object)(object)val == (Object)null || __instance != val)
				{
					return true;
				}
				if (__instance.isPlayerDead)
				{
					return true;
				}
				if (Plugin.IsLegBroken(__instance))
				{
					return true;
				}
				if (Plugin.IsCarrying(__instance))
				{
					return true;
				}
				PlayerControllerB nearbyBrokenPlayer = Plugin.GetNearbyBrokenPlayer(__instance);
				if ((Object)(object)nearbyBrokenPlayer == (Object)null)
				{
					return true;
				}
				Plugin.Logger.LogInfo((object)("[BrokenLeg] " + __instance.playerUsername + " hebt " + nearbyBrokenPlayer.playerUsername + " auf!"));
				BrokenLegNetwork.ClientNotifyCarry(__instance.actualClientId, nearbyBrokenPlayer.actualClientId);
				return false;
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogError((object)("[BrokenLeg] Interact-Patch Fehler: " + ex.Message));
				return true;
			}
		}
	}
	[HarmonyPatch(typeof(PlayerControllerB), "Discard_performed")]
	internal static class PlayerDiscard_Patch
	{
		[HarmonyPrefix]
		private static bool Prefix(PlayerControllerB __instance)
		{
			try
			{
				PlayerControllerB val = GameNetworkManager.Instance?.localPlayerController;
				if ((Object)(object)val == (Object)null || __instance != val)
				{
					return true;
				}
				if (__instance.isPlayerDead)
				{
					return true;
				}
				if (Plugin.IsCarrying(__instance))
				{
					PlayerControllerB carriedPlayer = Plugin.GetCarriedPlayer(__instance);
					if ((Object)(object)carriedPlayer != (Object)null)
					{
						Plugin.Logger.LogInfo((object)"[BrokenLeg] Spieler abgelegt (Discard-Taste)!");
						BrokenLegNetwork.ClientNotifyDrop(__instance.actualClientId, carriedPlayer.actualClientId);
						return false;
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogError((object)("[BrokenLeg] Discard-Patch Fehler: " + ex.Message));
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(PlayerControllerB), "KillPlayer")]
	internal static class Player_KillPlayer_Patch
	{
		[HarmonyPostfix]
		private static void Postfix(PlayerControllerB __instance)
		{
			try
			{
				ulong actualClientId = __instance.actualClientId;
				if (Plugin.IsBeingCarried(__instance))
				{
					Plugin.StopCarry(actualClientId);
				}
				PlayerControllerB carriedPlayer = Plugin.GetCarriedPlayer(__instance);
				if ((Object)(object)carriedPlayer != (Object)null)
				{
					Plugin.StopCarry(carriedPlayer.actualClientId);
				}
				Plugin.HealPlayer(actualClientId);
			}
			catch
			{
			}
		}
	}
	[HarmonyPatch(typeof(StartOfRound), "Start")]
	internal static class StartOfRound_Start_Patch
	{
		[HarmonyPostfix]
		private static void Postfix()
		{
			BrokenLegNetwork.Register();
			BrokenLegUpdater.EnsureExists();
			Plugin.Logger.LogInfo((object)"[BrokenLeg] Netzwerk + Updater initialisiert!");
		}
	}
	[HarmonyPatch(typeof(GameNetworkManager), "Disconnect")]
	internal static class GameNetworkManager_Disconnect_Patch
	{
		[HarmonyPrefix]
		private static void Prefix()
		{
			try
			{
				BrokenLegNetwork.Unregister();
				Plugin.CleanupAll();
			}
			catch
			{
			}
		}
	}
	[HarmonyPatch(typeof(StartOfRound), "ReviveDeadPlayers")]
	internal static class StartOfRound_ReviveDeadPlayers_Patch
	{
		[HarmonyPostfix]
		private static void Postfix()
		{
			Plugin.Logger.LogInfo((object)"[BrokenLeg] Spieler wiederbelebt → Aufraumen!");
			Plugin.CleanupAll();
			BrokenLegNetwork.HostBroadcastCleanup();
		}
	}
	[HarmonyPatch(typeof(StartOfRound), "ShipLeave")]
	internal static class StartOfRound_ShipLeave_Patch
	{
		[HarmonyPostfix]
		private static void Postfix()
		{
			Plugin.Logger.LogInfo((object)"[BrokenLeg] Schiff fliegt ab → Aufraumen!");
			Plugin.CleanupAll();
			BrokenLegNetwork.HostBroadcastCleanup();
		}
	}
	[HarmonyPatch(typeof(StartOfRound), "ResetShip")]
	internal static class StartOfRound_ResetShip_Patch
	{
		[HarmonyPostfix]
		private static void Postfix()
		{
			Plugin.Logger.LogInfo((object)"[BrokenLeg] Ship Reset → Aufraumen!");
			Plugin.CleanupAll();
			BrokenLegNetwork.HostBroadcastCleanup();
		}
	}
	internal class BrokenLegUpdater : MonoBehaviour
	{
		private static BrokenLegUpdater _instance;

		internal static void EnsureExists()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			if (!((Object)(object)_instance != (Object)null))
			{
				GameObject val = new GameObject("BrokenLegUpdater");
				Object.DontDestroyOnLoad((Object)val);
				_instance = val.AddComponent<BrokenLegUpdater>();
			}
		}

		private void LateUpdate()
		{
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: 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)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: 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)
			if (Plugin.CarryState.Count == 0)
			{
				return;
			}
			try
			{
				foreach (ulong item in new List<ulong>(Plugin.CarryState.Keys))
				{
					if (!Plugin.CarryState.ContainsKey(item))
					{
						continue;
					}
					ulong clientId = Plugin.CarryState[item];
					PlayerControllerB playerByClientId = BrokenLegNetwork.GetPlayerByClientId(item);
					PlayerControllerB playerByClientId2 = BrokenLegNetwork.GetPlayerByClientId(clientId);
					if ((Object)(object)playerByClientId == (Object)null || (Object)(object)playerByClientId2 == (Object)null)
					{
						continue;
					}
					if (playerByClientId2.isPlayerDead || playerByClientId.isPlayerDead)
					{
						Plugin.StopCarry(item);
						continue;
					}
					if (!playerByClientId2.twoHandedAnimation)
					{
						Plugin.SetCarryAnimation(playerByClientId2, enable: true);
					}
					Vector3 val = ((Component)playerByClientId2).transform.forward * Plugin.cfgCarryForward.Value - ((Component)playerByClientId2).transform.up * Plugin.cfgCarryDown.Value + ((Component)playerByClientId2).transform.right * Plugin.cfgCarryRight.Value;
					((Component)playerByClientId).transform.position = ((Component)playerByClientId2).transform.position + val;
					Vector3 eulerAngles = ((Component)playerByClientId2).transform.eulerAngles;
					((Component)playerByClientId).transform.eulerAngles = new Vector3(0f, eulerAngles.y, 0f);
				}
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogError((object)("[BrokenLeg] Updater Fehler: " + ex.Message));
			}
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "BrokenLegMod";

		public const string PLUGIN_NAME = "BrokenLegMod";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}