using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using ExitGames.Client.Photon;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Photon.Pun;
using Photon.Realtime;
using TMPro;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.EventSystems;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using UnityEngine.Rendering;
using UnityEngine.SceneManagement;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyCompany("Zichen-GameTools-1.0.9")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+1edd851a2e3ea048362167ab33bf7a71fd12cfc3")]
[assembly: AssemblyProduct("Zichen-GameTools-1.0.9")]
[assembly: AssemblyTitle("Zichen-GameTools-1.0.9")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[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 Zichen_GameTools
{
	public enum DisplayLanguage
	{
		中文,
		English
	}
	[BepInPlugin("zichen.gametools", "GameTools", "1.0.9")]
	public class Plugin : BaseUnityPlugin
	{
		internal class BatteryCache
		{
			public bool Resolved;

			public itemType ItemType;

			public bool FallbackResult;
		}

		internal sealed class CfgI18N
		{
			public string SectionCN;

			public string SectionEN;

			public string KeyCN;

			public string KeyEN;

			public string DisplayEN;

			public string DescCN;

			public string DescEN;

			public ConfigurationManagerAttributes Attrs;

			public string ValueEN;

			public string ValueCN;

			public ConfigEntry<string> ReadOnlyEntry;

			public ConfigEntryBase Entry;
		}

		public enum SpawnType
		{
			Valuable,
			Weapon,
			Enemy,
			Cart,
			Vehicle,
			Other
		}

		public class SpawnableInfo
		{
			public string Name;

			public string InternalName;

			public SpawnType Type;

			public object Source;

			public string ExtraInfo;

			private string _cachedNameCN;

			private string _cachedNameEN;

			public string GetDisplayName()
			{
				if (UseChinese())
				{
					if (_cachedNameCN == null)
					{
						string name = Name;
						name = ((Type != SpawnType.Enemy) ? ItemNameLocalizer.Translate(Name) : EnemyNameLocalizer.Translate(Name));
						if (!string.IsNullOrEmpty(ExtraInfo))
						{
							_cachedNameCN = name + " " + ExtraInfo;
						}
						else
						{
							_cachedNameCN = name;
						}
					}
					return _cachedNameCN;
				}
				if (_cachedNameEN == null)
				{
					string name2 = Name;
					if (!string.IsNullOrEmpty(ExtraInfo))
					{
						_cachedNameEN = name2 + " " + ExtraInfo;
					}
					else
					{
						_cachedNameEN = name2;
					}
				}
				return _cachedNameEN;
			}
		}

		internal enum PlayerTeleportType
		{
			PullToFront,
			Scatter,
			ToTruck,
			ToExtractionButton
		}

		[HarmonyPatch(typeof(InputManager), "InitializeInputs")]
		private class InputManager_InitializeInputs_Patch
		{
			[HarmonyPostfix]
			private static void Postfix()
			{
				try
				{
					InputManagerInitializeInputsPostfix();
				}
				catch (Exception arg)
				{
					Plugin instance = Instance;
					if (instance != null)
					{
						((BaseUnityPlugin)instance).Logger.LogWarning((object)$"[InitializeInputs Patch Error]: {arg}");
					}
				}
			}
		}

		[HarmonyPatch(typeof(PlayerController), "Start")]
		private class PlayerController_Start_Patch
		{
			[HarmonyPostfix]
			private static void Postfix()
			{
				try
				{
					PlayerControllerStartPostfix();
				}
				catch (Exception arg)
				{
					Plugin instance = Instance;
					if (instance != null)
					{
						((BaseUnityPlugin)instance).Logger.LogWarning((object)$"[PlayerController.Start Patch Error]: {arg}");
					}
				}
			}
		}

		[HarmonyPatch(typeof(CameraAim), "Update")]
		private class CameraAim_Update_Patch
		{
			private static readonly FieldRef<CameraAim, float> _fOverridePlayerAimDisableTimer = AccessTools.FieldRefAccess<CameraAim, float>("overridePlayerAimDisableTimer");

			private static readonly FieldRef<CameraAim, float> _fOverrideAimStopTimer = AccessTools.FieldRefAccess<CameraAim, float>("overrideAimStopTimer");

			private static readonly FieldRef<CameraAim, bool> _fOverrideAimStop = AccessTools.FieldRefAccess<CameraAim, bool>("overrideAimStop");

			private static readonly FieldRef<InputManager, float> _fDisableAimingTimer = AccessTools.FieldRefAccess<InputManager, float>("disableAimingTimer");

			private static readonly FieldRef<GameplayManager, bool> _fAimInvertVertical = AccessTools.FieldRefAccess<GameplayManager, bool>("aimInvertVertical");

			private static readonly FieldRef<CameraAim, float> _fAimHorizontal = AccessTools.FieldRefAccess<CameraAim, float>("aimHorizontal");

			private static readonly FieldRef<CameraAim, float> _fAimVertical = AccessTools.FieldRefAccess<CameraAim, float>("aimVertical");

			[HarmonyPrefix]
			private static void Prefix(CameraAim __instance)
			{
				//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_012b: Unknown result type (might be due to invalid IL or missing references)
				//IL_013d: Unknown result type (might be due to invalid IL or missing references)
				if (!IsStaticModEnabled() || !IsTumbleFlyEnabled())
				{
					return;
				}
				try
				{
					PlayerController instance = PlayerController.instance;
					PlayerTumble val = (((Object)(object)instance != (Object)null && (Object)(object)instance.playerAvatarScript != (Object)null) ? PlayerAvatarTumbleRef.Invoke(instance.playerAvatarScript) : null);
					if (!((Object)(object)val != (Object)null) || !PlayerTumbleIsTumblingRef.Invoke(val))
					{
						return;
					}
					Keyboard current = Keyboard.current;
					if (current == null || !((ButtonControl)current.qKey).isPressed)
					{
						return;
					}
					_fOverridePlayerAimDisableTimer.Invoke(__instance) = 0f;
					_fOverrideAimStopTimer.Invoke(__instance) = 0f;
					_fOverrideAimStop.Invoke(__instance) = false;
					if ((Object)(object)InputManager.instance != (Object)null)
					{
						_fDisableAimingTimer.Invoke(InputManager.instance) = 0f;
					}
					float num = SemiFunc.InputMouseX();
					float num2 = SemiFunc.InputMouseY();
					if (!(Mathf.Abs(num) < 0.0001f) || !(Mathf.Abs(num2) < 0.0001f))
					{
						return;
					}
					Mouse current2 = Mouse.current;
					if (current2 == null)
					{
						return;
					}
					Vector2 val2 = ((InputControl<Vector2>)(object)((Pointer)current2).delta).ReadValue();
					if (((Vector2)(ref val2)).sqrMagnitude > 0.0001f)
					{
						float aimSpeedMouse = __instance.AimSpeedMouse;
						float num3 = val2.x * 0.05f * aimSpeedMouse;
						float num4 = val2.y * 0.05f * aimSpeedMouse;
						if ((Object)(object)GameplayManager.instance != (Object)null && _fAimInvertVertical.Invoke(GameplayManager.instance))
						{
							num4 *= -1f;
						}
						ref float reference = ref _fAimHorizontal.Invoke(__instance);
						ref float reference2 = ref _fAimVertical.Invoke(__instance);
						reference += num3;
						if (reference > 360f)
						{
							reference -= 360f;
						}
						if (reference < -360f)
						{
							reference += 360f;
						}
						reference2 -= num4;
						reference2 = Mathf.Clamp(reference2, -70f, 80f);
					}
				}
				catch (Exception arg)
				{
					Plugin instance2 = Instance;
					if (instance2 != null)
					{
						((BaseUnityPlugin)instance2).Logger.LogWarning((object)$"[CameraAim.Update Prefix Error]: {arg}");
					}
				}
			}
		}

		[HarmonyPatch(typeof(PlayerAvatar), "ReviveRPC")]
		private class PlayerAvatar_ReviveRPC_Patch
		{
			[HarmonyPostfix]
			private static void Postfix(PlayerAvatar __instance)
			{
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: 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_005f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0040: 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_0077: Unknown result type (might be due to invalid IL or missing references)
				if (!IsStaticModEnabled() || !IsTeammateReviveDropBeadEnabled() || !SemiFunc.IsMasterClientOrSingleplayer())
				{
					return;
				}
				try
				{
					GameObject enemyValuableSmall = AssetManager.instance.enemyValuableSmall;
					if ((Object)(object)enemyValuableSmall != (Object)null)
					{
						Vector3 position = ((Component)__instance).transform.position;
						if (!SemiFunc.IsMultiplayer())
						{
							Object.Instantiate<GameObject>(enemyValuableSmall, position, Quaternion.identity);
						}
						else
						{
							PhotonNetwork.InstantiateRoomObject("Valuables/" + ((Object)enemyValuableSmall).name, position, Quaternion.identity, (byte)0, (object[])null);
						}
						LogInfo($"[GameTools] Player {((Object)__instance).name} revived. Dropped a small valuable shard at {position}.");
					}
				}
				catch (Exception arg)
				{
					LogWarning($"[TeammateReviveDropBead Error]: {arg}");
				}
			}
		}

		[HarmonyPatch(typeof(PlayerAvatar), "UpgradeTumbleWingsVisualsActive")]
		private class PlayerAvatar_UpgradeTumbleWingsVisualsActive_Patch
		{
			[HarmonyPrefix]
			private static bool Prefix(PlayerAvatar __instance, ref bool _visualsActive)
			{
				if (!IsStaticModEnabled())
				{
					return true;
				}
				try
				{
					if (IsWingsAlwaysShowEnabled() && PlayerAvatarIsLocalRef.Invoke(__instance) && !_visualsActive)
					{
						_visualsActive = true;
					}
				}
				catch (Exception arg)
				{
					Plugin instance = Instance;
					if (instance != null)
					{
						((BaseUnityPlugin)instance).Logger.LogWarning((object)$"[UpgradeTumbleWingsVisualsActive.Prefix Error]: {arg}");
					}
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(PlayerAvatar), "UpgradeTumbleWingsVisualsActiveRPC")]
		private class PlayerAvatar_UpgradeTumbleWingsVisualsActiveRPC_Patch
		{
			[HarmonyPrefix]
			private static void Prefix(PlayerAvatar __instance, ref bool _visualsActive)
			{
				if (!IsStaticModEnabled())
				{
					return;
				}
				try
				{
					object value;
					if (IsWingsAlwaysShowEnabled() && PlayerAvatarIsLocalRef.Invoke(__instance))
					{
						_visualsActive = true;
					}
					else if (!PlayerAvatarIsLocalRef.Invoke(__instance) && !_visualsActive && PhotonNetwork.InRoom && (Object)(object)__instance.photonView != (Object)null && __instance.photonView.Owner != null && ((Dictionary<object, object>)(object)__instance.photonView.Owner.CustomProperties).TryGetValue((object)"GT_WingsAlwaysShow", out value) && value is bool && (bool)value)
					{
						_visualsActive = true;
					}
				}
				catch (Exception arg)
				{
					Plugin instance = Instance;
					if (instance != null)
					{
						((BaseUnityPlugin)instance).Logger.LogWarning((object)$"[UpgradeTumbleWingsVisualsActiveRPC.Prefix Error]: {arg}");
					}
				}
			}
		}

		[HarmonyPatch(typeof(PlayerAvatar), "Update")]
		private class PlayerAvatar_Update_Patch
		{
			private static float _lastMultiCheckTime = 0f;

			private static bool _lastSentFlip = false;

			private static bool _lastSentSpinEnabled = false;

			private static int _lastSentSpinDirection = 0;

			private static int _lastSentSpinAxis = 0;

			private static float _lastSentSpinSpeed = -1f;

			private static bool _hasInitializedSentStates = false;

			private static readonly ConditionalWeakTable<PlayerAvatar, ItemUpgradePlayerTumbleWingsLogic> _wingsLogicCache = new ConditionalWeakTable<PlayerAvatar, ItemUpgradePlayerTumbleWingsLogic>();

			private static readonly FieldRef<PlayerHealth, Material> f_eyeMaterial = AccessTools.FieldRefAccess<PlayerHealth, Material>("eyeMaterial");

			private static readonly FieldRef<PlayerHealth, Material> f_pupilMaterial = AccessTools.FieldRefAccess<PlayerHealth, Material>("pupilMaterial");

			private static ItemUpgradePlayerTumbleWingsLogic GetWingsLogic(PlayerAvatar avatar)
			{
				if ((Object)(object)avatar == (Object)null)
				{
					return null;
				}
				if (!_wingsLogicCache.TryGetValue(avatar, out var value))
				{
					value = ((Component)avatar).GetComponentInChildren<ItemUpgradePlayerTumbleWingsLogic>(true);
					_wingsLogicCache.Add(avatar, value);
				}
				return value;
			}

			[HarmonyPostfix]
			private static void Postfix(PlayerAvatar __instance)
			{
				//IL_1c49: Unknown result type (might be due to invalid IL or missing references)
				//IL_1c50: Expected O, but got Unknown
				//IL_12d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_12da: Expected O, but got Unknown
				//IL_183c: Unknown result type (might be due to invalid IL or missing references)
				//IL_1843: Expected O, but got Unknown
				//IL_16e4: Unknown result type (might be due to invalid IL or missing references)
				//IL_16e9: Unknown result type (might be due to invalid IL or missing references)
				//IL_16eb: Unknown result type (might be due to invalid IL or missing references)
				//IL_16f0: Unknown result type (might be due to invalid IL or missing references)
				//IL_1713: Unknown result type (might be due to invalid IL or missing references)
				//IL_1715: Unknown result type (might be due to invalid IL or missing references)
				//IL_045f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0466: Expected O, but got Unknown
				//IL_1660: Unknown result type (might be due to invalid IL or missing references)
				//IL_1e56: Unknown result type (might be due to invalid IL or missing references)
				//IL_1e5e: Unknown result type (might be due to invalid IL or missing references)
				//IL_16b9: Unknown result type (might be due to invalid IL or missing references)
				//IL_17c9: Unknown result type (might be due to invalid IL or missing references)
				//IL_17a6: Unknown result type (might be due to invalid IL or missing references)
				//IL_17a8: Unknown result type (might be due to invalid IL or missing references)
				//IL_1765: Unknown result type (might be due to invalid IL or missing references)
				//IL_1767: Unknown result type (might be due to invalid IL or missing references)
				//IL_192c: Unknown result type (might be due to invalid IL or missing references)
				//IL_1931: Unknown result type (might be due to invalid IL or missing references)
				//IL_17e5: Unknown result type (might be due to invalid IL or missing references)
				//IL_19a3: Unknown result type (might be due to invalid IL or missing references)
				//IL_19a8: Unknown result type (might be due to invalid IL or missing references)
				if ((_cfgModEnabled == null || !_cfgModEnabled.Value) && !IsCosmeticsEnabled())
				{
					return;
				}
				if (PlayerAvatarIsLocalRef.Invoke(__instance))
				{
					UpdateLocalEyeTimer();
				}
				try
				{
					string text = PlayerAvatarSteamIDRef.Invoke(__instance);
					int value = 0;
					if ((Object)(object)StatsManager.instance != (Object)null && !string.IsNullOrEmpty(text))
					{
						StatsManager.instance.playerUpgradeTumbleWings.TryGetValue(text, out value);
					}
					if (PlayerAvatarIsLocalRef.Invoke(__instance))
					{
						bool flag = IsWingsAlwaysShowEnabled();
						if (flag)
						{
							int wingsColorIndex = GetWingsColorIndex();
							float num = ((wingsColorIndex == 1) ? 2f : 3f);
							int num2 = ((wingsColorIndex == 1) ? 2 : 3);
							if (PlayerAvatarUpgradeTumbleWingsRef.Invoke(__instance) != num)
							{
								PlayerAvatarUpgradeTumbleWingsRef.Invoke(__instance) = num;
							}
							bool flag2 = true;
							int num3 = 0;
							if (PhotonNetwork.InRoom && PhotonNetwork.LocalPlayer != null && ((Dictionary<object, object>)(object)PhotonNetwork.LocalPlayer.CustomProperties).TryGetValue((object)"GT_WingsColorIndex", out object value2))
							{
								num3 = SafeConvertToInt(value2);
							}
							bool flag3 = num3 != wingsColorIndex;
							if (PlayerAvatarUpgradeTumbleWingsVisualsActiveRef.Invoke(__instance) != flag2 || flag3)
							{
								__instance.UpgradeTumbleWingsVisualsActive(flag2, wingsColorIndex == 1);
								PlayerAvatarUpgradeTumbleWingsVisualsActiveRef.Invoke(__instance) = flag2;
							}
							ItemUpgradePlayerTumbleWingsLogic wingsLogic = GetWingsLogic(__instance);
							if ((Object)(object)wingsLogic != (Object)null && flag2)
							{
								if (TumbleWingTimerRef.Invoke(wingsLogic) < 1.15f)
								{
									TumbleWingTimerRef.Invoke(wingsLogic) = 1.15f;
								}
								switch (wingsColorIndex)
								{
								case 1:
									TumbleWingPinkTimerRef.Invoke(wingsLogic) = Mathf.Max(TumbleWingPinkTimerRef.Invoke(wingsLogic), 1.15f);
									if (!WingsIsPinkRef.Invoke(wingsLogic))
									{
										WingsIsPinkRef.Invoke(wingsLogic) = true;
										wingsLogic.WingsSetPinkColors();
									}
									break;
								case 2:
									if (WingsIsPinkRef.Invoke(wingsLogic) || TumbleWingPinkTimerRef.Invoke(wingsLogic) != 0f)
									{
										TumbleWingPinkTimerRef.Invoke(wingsLogic) = 0f;
										WingsIsPinkRef.Invoke(wingsLogic) = false;
										wingsLogic.WingsSetOriginalColors();
									}
									break;
								case 3:
								{
									float num4 = 5f;
									float wingsShowFrequency = GetWingsShowFrequency();
									if (wingsShowFrequency > 0.01f)
									{
										num4 = 1f / wingsShowFrequency;
									}
									if ((int)(Time.time * num4) % 2 == 0)
									{
										TumbleWingPinkTimerRef.Invoke(wingsLogic) = Mathf.Max(TumbleWingPinkTimerRef.Invoke(wingsLogic), 1.15f);
										if (!WingsIsPinkRef.Invoke(wingsLogic))
										{
											WingsIsPinkRef.Invoke(wingsLogic) = true;
											wingsLogic.WingsSetPinkColors();
										}
									}
									else if (WingsIsPinkRef.Invoke(wingsLogic) || TumbleWingPinkTimerRef.Invoke(wingsLogic) != 0f)
									{
										TumbleWingPinkTimerRef.Invoke(wingsLogic) = 0f;
										WingsIsPinkRef.Invoke(wingsLogic) = false;
										wingsLogic.WingsSetOriginalColors();
									}
									break;
								}
								}
							}
							if (PhotonNetwork.IsMasterClient && (Object)(object)StatsManager.instance != (Object)null && !string.IsNullOrEmpty(text))
							{
								int value3 = 0;
								StatsManager.instance.playerUpgradeTumbleWings.TryGetValue(text, out value3);
								if (value3 != num2)
								{
									if (!_originalWingsLevel.ContainsKey(text))
									{
										_originalWingsLevel[text] = value3;
									}
									StatsManager.instance.playerUpgradeTumbleWings[text] = num2;
									SemiFunc.StatSyncAll();
								}
							}
						}
						else
						{
							if (PlayerAvatarUpgradeTumbleWingsRef.Invoke(__instance) > (float)value)
							{
								PlayerAvatarUpgradeTumbleWingsRef.Invoke(__instance) = value;
								if (value <= 0)
								{
									__instance.UpgradeTumbleWingsVisualsActive(false, false);
									PlayerAvatarUpgradeTumbleWingsVisualsActiveRef.Invoke(__instance) = false;
								}
							}
							ItemUpgradePlayerTumbleWingsLogic wingsLogic2 = GetWingsLogic(__instance);
							if ((Object)(object)wingsLogic2 != (Object)null && (WingsIsPinkRef.Invoke(wingsLogic2) || TumbleWingPinkTimerRef.Invoke(wingsLogic2) != 0f))
							{
								TumbleWingPinkTimerRef.Invoke(wingsLogic2) = 0f;
								WingsIsPinkRef.Invoke(wingsLogic2) = false;
								wingsLogic2.WingsSetOriginalColors();
							}
							if (PhotonNetwork.IsMasterClient && (Object)(object)StatsManager.instance != (Object)null && !string.IsNullOrEmpty(text) && _originalWingsLevel.TryGetValue(text, out var value4))
							{
								StatsManager.instance.playerUpgradeTumbleWings[text] = value4;
								_originalWingsLevel.Remove(text);
								SemiFunc.StatSyncAll();
							}
						}
						if (PhotonNetwork.InRoom && PhotonNetwork.LocalPlayer != null)
						{
							Hashtable val = new Hashtable();
							bool flag4 = false;
							bool flag5 = false;
							if (((Dictionary<object, object>)(object)PhotonNetwork.LocalPlayer.CustomProperties).TryGetValue((object)"GT_WingsAlwaysShow", out object value5) && value5 is bool)
							{
								flag5 = (bool)value5;
							}
							if (flag5 != flag)
							{
								val[(object)"GT_WingsAlwaysShow"] = flag;
								flag4 = true;
							}
							int num5 = 0;
							if (((Dictionary<object, object>)(object)PhotonNetwork.LocalPlayer.CustomProperties).TryGetValue((object)"GT_WingsColorIndex", out object value6))
							{
								num5 = SafeConvertToInt(value6);
							}
							int wingsColorIndex2 = GetWingsColorIndex();
							if (num5 != wingsColorIndex2)
							{
								val[(object)"GT_WingsColorIndex"] = wingsColorIndex2;
								flag4 = true;
							}
							if (!_hasInitializedSentStates)
							{
								_hasInitializedSentStates = true;
								if (((Dictionary<object, object>)(object)PhotonNetwork.LocalPlayer.CustomProperties).TryGetValue((object)"GT_Flip", out object value7) && value7 is bool)
								{
									_lastSentFlip = (bool)value7;
								}
								if (((Dictionary<object, object>)(object)PhotonNetwork.LocalPlayer.CustomProperties).TryGetValue((object)"GT_SpinEnabled", out object value8) && value8 is bool)
								{
									_lastSentSpinEnabled = (bool)value8;
								}
								if (((Dictionary<object, object>)(object)PhotonNetwork.LocalPlayer.CustomProperties).TryGetValue((object)"GT_SpinDirection", out object value9))
								{
									_lastSentSpinDirection = SafeConvertToInt(value9);
								}
								if (((Dictionary<object, object>)(object)PhotonNetwork.LocalPlayer.CustomProperties).TryGetValue((object)"GT_SpinAxis", out object value10))
								{
									_lastSentSpinAxis = SafeConvertToInt(value10);
								}
								if (((Dictionary<object, object>)(object)PhotonNetwork.LocalPlayer.CustomProperties).TryGetValue((object)"GT_SpinSpeed", out object value11))
								{
									_lastSentSpinSpeed = SafeConvertToFloat(value11, 1f);
								}
							}
							bool flag6 = IsFlipEnabled();
							if (_lastSentFlip != flag6)
							{
								val[(object)"GT_Flip"] = flag6;
								_lastSentFlip = flag6;
								flag4 = true;
							}
							bool flag7 = IsSpinEnabled();
							if (_lastSentSpinEnabled != flag7)
							{
								val[(object)"GT_SpinEnabled"] = flag7;
								_lastSentSpinEnabled = flag7;
								flag4 = true;
							}
							int num6 = ((_cfgSpinDirection == null) ? 1 : _cfgSpinDirection.Value);
							if (_lastSentSpinDirection != num6)
							{
								val[(object)"GT_SpinDirection"] = num6;
								_lastSentSpinDirection = num6;
								flag4 = true;
							}
							int num7 = ((_cfgSpinAxis == null) ? 1 : _cfgSpinAxis.Value);
							if (_lastSentSpinAxis != num7)
							{
								val[(object)"GT_SpinAxis"] = num7;
								_lastSentSpinAxis = num7;
								flag4 = true;
							}
							float spinSpeed = GetSpinSpeed();
							if (Mathf.Abs(_lastSentSpinSpeed - spinSpeed) > 0.01f)
							{
								val[(object)"GT_SpinSpeed"] = spinSpeed;
								_lastSentSpinSpeed = spinSpeed;
								flag4 = true;
							}
							if (flag4)
							{
								PhotonNetwork.LocalPlayer.SetCustomProperties(val, (Hashtable)null, (WebFlags)null);
							}
						}
					}
					else
					{
						bool flag8 = false;
						int num8 = 0;
						if (PhotonNetwork.InRoom && (Object)(object)__instance.photonView != (Object)null && __instance.photonView.Owner != null)
						{
							Player owner = __instance.photonView.Owner;
							if (((Dictionary<object, object>)(object)owner.CustomProperties).TryGetValue((object)"GT_WingsAlwaysShow", out object value12) && value12 is bool)
							{
								flag8 = (bool)value12;
							}
							if (((Dictionary<object, object>)(object)owner.CustomProperties).TryGetValue((object)"GT_WingsColorIndex", out object value13))
							{
								num8 = SafeConvertToInt(value13);
							}
						}
						else
						{
							flag8 = false;
							num8 = 0;
						}
						if (flag8 && _cfgModEnabled != null && _cfgModEnabled.Value)
						{
							float num9 = ((num8 == 1) ? 2f : 3f);
							int num10 = ((num8 == 1) ? 2 : 3);
							if (PlayerAvatarUpgradeTumbleWingsRef.Invoke(__instance) != num9)
							{
								PlayerAvatarUpgradeTumbleWingsRef.Invoke(__instance) = num9;
							}
							bool flag9 = true;
							if (PlayerAvatarUpgradeTumbleWingsVisualsActiveRef.Invoke(__instance) != flag9)
							{
								__instance.UpgradeTumbleWingsVisualsActive(flag9, num8 == 1);
								PlayerAvatarUpgradeTumbleWingsVisualsActiveRef.Invoke(__instance) = flag9;
							}
							ItemUpgradePlayerTumbleWingsLogic wingsLogic3 = GetWingsLogic(__instance);
							if ((Object)(object)wingsLogic3 != (Object)null && flag9)
							{
								if (TumbleWingTimerRef.Invoke(wingsLogic3) < 1.15f)
								{
									TumbleWingTimerRef.Invoke(wingsLogic3) = 1.15f;
								}
								switch (num8)
								{
								case 1:
									TumbleWingPinkTimerRef.Invoke(wingsLogic3) = Mathf.Max(TumbleWingPinkTimerRef.Invoke(wingsLogic3), 1.15f);
									if (!WingsIsPinkRef.Invoke(wingsLogic3))
									{
										WingsIsPinkRef.Invoke(wingsLogic3) = true;
										wingsLogic3.WingsSetPinkColors();
									}
									break;
								case 2:
									if (WingsIsPinkRef.Invoke(wingsLogic3) || TumbleWingPinkTimerRef.Invoke(wingsLogic3) != 0f)
									{
										TumbleWingPinkTimerRef.Invoke(wingsLogic3) = 0f;
										WingsIsPinkRef.Invoke(wingsLogic3) = false;
										wingsLogic3.WingsSetOriginalColors();
									}
									break;
								case 3:
								{
									float num11 = 5f;
									float wingsShowFrequency2 = GetWingsShowFrequency();
									if (wingsShowFrequency2 > 0.01f)
									{
										num11 = 1f / wingsShowFrequency2;
									}
									if ((int)(Time.time * num11) % 2 == 0)
									{
										TumbleWingPinkTimerRef.Invoke(wingsLogic3) = Mathf.Max(TumbleWingPinkTimerRef.Invoke(wingsLogic3), 1.15f);
										if (!WingsIsPinkRef.Invoke(wingsLogic3))
										{
											WingsIsPinkRef.Invoke(wingsLogic3) = true;
											wingsLogic3.WingsSetPinkColors();
										}
									}
									else if (WingsIsPinkRef.Invoke(wingsLogic3) || TumbleWingPinkTimerRef.Invoke(wingsLogic3) != 0f)
									{
										TumbleWingPinkTimerRef.Invoke(wingsLogic3) = 0f;
										WingsIsPinkRef.Invoke(wingsLogic3) = false;
										wingsLogic3.WingsSetOriginalColors();
									}
									break;
								}
								}
							}
							if (PhotonNetwork.IsMasterClient && (Object)(object)StatsManager.instance != (Object)null && !string.IsNullOrEmpty(text))
							{
								int value14 = 0;
								StatsManager.instance.playerUpgradeTumbleWings.TryGetValue(text, out value14);
								if (value14 != num10)
								{
									if (!_originalWingsLevel.ContainsKey(text))
									{
										_originalWingsLevel[text] = value14;
									}
									StatsManager.instance.playerUpgradeTumbleWings[text] = num10;
									SemiFunc.StatSyncAll();
								}
							}
						}
						else
						{
							if (PlayerAvatarUpgradeTumbleWingsRef.Invoke(__instance) > (float)value)
							{
								PlayerAvatarUpgradeTumbleWingsRef.Invoke(__instance) = value;
								if (value <= 0)
								{
									PlayerAvatarUpgradeTumbleWingsVisualsActiveRef.Invoke(__instance) = false;
								}
							}
							ItemUpgradePlayerTumbleWingsLogic wingsLogic4 = GetWingsLogic(__instance);
							if ((Object)(object)wingsLogic4 != (Object)null && (WingsIsPinkRef.Invoke(wingsLogic4) || TumbleWingPinkTimerRef.Invoke(wingsLogic4) != 0f))
							{
								TumbleWingPinkTimerRef.Invoke(wingsLogic4) = 0f;
								WingsIsPinkRef.Invoke(wingsLogic4) = false;
								wingsLogic4.WingsSetOriginalColors();
							}
							if (PhotonNetwork.IsMasterClient && (Object)(object)StatsManager.instance != (Object)null && !string.IsNullOrEmpty(text) && _originalWingsLevel.TryGetValue(text, out var value15))
							{
								StatsManager.instance.playerUpgradeTumbleWings[text] = value15;
								_originalWingsLevel.Remove(text);
								SemiFunc.StatSyncAll();
							}
						}
					}
					if (PhotonNetwork.InRoom && Time.time - _lastMultiCheckTime >= 0.1f)
					{
						_lastMultiCheckTime = Time.time;
						string text2 = PlayerAvatarSteamIDRef.Invoke(__instance);
						string text3 = (((Object)(object)__instance.photonView != (Object)null && __instance.photonView.Owner != null) ? __instance.photonView.Owner.ActorNumber.ToString() : "");
						bool flag10 = PlayerAvatarDeadSetRef.Invoke(__instance);
						if (PlayerAvatarIsLocalRef.Invoke(__instance))
						{
							string text4 = ((PhotonNetwork.LocalPlayer != null) ? PhotonNetwork.LocalPlayer.ActorNumber.ToString() : "");
							if (flag10)
							{
								string key = "GT_ReqRevive_" + text4;
								string key2 = "GT_ReqRevive_" + text2;
								bool flag11 = false;
								Player[] playerList = PhotonNetwork.PlayerList;
								foreach (Player val2 in playerList)
								{
									if (val2 != null)
									{
										if (!string.IsNullOrEmpty(text4) && ((Dictionary<object, object>)(object)val2.CustomProperties).TryGetValue((object)key, out object value16) && SafeConvertToInt(value16) != 0)
										{
											flag11 = true;
											break;
										}
										if (!string.IsNullOrEmpty(text2) && ((Dictionary<object, object>)(object)val2.CustomProperties).TryGetValue((object)key2, out object value17) && SafeConvertToInt(value17) != 0)
										{
											flag11 = true;
											break;
										}
									}
								}
								if (flag11)
								{
									try
									{
										__instance.Revive(false);
										Plugin instance = Instance;
										if (instance != null)
										{
											((BaseUnityPlugin)instance).Logger.LogInfo((object)("[GameTools] Self-revived by remote request: " + text4 + " / " + text2));
										}
									}
									catch (Exception arg)
									{
										Plugin instance2 = Instance;
										if (instance2 != null)
										{
											((BaseUnityPlugin)instance2).Logger.LogWarning((object)$"[Self Revive Error]: {arg}");
										}
									}
								}
							}
							else
							{
								string key3 = "GT_ReqKill_" + text4;
								string key4 = "GT_ReqKill_" + text2;
								bool flag12 = false;
								Player[] playerList = PhotonNetwork.PlayerList;
								foreach (Player val3 in playerList)
								{
									if (val3 != null)
									{
										if (!string.IsNullOrEmpty(text4) && ((Dictionary<object, object>)(object)val3.CustomProperties).TryGetValue((object)key3, out object value18) && SafeConvertToInt(value18) != 0)
										{
											flag12 = true;
											break;
										}
										if (!string.IsNullOrEmpty(text2) && ((Dictionary<object, object>)(object)val3.CustomProperties).TryGetValue((object)key4, out object value19) && SafeConvertToInt(value19) != 0)
										{
											flag12 = true;
											break;
										}
									}
								}
								if (flag12)
								{
									try
									{
										__instance.PlayerDeath(-1);
										Plugin instance3 = Instance;
										if (instance3 != null)
										{
											((BaseUnityPlugin)instance3).Logger.LogInfo((object)("[GameTools] Self-killed by remote request: " + text4 + " / " + text2));
										}
									}
									catch (Exception arg2)
									{
										Plugin instance4 = Instance;
										if (instance4 != null)
										{
											((BaseUnityPlugin)instance4).Logger.LogWarning((object)$"[Self Kill Error]: {arg2}");
										}
									}
								}
							}
							if (!flag10 && (Object)(object)__instance.playerHealth != (Object)null)
							{
								string key5 = "GT_ReqHeal_" + text4;
								string key6 = "GT_ReqHeal_" + text2;
								bool flag13 = false;
								Player[] playerList = PhotonNetwork.PlayerList;
								foreach (Player val4 in playerList)
								{
									if (val4 != null)
									{
										if (!string.IsNullOrEmpty(text4) && ((Dictionary<object, object>)(object)val4.CustomProperties).TryGetValue((object)key5, out object value20) && SafeConvertToInt(value20) != 0)
										{
											flag13 = true;
											break;
										}
										if (!string.IsNullOrEmpty(text2) && ((Dictionary<object, object>)(object)val4.CustomProperties).TryGetValue((object)key6, out object value21) && SafeConvertToInt(value21) != 0)
										{
											flag13 = true;
											break;
										}
									}
								}
								if (flag13)
								{
									try
									{
										int num12 = PlayerHealthMaxRef.Invoke(__instance.playerHealth);
										__instance.playerHealth.Heal(num12, true);
										Plugin instance5 = Instance;
										if (instance5 != null)
										{
											((BaseUnityPlugin)instance5).Logger.LogInfo((object)("[GameTools] Self-healed by remote request: " + text4 + " / " + text2));
										}
									}
									catch (Exception arg3)
									{
										Plugin instance6 = Instance;
										if (instance6 != null)
										{
											((BaseUnityPlugin)instance6).Logger.LogWarning((object)$"[Self Heal Error]: {arg3}");
										}
									}
								}
							}
						}
						if (IsTab1Enabled() && PhotonNetwork.IsMasterClient && (!string.IsNullOrEmpty(text2) || !string.IsNullOrEmpty(text3)))
						{
							if (flag10)
							{
								string key7 = "GT_ReqRevive_" + text3;
								string key8 = "GT_ReqRevive_" + text2;
								bool flag14 = false;
								Player[] playerList = PhotonNetwork.PlayerList;
								foreach (Player val5 in playerList)
								{
									if (val5 != null)
									{
										if (!string.IsNullOrEmpty(text3) && ((Dictionary<object, object>)(object)val5.CustomProperties).TryGetValue((object)key7, out object value22) && SafeConvertToInt(value22) != 0)
										{
											flag14 = true;
											break;
										}
										if (!string.IsNullOrEmpty(text2) && ((Dictionary<object, object>)(object)val5.CustomProperties).TryGetValue((object)key8, out object value23) && SafeConvertToInt(value23) != 0)
										{
											flag14 = true;
											break;
										}
									}
								}
								if (flag14 && (Object)(object)__instance.photonView != (Object)null)
								{
									try
									{
										__instance.photonView.RPC("ReviveRPC", (RpcTarget)0, new object[1] { false });
										Plugin instance7 = Instance;
										if (instance7 != null)
										{
											((BaseUnityPlugin)instance7).Logger.LogInfo((object)("[GameTools] Host proxy-revived vanilla player: " + text3 + " / " + text2));
										}
									}
									catch (Exception arg4)
									{
										Plugin instance8 = Instance;
										if (instance8 != null)
										{
											((BaseUnityPlugin)instance8).Logger.LogWarning((object)$"[Host Proxy Revive Error]: {arg4}");
										}
									}
								}
							}
							else
							{
								string key9 = "GT_ReqKill_" + text3;
								string key10 = "GT_ReqKill_" + text2;
								bool flag15 = false;
								Player[] playerList = PhotonNetwork.PlayerList;
								foreach (Player val6 in playerList)
								{
									if (val6 != null)
									{
										if (!string.IsNullOrEmpty(text3) && ((Dictionary<object, object>)(object)val6.CustomProperties).TryGetValue((object)key9, out object value24) && SafeConvertToInt(value24) != 0)
										{
											flag15 = true;
											break;
										}
										if (!string.IsNullOrEmpty(text2) && ((Dictionary<object, object>)(object)val6.CustomProperties).TryGetValue((object)key10, out object value25) && SafeConvertToInt(value25) != 0)
										{
											flag15 = true;
											break;
										}
									}
								}
								if (flag15 && (Object)(object)__instance.photonView != (Object)null)
								{
									try
									{
										__instance.photonView.RPC("PlayerDeathRPC", (RpcTarget)0, new object[1] { -1 });
										Plugin instance9 = Instance;
										if (instance9 != null)
										{
											((BaseUnityPlugin)instance9).Logger.LogInfo((object)("[GameTools] Host proxy-killed vanilla player: " + text3 + " / " + text2));
										}
									}
									catch (Exception arg5)
									{
										Plugin instance10 = Instance;
										if (instance10 != null)
										{
											((BaseUnityPlugin)instance10).Logger.LogWarning((object)$"[Host Proxy Kill Error]: {arg5}");
										}
									}
								}
							}
							if (!flag10 && (Object)(object)__instance.playerHealth != (Object)null)
							{
								string key11 = "GT_ReqHeal_" + text3;
								string key12 = "GT_ReqHeal_" + text2;
								bool flag16 = false;
								Player[] playerList = PhotonNetwork.PlayerList;
								foreach (Player val7 in playerList)
								{
									if (val7 != null)
									{
										if (!string.IsNullOrEmpty(text3) && ((Dictionary<object, object>)(object)val7.CustomProperties).TryGetValue((object)key11, out object value26) && SafeConvertToInt(value26) != 0)
										{
											flag16 = true;
											break;
										}
										if (!string.IsNullOrEmpty(text2) && ((Dictionary<object, object>)(object)val7.CustomProperties).TryGetValue((object)key12, out object value27) && SafeConvertToInt(value27) != 0)
										{
											flag16 = true;
											break;
										}
									}
								}
								if (flag16 && (Object)(object)__instance.photonView != (Object)null)
								{
									try
									{
										int num13 = PlayerHealthMaxRef.Invoke(__instance.playerHealth);
										__instance.photonView.RPC("UpdateHealthRPC", (RpcTarget)0, new object[4] { num13, num13, true, false });
										Plugin instance11 = Instance;
										if (instance11 != null)
										{
											((BaseUnityPlugin)instance11).Logger.LogInfo((object)("[GameTools] Host proxy-healed vanilla player: " + text3 + " / " + text2));
										}
									}
									catch (Exception arg6)
									{
										Plugin instance12 = Instance;
										if (instance12 != null)
										{
											((BaseUnityPlugin)instance12).Logger.LogWarning((object)$"[Host Proxy Heal Error]: {arg6}");
										}
									}
								}
							}
						}
						if (PlayerAvatarIsLocalRef.Invoke(__instance))
						{
							List<PlayerAvatar> list = SemiFunc.PlayerGetList();
							if (list != null)
							{
								Hashtable val8 = new Hashtable();
								bool flag17 = false;
								foreach (PlayerAvatar item in list)
								{
									if ((Object)(object)item == (Object)null)
									{
										continue;
									}
									string text5 = PlayerAvatarSteamIDRef.Invoke(item);
									string text6 = (((Object)(object)item.photonView != (Object)null && item.photonView.Owner != null) ? item.photonView.Owner.ActorNumber.ToString() : "");
									bool num14 = PlayerAvatarDeadSetRef.Invoke(item);
									if (!num14)
									{
										string text7 = "GT_ReqRevive_" + text6;
										string text8 = "GT_ReqRevive_" + text5;
										if (!string.IsNullOrEmpty(text6) && ((Dictionary<object, object>)(object)PhotonNetwork.LocalPlayer.CustomProperties).TryGetValue((object)text7, out object value28) && SafeConvertToInt(value28) != 0)
										{
											val8[(object)text7] = null;
											flag17 = true;
										}
										if (!string.IsNullOrEmpty(text5) && ((Dictionary<object, object>)(object)PhotonNetwork.LocalPlayer.CustomProperties).TryGetValue((object)text8, out object value29) && SafeConvertToInt(value29) != 0)
										{
											val8[(object)text8] = null;
											flag17 = true;
										}
									}
									else
									{
										string text9 = "GT_ReqKill_" + text6;
										string text10 = "GT_ReqKill_" + text5;
										if (!string.IsNullOrEmpty(text6) && ((Dictionary<object, object>)(object)PhotonNetwork.LocalPlayer.CustomProperties).TryGetValue((object)text9, out object value30) && SafeConvertToInt(value30) != 0)
										{
											val8[(object)text9] = null;
											flag17 = true;
										}
										if (!string.IsNullOrEmpty(text5) && ((Dictionary<object, object>)(object)PhotonNetwork.LocalPlayer.CustomProperties).TryGetValue((object)text10, out object value31) && SafeConvertToInt(value31) != 0)
										{
											val8[(object)text10] = null;
											flag17 = true;
										}
									}
									if (num14 || !((Object)(object)item.playerHealth != (Object)null))
									{
										continue;
									}
									int num15 = PlayerHealthCurrentRef.Invoke(item.playerHealth);
									int num16 = PlayerHealthMaxRef.Invoke(item.playerHealth);
									if (num15 >= num16)
									{
										string text11 = "GT_ReqHeal_" + text6;
										string text12 = "GT_ReqHeal_" + text5;
										if (!string.IsNullOrEmpty(text6) && ((Dictionary<object, object>)(object)PhotonNetwork.LocalPlayer.CustomProperties).TryGetValue((object)text11, out object value32) && SafeConvertToInt(value32) != 0)
										{
											val8[(object)text11] = null;
											flag17 = true;
										}
										if (!string.IsNullOrEmpty(text5) && ((Dictionary<object, object>)(object)PhotonNetwork.LocalPlayer.CustomProperties).TryGetValue((object)text12, out object value33) && SafeConvertToInt(value33) != 0)
										{
											val8[(object)text12] = null;
											flag17 = true;
										}
									}
								}
								if (flag17)
								{
									PhotonNetwork.LocalPlayer.SetCustomProperties(val8, (Hashtable)null, (WebFlags)null);
									Plugin instance13 = Instance;
									if (instance13 != null)
									{
										((BaseUnityPlugin)instance13).Logger.LogInfo((object)"[GameTools] Cleared resolved player control requests.");
									}
								}
							}
						}
						if (PlayerAvatarIsLocalRef.Invoke(__instance))
						{
							string text13 = PlayerAvatarSteamIDRef.Invoke(__instance);
							string text14 = ((PhotonNetwork.LocalPlayer != null) ? PhotonNetwork.LocalPlayer.ActorNumber.ToString() : "");
							string key13 = "GT_ReqTeleport_" + text14;
							string key14 = "GT_ReqTeleport_" + text13;
							Vector3? val9 = null;
							Player[] playerList = PhotonNetwork.PlayerList;
							foreach (Player val10 in playerList)
							{
								if (val10 != null)
								{
									if (!string.IsNullOrEmpty(text14) && ((Dictionary<object, object>)(object)val10.CustomProperties).TryGetValue((object)key13, out object value34) && value34 is float[] && ((float[])value34).Length == 3)
									{
										val9 = new Vector3(((float[])value34)[0], ((float[])value34)[1], ((float[])value34)[2]);
										break;
									}
									if (!string.IsNullOrEmpty(text13) && ((Dictionary<object, object>)(object)val10.CustomProperties).TryGetValue((object)key14, out object value35) && value35 is float[] && ((float[])value35).Length == 3)
									{
										val9 = new Vector3(((float[])value35)[0], ((float[])value35)[1], ((float[])value35)[2]);
										break;
									}
								}
							}
							if (val9.HasValue)
							{
								Vector3 value36 = val9.Value;
								if (Vector3.Distance(_lastRemoteTpPos, value36) > 0.5f || Time.time - _lastRemoteTpTime > 1f)
								{
									_lastRemoteTpPos = value36;
									_lastRemoteTpTime = Time.time;
									try
									{
										if (PlayerAvatarDeadSetRef.Invoke(__instance))
										{
											PlayerDeathHead val11 = PlayerAvatarPlayerDeathHeadRef.Invoke(__instance);
											if ((Object)(object)val11 != (Object)null)
											{
												PhysGrabObject val12 = PlayerDeathHeadPhysGrabObjectRef.Invoke(val11);
												if ((Object)(object)val12 != (Object)null)
												{
													val12.Teleport(value36, Quaternion.identity);
												}
											}
										}
										else
										{
											PlayerTumble val13 = PlayerAvatarTumbleRef.Invoke(__instance);
											if ((Object)(object)val13 != (Object)null)
											{
												PhysGrabObject val14 = PlayerTumblePhysGrabObjectRef.Invoke(val13);
												if ((Object)(object)val14 != (Object)null)
												{
													val14.Teleport(value36, Quaternion.identity);
												}
											}
										}
										if ((Object)(object)PlayerController.instance != (Object)null)
										{
											((Component)PlayerController.instance).transform.position = value36;
										}
										Plugin instance14 = Instance;
										if (instance14 != null)
										{
											((BaseUnityPlugin)instance14).Logger.LogInfo((object)$"[GameTools] Teleported self locally by remote request to {value36}");
										}
									}
									catch (Exception arg7)
									{
										Plugin instance15 = Instance;
										if (instance15 != null)
										{
											((BaseUnityPlugin)instance15).Logger.LogWarning((object)$"[Self Teleport By Remote Error]: {arg7}");
										}
									}
								}
							}
						}
						if (PlayerAvatarIsLocalRef.Invoke(__instance))
						{
							List<PlayerAvatar> list2 = SemiFunc.PlayerGetList();
							if (list2 != null)
							{
								Hashtable val15 = new Hashtable();
								bool flag18 = false;
								Vector3 val16 = default(Vector3);
								Vector3 val17 = default(Vector3);
								foreach (PlayerAvatar item2 in list2)
								{
									if ((Object)(object)item2 == (Object)null)
									{
										continue;
									}
									string text15 = PlayerAvatarSteamIDRef.Invoke(item2);
									string text16 = (((Object)(object)item2.photonView != (Object)null && item2.photonView.Owner != null) ? item2.photonView.Owner.ActorNumber.ToString() : "");
									string text17 = "GT_ReqTeleport_" + text16;
									string text18 = "GT_ReqTeleport_" + text15;
									if (!string.IsNullOrEmpty(text16) && ((Dictionary<object, object>)(object)PhotonNetwork.LocalPlayer.CustomProperties).TryGetValue((object)text17, out object value37) && value37 is float[] && ((float[])value37).Length == 3)
									{
										((Vector3)(ref val16))..ctor(((float[])value37)[0], ((float[])value37)[1], ((float[])value37)[2]);
										if (Vector3.Distance(GetPlayerPosition(item2), val16) < 3f)
										{
											val15[(object)text17] = null;
											flag18 = true;
										}
									}
									if (!string.IsNullOrEmpty(text15) && ((Dictionary<object, object>)(object)PhotonNetwork.LocalPlayer.CustomProperties).TryGetValue((object)text18, out object value38) && value38 is float[] && ((float[])value38).Length == 3)
									{
										((Vector3)(ref val17))..ctor(((float[])value38)[0], ((float[])value38)[1], ((float[])value38)[2]);
										if (Vector3.Distance(GetPlayerPosition(item2), val17) < 3f)
										{
											val15[(object)text18] = null;
											flag18 = true;
										}
									}
								}
								if (flag18)
								{
									PhotonNetwork.LocalPlayer.SetCustomProperties(val15, (Hashtable)null, (WebFlags)null);
									Plugin instance16 = Instance;
									if (instance16 != null)
									{
										((BaseUnityPlugin)instance16).Logger.LogInfo((object)"[GameTools] Cleared resolved teleport requests.");
									}
								}
							}
						}
					}
				}
				catch (Exception arg8)
				{
					Plugin instance17 = Instance;
					if (instance17 != null)
					{
						((BaseUnityPlugin)instance17).Logger.LogWarning((object)$"[PlayerAvatar.Update.Postfix Error]: {arg8}");
					}
				}
				try
				{
					bool flag19 = false;
					bool flag20 = false;
					float num17 = 1f;
					if (PhotonNetwork.InRoom && (Object)(object)__instance.photonView != (Object)null && __instance.photonView.Owner != null)
					{
						Hashtable customProperties = __instance.photonView.Owner.CustomProperties;
						if (((Dictionary<object, object>)(object)customProperties).TryGetValue((object)"GT_EyeBigPupil", out object value39) && value39 is bool)
						{
							flag19 = (bool)value39;
						}
						if (((Dictionary<object, object>)(object)customProperties).TryGetValue((object)"GT_EyeBigPupilAuto", out object value40) && value40 is bool)
						{
							flag20 = (bool)value40;
						}
						if (((Dictionary<object, object>)(object)customProperties).TryGetValue((object)"GT_EyeBigPupilSpeed", out object value41))
						{
							try
							{
								num17 = Convert.ToSingle(value41);
							}
							catch
							{
							}
						}
					}
					else if (PlayerAvatarIsLocalRef.Invoke(__instance))
					{
						flag19 = IsCosmeticsEnabled() && _cfgEyeBigPupil != null && _cfgEyeBigPupil.Value;
						flag20 = IsCosmeticsEnabled() && _cfgEyePupilScaleAuto != null && _cfgEyePupilScaleAuto.Value;
						num17 = ((_cfgEyePupilScaleSpeed != null) ? _cfgEyePupilScaleSpeed.Value : 1f);
					}
					if (PlayerAvatarIsLocalRef.Invoke(__instance) && PhotonNetwork.InRoom && PhotonNetwork.LocalPlayer != null)
					{
						bool flag21 = IsCosmeticsEnabled() && _cfgEyeBigPupil != null && _cfgEyeBigPupil.Value;
						bool flag22 = IsCosmeticsEnabled() && _cfgEyePupilScaleAuto != null && _cfgEyePupilScaleAuto.Value;
						float num18 = ((_cfgEyePupilScaleSpeed != null) ? _cfgEyePupilScaleSpeed.Value : 1f);
						bool flag23 = false;
						bool flag24 = false;
						float num19 = 1f;
						Hashtable customProperties2 = PhotonNetwork.LocalPlayer.CustomProperties;
						if (((Dictionary<object, object>)(object)customProperties2).TryGetValue((object)"GT_EyeBigPupil", out object value42) && value42 is bool flag25)
						{
							flag23 = flag25;
						}
						if (((Dictionary<object, object>)(object)customProperties2).TryGetValue((object)"GT_EyeBigPupilAuto", out object value43) && value43 is bool flag26)
						{
							flag24 = flag26;
						}
						if (((Dictionary<object, object>)(object)customProperties2).TryGetValue((object)"GT_EyeBigPupilSpeed", out object value44))
						{
							try
							{
								num19 = Convert.ToSingle(value44);
							}
							catch
							{
							}
						}
						if (flag23 != flag21 || flag24 != flag22 || Mathf.Abs(num19 - num18) > 0.05f)
						{
							Hashtable val18 = new Hashtable();
							val18[(object)"GT_EyeBigPupil"] = flag21;
							val18[(object)"GT_EyeBigPupilAuto"] = flag22;
							val18[(object)"GT_EyeBigPupilSpeed"] = num18;
							PhotonNetwork.LocalPlayer.SetCustomProperties(val18, (Hashtable)null, (WebFlags)null);
						}
					}
					if (_cfgModEnabled != null && _cfgModEnabled.Value && flag19)
					{
						float num20 = 3f;
						if (flag20)
						{
							double num21 = (PhotonNetwork.InRoom ? PhotonNetwork.Time : ((double)Time.time));
							num20 = 2f + 1.2f * Mathf.Sin((float)(num21 * (double)num17 * 3.0));
						}
						__instance.OverridePupilSize(num20, 4, 1f, 1f, 5f, 0.5f, 0.5f);
					}
					int num22 = 0;
					if (PhotonNetwork.InRoom && (Object)(object)__instance.photonView != (Object)null && __instance.photonView.Owner != null)
					{
						if (((Dictionary<object, object>)(object)__instance.photonView.Owner.CustomProperties).TryGetValue((object)"GT_EyeEffect", out object value45))
						{
							num22 = SafeConvertToInt(value45);
						}
					}
					else if (PlayerAvatarIsLocalRef.Invoke(__instance) && IsCosmeticsEnabled() && _cfgEyeEffectEnabled != null && _cfgEyeEffectEnabled.Value)
					{
						num22 = CurrentEyeColor;
					}
					if (_cfgModEnabled == null || !_cfgModEnabled.Value)
					{
						return;
					}
					switch (num22)
					{
					case 2:
						if ((Object)(object)__instance.playerHealth != (Object)null)
						{
							__instance.playerHealth.EyeMaterialOverride((EyeOverrideState)1, 0.5f, 999);
						}
						break;
					case 3:
						if ((Object)(object)__instance.playerHealth != (Object)null)
						{
							__instance.playerHealth.EyeMaterialOverride((EyeOverrideState)2, 0.5f, 999);
						}
						break;
					case 4:
						if ((Object)(object)__instance.playerHealth != (Object)null)
						{
							EyeOverrideState val19 = (EyeOverrideState)(((int)(Time.time * 2f) % 2 == 0) ? 1 : 2);
							__instance.playerHealth.EyeMaterialOverride(val19, 0.5f, 999);
						}
						break;
					case 5:
						if ((Object)(object)__instance.playerHealth != (Object)null)
						{
							__instance.playerHealth.EyeMaterialOverride((EyeOverrideState)3, 0.5f, 999);
						}
						break;
					case 6:
						if ((Object)(object)__instance.playerHealth != (Object)null)
						{
							__instance.playerHealth.EyeMaterialOverride((EyeOverrideState)4, 0.5f, 999);
						}
						break;
					case 7:
						if ((Object)(object)__instance.playerHealth != (Object)null)
						{
							__instance.playerHealth.EyeMaterialOverride((EyeOverrideState)5, 0.5f, 999);
						}
						break;
					}
				}
				catch (Exception arg9)
				{
					Plugin instance18 = Instance;
					if (instance18 != null)
					{
						((BaseUnityPlugin)instance18).Logger.LogWarning((object)$"[PlayerAvatar.Update.EyeEffect Error]: {arg9}");
					}
				}
			}
		}

		[HarmonyPatch(typeof(PlayerController), "Update")]
		private class PlayerController_Update_Patch
		{
			private static float _originalJumpForce = -1f;

			private static bool _prevGodModeFlightEnabled = false;

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

			private static readonly FieldRef<PlayerAvatar, PlayerTumble> _fTumble = AccessTools.FieldRefAccess<PlayerAvatar, PlayerTumble>("tumble");

			[HarmonyPostfix]
			private static void Postfix(PlayerController __instance)
			{
				bool flag = IsStaticModEnabled() && IsJumpMultiplierEnabled();
				try
				{
					if ((Object)(object)__instance == (Object)(object)PlayerController.instance)
					{
						if (_originalJumpForce < 0f)
						{
							_originalJumpForce = __instance.JumpForce;
						}
						if (flag)
						{
							__instance.JumpForce = _originalJumpForce * GetJumpMultiplier();
						}
						else if (__instance.JumpForce != _originalJumpForce && _originalJumpForce >= 0f)
						{
							__instance.JumpForce = _originalJumpForce;
						}
						UpdateGodModeFlight(__instance);
						UpdateAllTeammatesGodMode();
						__instance.DebugEnergy = IsInfiniteStaminaEnabled();
					}
				}
				catch (Exception arg)
				{
					Plugin instance = Instance;
					if (instance != null)
					{
						((BaseUnityPlugin)instance).Logger.LogWarning((object)$"[PlayerController.Update.JumpForce Patch Error]: {arg}");
					}
				}
			}

			private static void UpdateGodModeFlight(PlayerController player)
			{
				//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
				//IL_011e: 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_0171: Unknown result type (might be due to invalid IL or missing references)
				//IL_0178: Unknown result type (might be due to invalid IL or missing references)
				//IL_017e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0183: Unknown result type (might be due to invalid IL or missing references)
				//IL_0188: Unknown result type (might be due to invalid IL or missing references)
				//IL_0189: Unknown result type (might be due to invalid IL or missing references)
				//IL_0190: Unknown result type (might be due to invalid IL or missing references)
				//IL_0196: Unknown result type (might be due to invalid IL or missing references)
				//IL_019b: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
				//IL_013c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0141: Unknown result type (might be due to invalid IL or missing references)
				//IL_014a: Unknown result type (might be due to invalid IL or missing references)
				//IL_014f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0151: Unknown result type (might be due to invalid IL or missing references)
				//IL_0152: Unknown result type (might be due to invalid IL or missing references)
				//IL_0155: Unknown result type (might be due to invalid IL or missing references)
				//IL_015a: Unknown result type (might be due to invalid IL or missing references)
				//IL_015f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0160: Unknown result type (might be due to invalid IL or missing references)
				//IL_0161: 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_0169: Unknown result type (might be due to invalid IL or missing references)
				//IL_016e: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
				//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
				//IL_01af: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
				//IL_01be: Unknown result type (might be due to invalid IL or missing references)
				//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
				//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
				//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
				//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
				if (IsStaticModEnabled() && IsGodModeFlightEnabled())
				{
					if (!_prevGodModeFlightEnabled)
					{
						_prevGodModeFlightEnabled = true;
						if ((Object)(object)PlayerAvatar.instance != (Object)null)
						{
							string text = PlayerAvatarSteamIDRef.Invoke(PlayerAvatar.instance);
							if (!string.IsNullOrEmpty(text))
							{
								SetPlayerFlightGodMode(text, enable: true);
							}
						}
					}
					if ((Object)(object)player.playerAvatarScript != (Object)null)
					{
						bool num = _fIsTumbling.Invoke(player.playerAvatarScript);
						PlayerTumble val = _fTumble.Invoke(player.playerAvatarScript);
						if (num && (Object)(object)val != (Object)null)
						{
							val.TumbleRequest(false, false);
						}
					}
					if ((Object)(object)player.rb != (Object)null)
					{
						player.rb.isKinematic = true;
						player.rb.useGravity = false;
						player.rb.velocity = Vector3.zero;
					}
					if ((Object)(object)player.col != (Object)null && player.col.enabled)
					{
						player.col.enabled = false;
					}
					float num2 = 12f;
					if (SemiFunc.InputHold((InputKey)15) || player.sprinting)
					{
						num2 = 28f;
					}
					float num3 = SemiFunc.InputMovementX();
					float num4 = SemiFunc.InputMovementY();
					Vector3 val2 = Vector3.zero;
					Camera mainCamera = GetMainCamera();
					if ((Object)(object)mainCamera != (Object)null)
					{
						Vector3 forward = ((Component)mainCamera).transform.forward;
						Vector3 right = ((Component)mainCamera).transform.right;
						val2 += forward * num4;
						val2 += right * num3;
					}
					else
					{
						val2 += ((Component)player).transform.forward * num4;
						val2 += ((Component)player).transform.right * num3;
					}
					if (SemiFunc.InputHold((InputKey)1))
					{
						val2 += Vector3.up;
					}
					if (SemiFunc.InputHold((InputKey)12))
					{
						val2 -= Vector3.up;
					}
					if (((Vector3)(ref val2)).sqrMagnitude > 0.001f)
					{
						Transform transform = ((Component)player).transform;
						transform.position += ((Vector3)(ref val2)).normalized * num2 * Time.deltaTime;
					}
				}
				else
				{
					if (!_prevGodModeFlightEnabled)
					{
						return;
					}
					_prevGodModeFlightEnabled = false;
					if ((Object)(object)PlayerAvatar.instance != (Object)null)
					{
						string text2 = PlayerAvatarSteamIDRef.Invoke(PlayerAvatar.instance);
						if (!string.IsNullOrEmpty(text2))
						{
							SetPlayerFlightGodMode(text2, enable: false);
						}
					}
					if ((Object)(object)player.rb != (Object)null)
					{
						player.rb.isKinematic = false;
						player.rb.useGravity = true;
					}
					if ((Object)(object)player.col != (Object)null)
					{
						player.col.enabled = true;
					}
				}
			}
		}

		[HarmonyPatch(typeof(ItemUpgradePlayerTumbleWingsLogic), "TumbleWingPinkTimerUpdate")]
		private class ItemUpgradePlayerTumbleWingsLogic_TumbleWingPinkTimerUpdate_Patch
		{
			[HarmonyPrefix]
			private static bool Prefix(ItemUpgradePlayerTumbleWingsLogic __instance)
			{
				if (IsStaticModEnabled() && IsWingsAlwaysShowEnabled())
				{
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(ItemUpgradePlayerTumbleWingsLogic), "TurnOffWings")]
		private class ItemUpgradePlayerTumbleWingsLogic_TurnOffWings_Patch
		{
			[HarmonyPrefix]
			private static bool Prefix(ItemUpgradePlayerTumbleWingsLogic __instance)
			{
				if (IsStaticModEnabled() && IsWingsAlwaysShowEnabled())
				{
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(ItemUpgradePlayerTumbleWingsLogic), "LoopSound")]
		private class ItemUpgradePlayerTumbleWingsLogic_LoopSound_Patch
		{
			[HarmonyPrefix]
			private static bool Prefix(ItemUpgradePlayerTumbleWingsLogic __instance)
			{
				if (!IsWingsSoundEnabled())
				{
					try
					{
						if (__instance.soundWingsLoop != null)
						{
							__instance.soundWingsLoop.PlayLoop(false, 2f, 2f, 1f, 1f);
						}
					}
					catch
					{
					}
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(ItemUpgradePlayerTumbleWingsLogic), "FixedUpdate")]
		private class ItemUpgradePlayerTumbleWingsLogic_FixedUpdate_Patch
		{
			[HarmonyPostfix]
			private static void Postfix(ItemUpgradePlayerTumbleWingsLogic __instance)
			{
				//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
				//IL_0102: Unknown result type (might be due to invalid IL or missing references)
				//IL_0109: Unknown result type (might be due to invalid IL or missing references)
				if (!IsStaticModEnabled() || !IsTumbleFlyEnabled())
				{
					return;
				}
				try
				{
					if (!((Object)(object)__instance.playerAvatar != (Object)null) || !PlayerAvatarIsLocalRef.Invoke(__instance.playerAvatar))
					{
						return;
					}
					PlayerTumble val = WingsPlayerTumbleRef.Invoke(__instance);
					PhysGrabObject val2 = (((Object)(object)val != (Object)null) ? PlayerTumblePhysGrabObjectRef.Invoke(val) : null);
					Keyboard current = Keyboard.current;
					if (current == null || !((ButtonControl)current.qKey).isPressed || !((Object)(object)val != (Object)null) || !PlayerTumbleIsTumblingRef.Invoke(val) || !((Object)(object)val2 != (Object)null) || !((Object)(object)val2.rb != (Object)null))
					{
						return;
					}
					Transform overrideTransform = __instance.playerAvatar.localCamera.GetOverrideTransform();
					if ((Object)(object)overrideTransform != (Object)null)
					{
						val.DisableCustomGravity(0.1f);
						Vector3 forward = overrideTransform.forward;
						float num = 16f;
						Vector3 val3 = forward * num;
						val2.rb.velocity = Vector3.Lerp(val2.rb.velocity, val3, 0.35f);
						val.OverrideLookAtCamera(0.1f, 10f, 5f);
						if (!PlayerAvatarUpgradeTumbleWingsVisualsActiveRef.Invoke(__instance.playerAvatar))
						{
							__instance.playerAvatar.UpgradeTumbleWingsVisualsActive(true, false);
							PlayerAvatarUpgradeTumbleWingsVisualsActiveRef.Invoke(__instance.playerAvatar) = true;
						}
						TumbleWingTimerRef.Invoke(__instance) = 1f;
					}
				}
				catch (Exception arg)
				{
					Plugin instance = Instance;
					if (instance != null)
					{
						((BaseUnityPlugin)instance).Logger.LogWarning((object)$"[ItemUpgradePlayerTumbleWingsLogic.FixedUpdate Patch Error]: {arg}");
					}
				}
			}
		}

		[HarmonyPatch(typeof(EnemyParent), "Despawn")]
		private class EnemyParent_Despawn_Patch
		{
			[HarmonyPostfix]
			private static void Postfix(EnemyParent __instance)
			{
				if (!IsTab4Enabled() || (PhotonNetwork.InRoom && !PhotonNetwork.IsMasterClient))
				{
					return;
				}
				try
				{
					if (!((Object)(object)((Component)__instance).GetComponent<SpawnedByGameToolsHelper>() != (Object)null) || _cfgSpawnedAutoRespawn)
					{
						return;
					}
					Enemy val = EnemyParentEnemyRef.Invoke(__instance);
					if (!((Object)(object)val != (Object)null))
					{
						return;
					}
					EnemyHealth val2 = EnemyHealthRef.Invoke(val);
					if (!((Object)(object)val2 != (Object)null) || EnemyHealthCurrentRef.Invoke(val2) > 0)
					{
						return;
					}
					if ((Object)(object)EnemyDirector.instance != (Object)null && EnemyDirector.instance.enemiesSpawned != null)
					{
						EnemyDirector.instance.enemiesSpawned.Remove(__instance);
					}
					if (PhotonNetwork.InRoom)
					{
						if (PhotonNetwork.IsMasterClient)
						{
							PhotonNetwork.Destroy(((Component)__instance).gameObject);
						}
					}
					else
					{
						Object.Destroy((Object)(object)((Component)__instance).gameObject);
					}
				}
				catch (Exception arg)
				{
					Plugin instance = Instance;
					if (instance != null)
					{
						((BaseUnityPlugin)instance).Logger.LogWarning((object)$"[EnemyParent.Despawn Postfix Error]: {arg}");
					}
				}
			}
		}

		[HarmonyPatch(typeof(EnemyDirector), "AmountSetup")]
		private class EnemyDirector_AmountSetup_Patch
		{
			private static readonly MethodInfo pickMethod = typeof(EnemyDirector).GetMethod("PickEnemies", BindingFlags.Instance | BindingFlags.NonPublic);

			[HarmonyPostfix]
			private static void Postfix(EnemyDirector __instance)
			{
				if (!IsTab5Enabled() || (PhotonNetwork.InRoom && !PhotonNetwork.IsMasterClient))
				{
					return;
				}
				try
				{
					float spawnRateMultiplier = GetSpawnRateMultiplier();
					if (!(spawnRateMultiplier > 1f))
					{
						return;
					}
					int num = EnemyDirectorAmountCurve1ValueRef.Invoke(__instance);
					int num2 = EnemyDirectorAmountCurve2ValueRef.Invoke(__instance);
					int num3 = EnemyDirectorAmountCurve3ValueRef.Invoke(__instance);
					int num4 = Mathf.RoundToInt((float)num * (spawnRateMultiplier - 1f));
					int num5 = Mathf.RoundToInt((float)num2 * (spawnRateMultiplier - 1f));
					int num6 = Mathf.RoundToInt((float)num3 * (spawnRateMultiplier - 1f));
					if (pickMethod != null)
					{
						object[] array = new object[1];
						for (int i = 0; i < num6; i++)
						{
							array[0] = __instance.enemiesDifficulty3;
							pickMethod.Invoke(__instance, array);
						}
						for (int j = 0; j < num5; j++)
						{
							array[0] = __instance.enemiesDifficulty2;
							pickMethod.Invoke(__instance, array);
						}
						for (int k = 0; k < num4; k++)
						{
							array[0] = __instance.enemiesDifficulty1;
							pickMethod.Invoke(__instance, array);
						}
					}
					EnemyDirectorAmountCurve1ValueRef.Invoke(__instance) = num + num4;
					EnemyDirectorAmountCurve2ValueRef.Invoke(__instance) = num2 + num5;
					EnemyDirectorAmountCurve3ValueRef.Invoke(__instance) = num3 + num6;
					EnemyDirectorTotalAmountRef.Invoke(__instance) = EnemyDirectorTotalAmountRef.Invoke(__instance) + num4 + num5 + num6;
					Plugin instance = Instance;
					if (instance != null)
					{
						((BaseUnityPlugin)instance).Logger.LogInfo((object)$"[GameTools] Spawn Multiplier {spawnRateMultiplier}x applied! Added slots: Difficulty1={num4}, Difficulty2={num5}, Difficulty3={num6}. Total slots: {EnemyDirectorTotalAmountRef.Invoke(__instance)}");
					}
				}
				catch (Exception arg)
				{
					Plugin instance2 = Instance;
					if (instance2 != null)
					{
						((BaseUnityPlugin)instance2).Logger.LogWarning((object)$"[EnemyDirector.AmountSetup Postfix Error]: {arg}");
					}
				}
			}
		}

		[HarmonyPatch(typeof(ItemBattery), "Update")]
		private class ItemBattery_Update_Patch
		{
			[HarmonyPrefix]
			private static void Prefix(ItemBattery __instance, ref float __state)
			{
				__state = -1f;
				if (IsStaticModEnabled() && ShouldBatteryBeInfinite(__instance))
				{
					__state = __instance.batteryLife;
				}
			}

			[HarmonyPostfix]
			private static void Postfix(ItemBattery __instance, float __state)
			{
				if (IsStaticModEnabled() && ShouldBatteryBeInfinite(__instance))
				{
					__instance.batteryLife = 100f;
					ItemBatteryBatteryLifeIntRef.Invoke(__instance) = __instance.batteryBars;
				}
				else if (__state >= 0f)
				{
					__instance.batteryLife = __state;
				}
			}
		}

		[HarmonyPatch(typeof(ItemBattery), "Drain")]
		private class ItemBattery_Drain_Patch
		{
			[HarmonyPrefix]
			private static bool Prefix(ItemBattery __instance)
			{
				if (IsStaticModEnabled() && ShouldBatteryBeInfinite(__instance))
				{
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(ItemBattery), "RemoveFullBar")]
		private class ItemBattery_RemoveFullBar_Patch
		{
			[HarmonyPrefix]
			private static bool Prefix(ItemBattery __instance)
			{
				if (IsStaticModEnabled() && ShouldBatteryBeInfinite(__instance))
				{
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(PlayerDeathHead), "SeenSetRPC")]
		private class PlayerDeathHead_SeenSetRPC_Patch
		{
			[HarmonyPostfix]
			private static void Postfix(PlayerDeathHead __instance, bool _toggle)
			{
				if (!_toggle || !IsStaticModEnabled() || !IsAutoReviveWhenSeenEnabled())
				{
					return;
				}
				try
				{
					PlayerAvatar playerAvatar = __instance.playerAvatar;
					if ((Object)(object)playerAvatar != (Object)null && PlayerAvatarDeadSetRef.Invoke(playerAvatar) && (!PhotonNetwork.InRoom || PhotonNetwork.IsMasterClient || PlayerAvatarIsLocalRef.Invoke(playerAvatar)))
					{
						Plugin instance = Instance;
						if (instance != null)
						{
							((BaseUnityPlugin)instance).Logger.LogInfo((object)("[GameTools] Player " + ((Object)playerAvatar).name + " death head was seen by teammates. Triggering auto revive!"));
						}
						HandleReviveAndTeleport(playerAvatar);
					}
				}
				catch (Exception arg)
				{
					Plugin instance2 = Instance;
					if (instance2 != null)
					{
						((BaseUnityPlugin)instance2).Logger.LogWarning((object)$"[PlayerDeathHead.SeenSetRPC Postfix Error]: {arg}");
					}
				}
			}
		}

		[HarmonyPatch(typeof(PlayerDeathHead), "Update")]
		private class PlayerDeathHead_Update_Patch
		{
			private static readonly Dictionary<int, float> _reviveCooldown = new Dictionary<int, float>();

			private static readonly Dictionary<int, float> _nextCheckTime = new Dictionary<int, float>();

			private static readonly FieldRef<PlayerDeathHead, PhysGrabObject> _fPhysGrabObjRef = AccessTools.FieldRefAccess<PlayerDeathHead, PhysGrabObject>("physGrabObject");

			private static readonly FieldRef<PlayerDeathHead, PhotonView> _fPhotonViewRef = AccessTools.FieldRefAccess<PlayerDeathHead, PhotonView>("photonView");

			private static readonly FieldRef<PlayerDeathHead, RoomVolumeCheck> _fRoomVolumeCheckRef = AccessTools.FieldRefAccess<PlayerDeathHead, RoomVolumeCheck>("roomVolumeCheck");

			private static readonly FieldRef<RoomVolumeCheck, bool> _fRoomInTruckRef = AccessTools.FieldRefAccess<RoomVolumeCheck, bool>("inTruck");

			private static readonly FieldRef<RoomVolumeCheck, bool> _fRoomInExtractionRef = AccessTools.FieldRefAccess<RoomVolumeCheck, bool>("inExtractionPoint");

			[HarmonyPostfix]
			private static void Postfix(PlayerDeathHead __instance)
			{
				//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
				//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
				if (!IsStaticModEnabled())
				{
					return;
				}
				PlayerAvatar playerAvatar = __instance.playerAvatar;
				if ((Object)(object)playerAvatar == (Object)null || !PlayerAvatarDeadSetRef.Invoke(playerAvatar))
				{
					return;
				}
				bool num = SemiFunc.IsMasterClientOrSingleplayer();
				bool flag = PlayerAvatarIsLocalRef.Invoke(playerAvatar);
				if (!num && !flag)
				{
					return;
				}
				PhotonView val = _fPhotonViewRef.Invoke(__instance);
				int key = (((Object)(object)val != (Object)null) ? val.ViewID : ((Object)__instance).GetInstanceID());
				if (_reviveCooldown.TryGetValue(key, out var value) && value > 0f)
				{
					_reviveCooldown[key] = value - Time.deltaTime;
					return;
				}
				float time = Time.time;
				if (_nextCheckTime.TryGetValue(key, out var value2) && time < value2)
				{
					return;
				}
				_nextCheckTime[key] = time + 1f;
				PhysGrabObject val2 = _fPhysGrabObjRef.Invoke(__instance);
				if ((Object)(object)val2 == (Object)null)
				{
					return;
				}
				bool flag2 = false;
				bool flag3 = false;
				bool flag4 = false;
				RoomVolumeCheck val3 = _fRoomVolumeCheckRef.Invoke(__instance);
				if ((Object)(object)val3 != (Object)null)
				{
					flag3 = _fRoomInTruckRef.Invoke(val3);
					flag4 = _fRoomInExtractionRef.Invoke(val3);
				}
				if (IsReviveHeadOnTruck() && flag3)
				{
					flag2 = true;
					Plugin instance = Instance;
					if (instance != null)
					{
						((BaseUnityPlugin)instance).Logger.LogInfo((object)("[GameTools] " + ((Object)playerAvatar).name + " death head is IN TRUCK → auto revive!"));
					}
				}
				if (!flag2 && IsReviveHeadOnExtraction() && flag4)
				{
					flag2 = true;
					Plugin instance2 = Instance;
					if (instance2 != null)
					{
						((BaseUnityPlugin)instance2).Logger.LogInfo((object)("[GameTools] " + ((Object)playerAvatar).name + " death head is AT EXTRACTION POINT → auto revive!"));
					}
				}
				if (!flag2 && IsReviveHeadOnCart())
				{
					try
					{
						PhysGrabCart[] array = Object.FindObjectsOfType<PhysGrabCart>();
						Vector3 centerPoint = val2.centerPoint;
						PhysGrabCart[] array2 = array;
						foreach (PhysGrabCart val4 in array2)
						{
							if ((Object)(object)val4 != (Object)null && Vector3.Distance(centerPoint, ((Component)val4).transform.position) <= 0.8f)
							{
								flag2 = true;
								Plugin instance3 = Instance;
								if (instance3 != null)
								{
									((BaseUnityPlugin)instance3).Logger.LogInfo((object)("[GameTools] " + ((Object)playerAvatar).name + " death head is ON CART (" + ((Object)val4).name + ") → auto revive!"));
								}
								break;
							}
						}
					}
					catch (Exception arg)
					{
						Plugin instance4 = Instance;
						if (instance4 != null)
						{
							((BaseUnityPlugin)instance4).Logger.LogWarning((object)$"[PlayerDeathHead_Update_Patch Cart Error]: {arg}");
						}
					}
				}
				if (flag2)
				{
					_reviveCooldown[key] = 5f;
					HandleReviveAndTeleport(playerAvatar);
				}
			}
		}

		[HarmonyPatch(typeof(PlayerTumble), "TumbleRequest")]
		private class PlayerTumble_TumbleRequest_Patch
		{
			[HarmonyPrefix]
			private static bool Prefix(PlayerTumble __instance, bool _isTumbling, bool _playerInput)
			{
				if (!_isTumbling || _playerInput)
				{
					return true;
				}
				if (!IsStaticModEnabled())
				{
					return true;
				}
				try
				{
					PlayerAvatar playerAvatar = __instance.playerAvatar;
					if ((Object)(object)playerAvatar == (Object)null)
					{
						return true;
					}
					string steamID = PlayerAvatarSteamIDRef.Invoke(playerAvatar);
					if (IsAllTeammatesGodModeEnabled() || IsPlayerGodMode(steamID) || IsPlayerTempGodMode(steamID))
					{
						return false;
					}
				}
				catch (Exception arg)
				{
					Plugin instance = Instance;
					if (instance != null)
					{
						((BaseUnityPlugin)instance).Logger.LogWarning((object)$"[PlayerTumble_TumbleRequest_Patch Error]: {arg}");
					}
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(PlayerHealth), "Hurt")]
		private class PlayerHealth_Hurt_Patch
		{
			[HarmonyPrefix]
			private static bool Prefix(PlayerHealth __instance)
			{
				if (!IsStaticModEnabled())
				{
					return true;
				}
				try
				{
					PlayerAvatar val = PlayerHealthAvatarRef.Invoke(__instance);
					if ((Object)(object)val != (Object)null)
					{
						string steamID = PlayerAvatarSteamIDRef.Invoke(val);
						if (PlayerAvatarIsLocalRef.Invoke(val))
						{
							if (IsPlayerGodMode(steamID))
							{
								PlayerHealthCurrentRef.Invoke(__instance) = PlayerHealthMaxRef.Invoke(__instance);
								return false;
							}
							if (IsPlayerTempGodMode(steamID))
							{
								return false;
							}
						}
						else if (PhotonNetwork.IsMasterClient && IsPlayerGodMode(steamID))
						{
							PlayerHealthCurrentRef.Invoke(__instance) = PlayerHealthMaxRef.Invoke(__instance);
							if ((Object)(object)val.photonView != (Object)null)
							{
								int num = PlayerHealthMaxRef.Invoke(__instance);
								val.photonView.RPC("UpdateHealthRPC", (RpcTarget)0, new object[4] { num, num, true, false });
							}
							return false;
						}
					}
				}
				catch (Exception arg)
				{
					Plugin instance = Instance;
					if (instance != null)
					{
						((BaseUnityPlugin)instance).Logger.LogWarning((object)$"[PlayerHealth.Hurt Patch Error]: {arg}");
					}
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(PlayerHealth), "Update")]
		private class PlayerHealth_Update_Patch
		{
			[HarmonyPrefix]
			private static void Prefix(PlayerHealth __instance)
			{
				if (!IsStaticModEnabled())
				{
					return;
				}
				try
				{
					PlayerAvatar val = PlayerHealthAvatarRef.Invoke(__instance);
					if (!((Object)(object)val != (Object)null))
					{
						return;
					}
					string steamID = PlayerAvatarSteamIDRef.Invoke(val);
					if (PlayerAvatarIsLocalRef.Invoke(val) && IsPlayerGodMode(steamID))
					{
						int num = PlayerHealthMaxRef.Invoke(__instance);
						if (PlayerHealthCurrentRef.Invoke(__instance) < num)
						{
							PlayerHealthCurrentRef.Invoke(__instance) = num;
						}
					}
					else
					{
						if (PlayerAvatarIsLocalRef.Invoke(val) || !PhotonNetwork.IsMasterClient || !IsPlayerGodMode(steamID))
						{
							return;
						}
						int num2 = PlayerHealthMaxRef.Invoke(__instance);
						if (PlayerHealthCurrentRef.Invoke(__instance) < num2)
						{
							PlayerHealthCurrentRef.Invoke(__instance) = num2;
							if ((Object)(object)val.photonView != (Object)null)
							{
								val.photonView.RPC("UpdateHealthRPC", (RpcTarget)0, new object[4] { num2, num2, true, false });
							}
						}
					}
				}
				catch (Exception arg)
				{
					Plugin instance = Instance;
					if (instance != null)
					{
						((BaseUnityPlugin)instance).Logger.LogWarning((object)$"[PlayerHealth.Update Patch Error]: {arg}");
					}
				}
			}
		}

		[HarmonyPatch(typeof(PlayerHealth), "HurtOther")]
		private class PlayerHealth_HurtOther_Patch
		{
			[HarmonyPrefix]
			private static bool Prefix(PlayerHealth __instance)
			{
				if (!IsStaticModEnabled())
				{
					return true;
				}
				try
				{
					PlayerAvatar val = PlayerHealthAvatarRef.Invoke(__instance);
					if ((Object)(object)val != (Object)null && IsPlayerGodMode(PlayerAvatarSteamIDRef.Invoke(val)))
					{
						return false;
					}
				}
				catch (Exception arg)
				{
					Plugin instance = Instance;
					if (instance != null)
					{
						((BaseUnityPlugin)instance).Logger.LogWarning((object)$"[PlayerHealth.HurtOther Patch Error]: {arg}");
					}
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(PlayerHealth), "HurtOtherRPC")]
		private class PlayerHealth_HurtOtherRPC_Patch
		{
			[HarmonyPrefix]
			private static bool Prefix(PlayerHealth __instance)
			{
				if (!IsStaticModEnabled())
				{
					return true;
				}
				try
				{
					PlayerAvatar val = PlayerHealthAvatarRef.Invoke(__instance);
					if ((Object)(object)val != (Object)null && IsPlayerGodMode(PlayerAvatarSteamIDRef.Invoke(val)))
					{
						return false;
					}
				}
				catch (Exception arg)
				{
					Plugin instance = Instance;
					if (instance != null)
					{
						((BaseUnityPlugin)instance).Logger.LogWarning((object)$"[PlayerHealth.HurtOtherRPC Patch Error]: {arg}");
					}
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(PlayerHealth), "Death")]
		private class PlayerHealth_Death_Patch
		{
			[HarmonyPrefix]
			private static bool Prefix(PlayerHealth __instance)
			{
				if (!IsStaticModEnabled())
				{
					return true;
				}
				try
				{
					PlayerAvatar val = PlayerHealthAvatarRef.Invoke(__instance);
					if ((Object)(object)val != (Object)null && IsPlayerGodMode(PlayerAvatarSteamIDRef.Invoke(val)))
					{
						return false;
					}
				}
				catch (Exception arg)
				{
					Plugin instance = Instance;
					if (instance != null)
					{
						((BaseUnityPlugin)instance).Logger.LogWarning((object)$"[PlayerHealth.Death Patch Error]: {arg}");
					}
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(CameraPosition), "Awake")]
		private class CameraPosition_Awake_Patch
		{
			[HarmonyPostfix]
			private static void Postfix()
			{
				CameraPosition_Update_Patch.ResetState();
				GameToolsVisuals.ResetLocalState();
			}
		}

		[HarmonyPatch(typeof(CameraPosition), "Update")]
		private class CameraPosition_Update_Patch
		{
			private static readonly int CameraCollisionLayerMask = LayerMask.GetMask(new string[3] { "Default", "World", "Terrain" });

			private static bool _prevThirdPersonEnabled = false;

			private static Vector3 _lastMainCamLocalPos = Vector3.zero;

			public static void ResetState()
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				_prevThirdPersonEnabled = false;
				_lastMainCamLocalPos = Vector3.zero;
			}

			[HarmonyPrefix]
			private static void Prefix(CameraPosition __instance)
			{
				//IL_0081: Unknown result type (might be due to invalid IL or missing references)
				if (_cfgModEnabled == null || !_cfgModEnabled.Value)
				{
					return;
				}
				try
				{
					bool flag = IsThirdPersonEnabled();
					bool flag2 = CameraPositionOverridePositionActiveRef.Invoke(__instance) || CameraPositionOverridePositionTimerRef.Invoke(__instance) > 0f;
					if ((Object)(object)PlayerAvatar.instance != (Object)null && PlayerAvatarIsLocalRef.Invoke(PlayerAvatar.instance) && flag && _prevThirdPersonEnabled && !flag2)
					{
						Camera mainCamera = GetMainCamera();
						if ((Object)(object)mainCamera != (Object)null)
						{
							((Component)mainCamera).transform.localPosition = _lastMainCamLocalPos;
						}
					}
				}
				catch (Exception arg)
				{
					Plugin instance = Instance;
					if (instance != null)
					{
						((BaseUnityPlugin)instance).Logger.LogWarning((object)$"[CameraPosition.Update Prefix Patch Error]: {arg}");
					}
				}
			}

			[HarmonyPostfix]
			private static void Postfix(CameraPosition __instance)
			{
				//IL_0285: Unknown result type (might be due to invalid IL or missing references)
				//IL_02c4: Unknown result type (might be due to invalid IL or missing references)
				//IL_0096: Unknown result type (might be due to invalid IL or missing references)
				//IL_009b: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
				//IL_0172: Unknown result type (might be due to invalid IL or missing references)
				//IL_0177: Unknown result type (might be due to invalid IL or missing references)
				//IL_0182: Unknown result type (might be due to invalid IL or missing references)
				//IL_0187: Unknown result type (might be due to invalid IL or missing references)
				//IL_018e: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
				//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
				//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
				//IL_01db: Unknown result type (might be due to invalid IL or missing references)
				//IL_01e0: 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_01e9: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
				//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
				//IL_0200: Unknown result type (might be due to invalid IL or missing references)
				//IL_0202: Unknown result type (might be due to invalid IL or missing references)
				//IL_0203: Unknown result type (might be due to invalid IL or missing references)
				//IL_0205: Unknown result type (might be due to invalid IL or missing references)
				//IL_020a: Unknown result type (might be due to invalid IL or missing references)
				//IL_020c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0212: Unknown result type (might be due to invalid IL or missing references)
				//IL_0251: Unknown result type (might be due to invalid IL or missing references)
				//IL_0225: Unknown result type (might be due to invalid IL or missing references)
				//IL_0226: Unknown result type (might be due to invalid IL or missing references)
				//IL_023f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0244: Unknown result type (might be due to invalid IL or missing references)
				//IL_0249: Unknown result type (might be due to invalid IL or missing references)
				if (_cfgModEnabled == null || !_cfgModEnabled.Value)
				{
					return;
				}
				try
				{
					bool flag = IsThirdPersonEnabled();
					bool flag2 = CameraPositionOverridePositionActiveRef.Invoke(__instance) || CameraPositionOverridePositionTimerRef.Invoke(__instance) > 0f;
					if (!((Object)(object)PlayerAvatar.instance != (Object)null) || !PlayerAvatarIsLocalRef.Invoke(PlayerAvatar.instance))
					{
						return;
					}
					if (flag && !flag2)
					{
						Camera mainCamera = GetMainCamera();
						if (!((Object)(object)mainCamera != (Object)null))
						{
							return;
						}
						if (!_prevThirdPersonEnabled)
						{
							_prevThirdPersonEnabled = true;
							_lastMainCamLocalPos = ((Component)mainCamera).transform.localPosition;
						}
						if ((Object)(object)PlayerAvatar.instance.playerAvatarVisuals != (Object)null)
						{
							PlayerAvatar.instance.playerAvatarVisuals.ShowSelfOverride(0.5f);
							float thirdPersonModelScale = GetThirdPersonModelScale();
							((Component)PlayerAvatar.instance.playerAvatarVisuals).transform.localScale = new Vector3(thirdPersonModelScale, thirdPersonModelScale, thirdPersonModelScale);
						}
						PhysGrabber physGrabber = PlayerAvatar.instance.physGrabber;
						if (physGrabber != null)
						{
							physGrabber.SetThirdPerson(true);
						}
						FlashlightController flashlightController = PlayerAvatar.instance.flashlightController;
						if (flashlightController != null)
						{
							flashlightController.SetThirdPerson(true);
						}
						if ((Object)(object)PlayerAvatar.instance.playerAvatarVisuals != (Object)null)
						{
							PlayerAvatarRightArm val = PlayerAvatarVisualsRightArmRef.Invoke(PlayerAvatar.instance.playerAvatarVisuals);
							if ((Object)(object)val != (Object)null && (Object)(object)val.grabberOrb != (Object)null)
							{
								((Component)val.grabberOrb).gameObject.SetActive(false);
							}
						}
						_lastMainCamLocalPos = ((Component)mainCamera).transform.localPosition;
						Vector3 position = ((Component)mainCamera).transform.position;
						Quaternion rotation = ((Component)mainCamera).transform.rotation;
						float thirdPersonDistance = GetThirdPersonDistance();
						float thirdPersonHeight = GetThirdPersonHeight();
						float thirdPersonHorizontal = GetThirdPersonHorizontal();
						Vector3 val2 = rotation * Vector3.forward;
						Vector3 val3 = rotation * Vector3.right;
						Vector3 val4 = -val2 * thirdPersonDistance + Vector3.up * thirdPersonHeight + val3 * thirdPersonHorizontal;
						float magnitude = ((Vector3)(ref val4)).magnitude;
						Vector3 normalized = ((Vector3)(ref val4)).normalized;
						Vector3 position2 = position + val4;
						RaycastHit val5 = default(RaycastHit);
						if (Physics.SphereCast(position, 0.2f, normalized, ref val5, magnitude, CameraCollisionLayerMask, (QueryTriggerInteraction)1))
						{
							position2 = position + normalized * Mathf.Max(0.1f, ((RaycastHit)(ref val5)).distance - 0.05f);
						}
						((Component)mainCamera).transform.position = position2;
					}
					else
					{
						if (!_prevThirdPersonEnabled)
						{
							return;
						}
						_prevThirdPersonEnabled = false;
						Camera mainCamera2 = GetMainCamera();
						if ((Object)(object)mainCamera2 != (Object)null)
						{
							((Component)mainCamera2).transform.localPosition = _lastMainCamLocalPos;
						}
						if ((Object)(object)PlayerAvatar.instance.playerAvatarVisuals != (Object)null)
						{
							PlayerAvatar.instance.playerAvatarVisuals.ShowSelfOverride(0f);
							((Component)PlayerAvatar.instance.playerAvatarVisuals).transform.localScale = Vector3.one;
						}
						if (!flag)
						{
							PhysGrabber physGrabber2 = PlayerAvatar.instance.physGrabber;
							if (physGrabber2 != null)
							{
								physGrabber2.SetThirdPerson(false);
							}
							FlashlightController flashlightController2 = PlayerAvatar.instance.flashlightController;
							if (flashlightController2 != null)
							{
								flashlightController2.SetThirdPerson(false);
							}
						}
					}
				}
				catch (Exception arg)
				{
					Plugin instance = Instance;
					if (instance != null)
					{
						((BaseUnityPlugin)instance).Logger.LogWarning((object)$"[CameraPosition.Update Postfix Patch Error]: {arg}");
					}
				}
			}
		}

		[HarmonyPatch(typeof(FlashlightController), "Update")]
		private class FlashlightController_Update_Patch
		{
			private static readonly FieldRef<FlashlightController, float> _fHiddenScale = AccessTools.FieldRefAccess<FlashlightController, float>("hiddenScale");

			private static readonly ConditionalWeakTable<FlashlightController, Light[]> _lightCache = new ConditionalWeakTable<FlashlightController, Light[]>();

			[HarmonyPostfix]
			private static void Postfix(FlashlightController __instance)
			{
				//IL_0070: Unknown result type (might be due to invalid IL or missing references)
				//IL_0086: Unknown result type (might be due to invalid IL or missing references)
				//IL_009c: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f0: 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_011a: Unknown result type (might be due to invalid IL or missing references)
				//IL_026e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0273: Unknown result type (might be due to invalid IL or missing references)
				//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c6: Expected O, but got Unknown
				//IL_028f: Unknown result type (might be due to invalid IL or missing references)
				if (_cfgModEnabled == null || !_cfgModEnabled.Value)
				{
					return;
				}
				try
				{
					if ((Object)(object)__instance.PlayerAvatar != (Object)null && PlayerAvatarIsLocalRef.Invoke(__instance.PlayerAvatar) && IsThirdPersonEnabled() && (Object)(object)__instance.FollowTransformClient != (Object)null)
					{
						float num = _fHiddenScale.Invoke(__instance);
						((Component)__instance).transform.position = __instance.FollowTransformClient.position;
						((Component)__instance).transform.rotation = __instance.FollowTransformClient.rotation;
						((Component)__instance).transform.localScale = __instance.FollowTransformClient.localScale * num * GetThirdPersonModelScale();
						if ((Object)(object)__instance.meshShadows != (Object)null)
						{
							((Component)__instance.meshShadows).transform.position = __instance.FollowTransformClient.position;
							((Component)__instance.meshShadows).transform.rotation = __instance.FollowTransformClient.rotation;
							((Component)__instance.meshShadows).transform.localScale = ((Component)__instance.mesh).transform.localScale * GetThirdPersonModelScale();
						}
					}
					if (!((Object)(object)__instance.PlayerAvatar != (Object)null))
					{
						return;
					}
					int num2 = 0;
					object value2;
					if (PlayerAvatarIsLocalRef.Invoke(__instance.PlayerAvatar))
					{
						if (IsCosmeticsEnabled() && _cfgFlashlightColorEnabled != null && _cfgFlashlightColorEnabled.Value)
						{
							num2 = ((_cfgFlashlightColor != null) ? _cfgFlashlightColor.Value : 0);
						}
						if (PhotonNetwork.InRoom && PhotonNetwork.LocalPlayer != null)
						{
							int num3 = 0;
							if (((Dictionary<object, object>)(object)PhotonNetwork.LocalPlayer.CustomProperties).TryGetValue((object)"GT_FlashlightColor", out object value))
							{
								num3 = SafeConvertToInt(value);
							}
							if (num3 != num2)
							{
								Hashtable val = new Hashtable();
								val[(object)"GT_FlashlightColor"] = num2;
								PhotonNetwork.LocalPlayer.SetCustomProperties(val, (Hashtable)null, (WebFlags)null);
							}
						}
					}
					else if (PhotonNetwork.InRoom && (Object)(object)__instance.PlayerAvatar.photonView != (Object)null && __instance.PlayerAvatar.photonView.Owner != null && ((Dictionary<object, object>)(object)__instance.PlayerAvatar.photonView.Owner.CustomProperties).TryGetValue((object)"GT_FlashlightColor", out value2))
					{
						num2 = SafeConvertToInt(value2);
					}
					if (!_lightCache.TryGetValue(__instance, out var value3))
					{
						value3 = ((Component)__instance).GetComponentsInChildren<Light>(true);
						_lightCache.Add(__instance, value3);
					}
					if (value3 == null || value3.Length == 0)
					{
						return;
					}
					Color flashlightColorValue = GetFlashlightColorValue(num2);
					Light[] array = value3;
					foreach (Light val2 in array)
					{
						if ((Object)(object)val2 != (Object)null)
						{
							val2.color = flashlightColorValue;
						}
					}
				}
				catch (Exception arg)
				{
					LogWarning($"[FlashlightController.Update Postfix Patch Error]: {arg}");
				}
			}
		}

		[HarmonyPatch(typeof(InputManager))]
		private class InputManager_Block_Patch
		{
			[HarmonyPrefix]
			[HarmonyPatch("KeyDown")]
			private static bool PrefixKeyDown(ref bool __result)
			{
				if (IsStaticModEnabled() && IsWindowOpen())
				{
					__result = false;
					return false;
				}
				return true;
			}

			[HarmonyPrefix]
			[HarmonyPatch("KeyUp")]
			private static bool PrefixKeyUp(ref bool __result)
			{
				if (IsStaticModEnabled() && IsWindowOpen())
				{
					__result = false;
					return false;
				}
				return true;
			}

			[HarmonyPrefix]
			[HarmonyPatch("KeyHold")]
			private static bool PrefixKeyHold(ref bool __result)
			{
				if (IsStaticModEnabled() && IsWindowOpen())
				{
					__result = false;
					return false;
				}
				return true;
			}

			[HarmonyPrefix]
			[HarmonyPatch("GetMovementX")]
			private static bool PrefixGetMovementX(ref float __result)
			{
				if (IsStaticModEnabled() && IsWindowOpen())
				{
					__result = 0f;
					return false;
				}
				return true;
			}

			[HarmonyPrefix]
			[HarmonyPatch("GetMovementY")]
			private static bool PrefixGetMovementY(ref float __result)
			{
				if (IsStaticModEnabled() && IsWindowOpen())
				{
					__result = 0f;
					return false;
				}
				return true;
			}

			[HarmonyPrefix]
			[HarmonyPatch("GetScrollY")]
			private static bool PrefixGetScrollY(ref float __result)
			{
				if (IsStaticModEnabled() && IsWindowOpen())
				{
					__result = 0f;
					return false;
				}
				return true;
			}

			[HarmonyPrefix]
			[HarmonyPatch("KeyPullAndPush")]
			private static bool PrefixKeyPullAndPush(ref float __result)
			{
				if (IsStaticModEnabled() && IsWindowOpen())
				{
					__result = 0f;
					return false;
				}
				return true;
			}
		}

		internal class DetectorCache
		{
			public float LastCheckTime;

			public bool IsValuable;

			public bool IsBead;

			public bool IsWeapon;

			public bool IsVehicle;

			public bool IsCosmetic;

			public bool IsPotion;

			public bool IsBattery;
		}

		[HarmonyPatch(typeof(PhysGrabObjectImpactDetector), "Update")]
		private class PhysGrabObjectImpactDetector_Update_Patch
		{
			[HarmonyPostfix]
			private static void Postfix(PhysGrabObjectImpactDetector __instance)
			{
				if (!IsStaticModEnabled())
				{
					return;
				}
				float time = Time.time;
				if (_detectorCache.TryGetValue(__instance, out var value))
				{
					if (time - value.LastCheckTime < 0.5f)
					{
						return;
					}
					value.LastCheckTime = time;
				}
				ApplyGodModeForDetector(__instance);
			}
		}

		[HarmonyPatch(typeof(PhysGrabObjectImpactDetector), "Start")]
		private class PhysGrabObjectImpactDetector_Start_Patch
		{
			[HarmonyPostfix]
			private static void Postfix(PhysGrabObjectImpactDetector __instance)
			{
				ApplyGodModeForDetector(__instance);
			}
		}

		[HarmonyPatch(typeof(PhysGrabObjectImpactDetector), "Break")]
		private class PhysGrabObjectImpactDetector_Break_Patch
		{
			[HarmonyPrefix]
			private static void Prefix(PhysGrabObjectImpactDetector __instance)
			{
				ApplyGodModeForDetector(__instance);
			}
		}

		internal sealed class LiveLabel
		{
			public WeakReference<TextMeshProUGUI> Tmp;

			public CfgI18N I18N;

			public bool IsSection;
		}

		internal sealed class LiveValue
		{
			public WeakReference<Object> InputField;

			public CfgI18N I18N;
		}

		internal sealed class LiveSliderOptions
		{
			public WeakReference<Object> Slider;

			public CfgI18N I18N;

			public string[] OptionsCN;

			public string[] OptionsEN;
		}

		internal sealed class LiveToggleButtons
		{
			public WeakReference<TextMeshProUGUI> LeftTmp;

			public WeakReference<TextMeshProUGUI> RightTmp;
		}

		public const string PluginGuid = "zichen.gametools";

		public const string PluginName = "GameTools";

		public const string PluginVersion = "1.0.9";

		internal static Plugin Instance;

		internal static Vector3 _lastRemoteTpPos = Vector3.zero;

		internal static float _lastRemoteTpTime = 0f;

		private Harmony _harmony;

		internal static readonly FieldRef<PlayerController, string> PlayerSteamIDRef = AccessTools.FieldRefAccess<PlayerController, string>("playerSteamID");

		internal static readonly FieldRef<PlayerAvatar, string> PlayerAvatarSteamIDRef = AccessTools.FieldRefAccess<PlayerAvatar, string>("steamID");

		internal static readonly FieldRef<PlayerAvatar, bool> PlayerAvatarIsLocalRef = AccessTools.FieldRefAccess<PlayerAvatar, bool>("isLocal");

		internal static readonly FieldRef<PlayerAvatar, string> PlayerAvatarPlayerNameRef = AccessTools.FieldRefAccess<PlayerAvatar, string>("playerName");

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

		internal static readonly FieldRef<PlayerAvatar, PlayerTumble> PlayerAvatarTumbleRef = AccessTools.FieldRefAccess<PlayerAvatar, PlayerTumble>("tumble");

		internal static readonly FieldRef<PlayerAvatar, float> PlayerAvatarUpgradeTumbleWingsRef = AccessTools.FieldRefAccess<PlayerAvatar, float>("upgradeTumbleWings");

		internal static readonly FieldRef<PlayerAvatar, bool> PlayerAvatarUpgradeTumbleWingsVisualsActiveRef = AccessTools.FieldRefAccess<PlayerAvatar, bool>("upgradeTumbleWingsVisualsActive");

		internal static readonly FieldRef<PlayerAvatar, PlayerDeathHead> PlayerAvatarPlayerDeathHeadRef = AccessTools.FieldRefAccess<PlayerAvatar, PlayerDeathHead>("playerDeathHead");

		internal static readonly FieldRef<PlayerDeathHead, PhysGrabObject> PlayerDeathHeadPhysGrabObjectRef = AccessTools.FieldRefAccess<PlayerDeathHead, PhysGrabObject>("physGrabObject");

		internal static readonly FieldRef<ItemUpgradePlayerTumbleWing