using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Text;
using BepInEx;
using BepInEx.Logging;
using TMPro;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using UnityEngine.Networking;
using UnityEngine.Rendering;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyVersion("0.0.0.0")]
internal static class BirdieGrantBridge
{
	private const string CommandMethodName = "System.Void PlayerInventory::BirdieCmdGrantItem(System.Int32)";

	private static bool initialized;

	private static float _nextRetry = -1f;

	private static ushort registeredCommandHash;

	private static Type mirrorNbType;

	private static Type mirrorReaderType;

	private static Type mirrorConnType;

	private static Type mirrorRpcType;

	private static Type mirrorRcdType;

	private static Type mirrorRctType;

	private static Type mirrorCmdMsgType;

	private static Type mirrorNcType;

	private static Type mirrorNwpType;

	private static Type mirrorNwExtType;

	private static Type mirrorNrExtType;

	private static MethodInfo mirrorRegisterDelegate;

	private static MethodInfo mirrorNcSend;

	private static MethodInfo mirrorWriterExtWriteInt;

	private static MethodInfo mirrorWriterPoolGet;

	private static MethodInfo mirrorWriterPoolReturn;

	private static MethodInfo mirrorWriterToArraySegment;

	private static MethodInfo mirrorReaderExtReadInt;

	private static PropertyInfo mirrorNbNetId;

	private static PropertyInfo mirrorNbComponentIndex;

	private static FieldInfo mirrorCmdNetId;

	private static FieldInfo mirrorCmdComponentIndex;

	private static FieldInfo mirrorCmdFunctionHash;

	private static FieldInfo mirrorCmdPayload;

	private static MethodInfo cachedServerTryAddItemMethod;

	private static Type cachedItemTypeEnumType;

	private static PropertyInfo cachedAllItemsProperty;

	private static MethodInfo cachedTryGetItemDataMethod;

	private static PropertyInfo cachedItemDataMaxUsesProperty;

	internal static bool IsReady()
	{
		if (initialized)
		{
			return registeredCommandHash != 0;
		}
		return false;
	}

	internal static void EnsureInitialized()
	{
		if (initialized)
		{
			return;
		}
		float time = Time.time;
		if (time < _nextRetry)
		{
			return;
		}
		_nextRetry = time + 2f;
		try
		{
			if (CollectReflectionCaches())
			{
				RegisterCommandHandler();
				if (registeredCommandHash != 0)
				{
					initialized = true;
					BirdieLog.Msg("[Birdie] Grant bridge ready.");
				}
			}
		}
		catch (Exception ex)
		{
			BirdieLog.Warning("[Birdie] Grant bridge init: " + ex.Message);
		}
	}

	internal static void RequestGrant(Component inventory, int itemTypeInt)
	{
		EnsureInitialized();
		if (registeredCommandHash == 0 || mirrorNbNetId == null || mirrorNbComponentIndex == null || mirrorCmdMsgType == null || mirrorNcSend == null || mirrorWriterExtWriteInt == null || mirrorWriterPoolGet == null || mirrorWriterPoolReturn == null || mirrorWriterToArraySegment == null)
		{
			BirdieLog.Warning("[Birdie] Item spawner: grant bridge not ready (reflection incomplete).");
			return;
		}
		try
		{
			uint num = (uint)mirrorNbNetId.GetValue(inventory, null);
			byte b = (byte)mirrorNbComponentIndex.GetValue(inventory, null);
			object obj = mirrorWriterPoolGet.Invoke(null, null);
			mirrorWriterExtWriteInt.Invoke(null, new object[2] { obj, itemTypeInt });
			ArraySegment<byte> arraySegment = (ArraySegment<byte>)mirrorWriterToArraySegment.Invoke(obj, null);
			object obj2 = Activator.CreateInstance(mirrorCmdMsgType);
			mirrorCmdNetId.SetValue(obj2, num);
			mirrorCmdComponentIndex.SetValue(obj2, b);
			mirrorCmdFunctionHash.SetValue(obj2, registeredCommandHash);
			mirrorCmdPayload.SetValue(obj2, arraySegment);
			mirrorNcSend.Invoke(null, new object[2] { obj2, 0 });
			mirrorWriterPoolReturn.Invoke(null, new object[1] { obj });
		}
		catch (Exception ex)
		{
			BirdieLog.Warning("[Birdie] Item spawner (client bridge): " + ex.Message);
		}
	}

	private static void ServerHandleGrantItem(object nbObj, object readerObj, object connObj)
	{
		try
		{
			if (nbObj == null || readerObj == null)
			{
				return;
			}
			if (mirrorReaderExtReadInt == null || cachedServerTryAddItemMethod == null || cachedItemTypeEnumType == null)
			{
				BirdieLog.Warning("[Birdie] Grant bridge server handler: reflection incomplete.");
				return;
			}
			int num = (int)mirrorReaderExtReadInt.Invoke(null, new object[1] { readerObj });
			object obj = Enum.ToObject(cachedItemTypeEnumType, num);
			int num2 = GetItemMaxUses(num);
			if (num2 <= 0)
			{
				num2 = 1;
			}
			if (!(bool)cachedServerTryAddItemMethod.Invoke(nbObj, new object[2] { obj, num2 }))
			{
				BirdieLog.Warning("[Birdie] Item spawner (bridge server): inventory full or item invalid.");
			}
		}
		catch (Exception ex)
		{
			BirdieLog.Warning("[Birdie] Grant bridge server handler: " + ex.Message);
		}
	}

	private static bool CollectReflectionCaches()
	{
		Assembly assembly = null;
		Assembly assembly2 = null;
		Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
		foreach (Assembly assembly3 in assemblies)
		{
			switch (assembly3.GetName().Name)
			{
			case "Mirror":
				assembly = assembly3;
				break;
			case "Assembly-CSharp":
			case "GameAssembly":
				assembly2 = assembly3;
				break;
			}
		}
		if (assembly == null || assembly2 == null)
		{
			return false;
		}
		mirrorNbType = assembly.GetType("Mirror.NetworkBehaviour");
		mirrorReaderType = assembly.GetType("Mirror.NetworkReader");
		mirrorConnType = assembly.GetType("Mirror.NetworkConnectionToClient");
		mirrorRpcType = assembly.GetType("Mirror.RemoteCalls.RemoteProcedureCalls");
		mirrorRcdType = assembly.GetType("Mirror.RemoteCalls.RemoteCallDelegate");
		mirrorRctType = assembly.GetType("Mirror.RemoteCalls.RemoteCallType");
		mirrorCmdMsgType = assembly.GetType("Mirror.CommandMessage");
		mirrorNcType = assembly.GetType("Mirror.NetworkClient");
		mirrorNwpType = assembly.GetType("Mirror.NetworkWriterPool");
		mirrorNwExtType = assembly.GetType("Mirror.NetworkWriterExtensions");
		mirrorNrExtType = assembly.GetType("Mirror.NetworkReaderExtensions");
		if (mirrorNbType == null || mirrorReaderType == null || mirrorConnType == null || mirrorRpcType == null || mirrorRcdType == null || mirrorRctType == null || mirrorCmdMsgType == null || mirrorNcType == null || mirrorNwpType == null || mirrorNwExtType == null || mirrorNrExtType == null)
		{
			return false;
		}
		mirrorRegisterDelegate = mirrorRpcType.GetMethod("RegisterDelegate", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
		MethodInfo method = mirrorNcType.GetMethod("Send", BindingFlags.Static | BindingFlags.Public);
		if (method != null)
		{
			mirrorNcSend = method.MakeGenericMethod(mirrorCmdMsgType);
		}
		mirrorWriterExtWriteInt = mirrorNwExtType.GetMethod("WriteInt", BindingFlags.Static | BindingFlags.Public);
		mirrorWriterPoolGet = mirrorNwpType.GetMethod("Get", BindingFlags.Static | BindingFlags.Public);
		mirrorWriterPoolReturn = mirrorNwpType.GetMethod("Return", BindingFlags.Static | BindingFlags.Public);
		Type type = assembly.GetType("Mirror.NetworkWriter");
		if (type != null)
		{
			mirrorWriterToArraySegment = type.GetMethod("ToArraySegment", BindingFlags.Instance | BindingFlags.Public);
		}
		mirrorReaderExtReadInt = mirrorNrExtType.GetMethod("ReadInt", BindingFlags.Static | BindingFlags.Public);
		mirrorNbNetId = mirrorNbType.GetProperty("netId", BindingFlags.Instance | BindingFlags.Public);
		mirrorNbComponentIndex = mirrorNbType.GetProperty("ComponentIndex", BindingFlags.Instance | BindingFlags.Public);
		mirrorCmdNetId = mirrorCmdMsgType.GetField("netId");
		mirrorCmdComponentIndex = mirrorCmdMsgType.GetField("componentIndex");
		mirrorCmdFunctionHash = mirrorCmdMsgType.GetField("functionHash");
		mirrorCmdPayload = mirrorCmdMsgType.GetField("payload");
		Type type2 = assembly2.GetType("PlayerInventory");
		cachedItemTypeEnumType = assembly2.GetType("ItemType");
		if (type2 != null)
		{
			cachedServerTryAddItemMethod = type2.GetMethod("ServerTryAddItem", BindingFlags.Instance | BindingFlags.Public);
		}
		Type type3 = assembly2.GetType("ItemCollection");
		if (type3 != null)
		{
			cachedTryGetItemDataMethod = type3.GetMethod("TryGetItemData", BindingFlags.Instance | BindingFlags.Public);
		}
		Type type4 = assembly2.GetType("ItemData");
		if (type4 != null)
		{
			cachedItemDataMaxUsesProperty = type4.GetProperty("MaxUses", BindingFlags.Instance | BindingFlags.Public);
		}
		Type type5 = assembly2.GetType("GameManager");
		if (type5 != null)
		{
			cachedAllItemsProperty = type5.GetProperty("AllItems", BindingFlags.Static | BindingFlags.Public);
		}
		if (mirrorRegisterDelegate != null && mirrorNcSend != null && mirrorWriterExtWriteInt != null && mirrorWriterPoolGet != null && mirrorWriterToArraySegment != null && mirrorReaderExtReadInt != null && mirrorNbNetId != null && mirrorNbComponentIndex != null && mirrorCmdNetId != null && type2 != null && cachedServerTryAddItemMethod != null)
		{
			return cachedItemTypeEnumType != null;
		}
		return false;
	}

	private static void RegisterCommandHandler()
	{
		if (mirrorRegisterDelegate == null || mirrorRcdType == null || mirrorNbType == null || mirrorReaderType == null || mirrorConnType == null || mirrorRctType == null)
		{
			return;
		}
		Type type = null;
		Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
		for (int i = 0; i < assemblies.Length; i++)
		{
			type = assemblies[i].GetType("PlayerInventory");
			if (type != null)
			{
				break;
			}
		}
		if (type == null)
		{
			BirdieLog.Warning("[Birdie] Grant bridge: PlayerInventory type not found.");
			return;
		}
		DynamicMethod dynamicMethod = new DynamicMethod("BirdieGrantItemCommandHandler", typeof(void), new Type[3] { mirrorNbType, mirrorReaderType, mirrorConnType }, typeof(BirdieGrantBridge).Module, skipVisibility: true);
		MethodInfo method = typeof(BirdieGrantBridge).GetMethod("ServerHandleGrantItem", BindingFlags.Static | BindingFlags.NonPublic);
		if (method == null)
		{
			BirdieLog.Warning("[Birdie] Grant bridge: ServerHandleGrantItem not found via reflection.");
			return;
		}
		ILGenerator iLGenerator = dynamicMethod.GetILGenerator();
		iLGenerator.Emit(OpCodes.Ldarg_0);
		iLGenerator.Emit(OpCodes.Ldarg_1);
		iLGenerator.Emit(OpCodes.Ldarg_2);
		iLGenerator.Emit(OpCodes.Call, method);
		iLGenerator.Emit(OpCodes.Ret);
		Delegate @delegate = dynamicMethod.CreateDelegate(mirrorRcdType);
		object obj = Enum.Parse(mirrorRctType, "Command");
		registeredCommandHash = (ushort)mirrorRegisterDelegate.Invoke(null, new object[5] { type, "System.Void PlayerInventory::BirdieCmdGrantItem(System.Int32)", obj, @delegate, false });
		if (registeredCommandHash == 0)
		{
			BirdieLog.Warning("[Birdie] Grant bridge: RegisterDelegate returned hash 0 — may indicate a collision.");
		}
	}

	private static int GetItemMaxUses(int itemTypeInt)
	{
		try
		{
			if (cachedAllItemsProperty == null || cachedTryGetItemDataMethod == null || cachedItemDataMaxUsesProperty == null || cachedItemTypeEnumType == null)
			{
				return 1;
			}
			object value = cachedAllItemsProperty.GetValue(null, null);
			if (value == null)
			{
				return 1;
			}
			object obj = Enum.ToObject(cachedItemTypeEnumType, itemTypeInt);
			object[] array = new object[2] { obj, null };
			if (!(bool)cachedTryGetItemDataMethod.Invoke(value, array) || array[1] == null)
			{
				return 1;
			}
			return (int)cachedItemDataMaxUsesProperty.GetValue(array[1], null);
		}
		catch
		{
			return 1;
		}
	}
}
internal static class BirdieHostBridge
{
	private const string RpcMethodName = "System.Void PlayerInventory::BirdieCmdSyncHostConfig(System.Boolean,System.UInt64)";

	internal static bool IsUnderHostControl;

	internal static ulong ReceivedFeatureMask;

	private static bool initialized;

	private static float _nextRetry = -1f;

	private static ushort registeredRpcHash;

	internal static bool FlagExpandedSlotsForClient;

	private static Type mirrorNbType;

	private static Type mirrorReaderType;

	private static Type mirrorConnType;

	private static Type mirrorRpcType;

	private static Type mirrorRcdType;

	private static Type mirrorRctType;

	private static Type mirrorRpcMsgType;

	private static Type mirrorNsType;

	private static Type mirrorNwpType;

	private static Type mirrorNwExtType;

	private static Type mirrorNrExtType;

	private static MethodInfo mirrorRegisterDelegate;

	private static MethodInfo mirrorNsSendToAll;

	private static MethodInfo mirrorWriterExtWriteBool;

	private static MethodInfo mirrorWriterExtWriteULong;

	private static MethodInfo mirrorWriterPoolGet;

	private static MethodInfo mirrorWriterPoolReturn;

	private static MethodInfo mirrorWriterToArraySegment;

	private static MethodInfo mirrorReaderExtReadBool;

	private static MethodInfo mirrorReaderExtReadULong;

	private static PropertyInfo mirrorNbNetId;

	private static PropertyInfo mirrorNbComponentIndex;

	private static FieldInfo mirrorRpcNetId;

	private static FieldInfo mirrorRpcComponentIndex;

	private static FieldInfo mirrorRpcFunctionHash;

	private static FieldInfo mirrorRpcPayload;

	private static PropertyInfo cachedLocalPlayerInventoryProperty;

	internal static void EnsureHandlersRegistered()
	{
		if (initialized)
		{
			return;
		}
		float time = Time.time;
		if (time < _nextRetry)
		{
			return;
		}
		_nextRetry = time + 2f;
		try
		{
			if (CollectReflectionCaches())
			{
				RegisterRpcHandler();
				if (registeredRpcHash != 0)
				{
					initialized = true;
					BirdieLog.Msg("[Birdie] Host bridge ready.");
				}
			}
		}
		catch (Exception ex)
		{
			BirdieLog.Warning("[Birdie] Host bridge init: " + ex.Message);
		}
	}

	internal static void BroadcastToClients(bool active, ulong featureMask)
	{
		EnsureHandlersRegistered();
		try
		{
			Type type = mirrorNsType;
			if (type != null)
			{
				PropertyInfo property = type.GetProperty("active", BindingFlags.Static | BindingFlags.Public);
				if (property != null && !(bool)property.GetValue(null, null))
				{
					BirdieLog.Warning("[Birdie] Host bridge: NetworkServer is not active — cannot broadcast.");
					return;
				}
			}
		}
		catch (Exception ex)
		{
			BirdieLog.Warning("[Birdie] Host bridge (server check): " + ex.Message);
			return;
		}
		if (registeredRpcHash == 0 || mirrorNbNetId == null || mirrorNbComponentIndex == null || mirrorRpcMsgType == null || mirrorNsSendToAll == null || mirrorWriterExtWriteBool == null || mirrorWriterExtWriteULong == null || mirrorWriterPoolGet == null || mirrorWriterPoolReturn == null || mirrorWriterToArraySegment == null || cachedLocalPlayerInventoryProperty == null)
		{
			BirdieLog.Warning("[Birdie] Host bridge: broadcast not ready (reflection incomplete).");
			return;
		}
		try
		{
			object? value = cachedLocalPlayerInventoryProperty.GetValue(null, null);
			Component val = (Component)((value is Component) ? value : null);
			if ((Object)(object)val == (Object)null)
			{
				BirdieLog.Warning("[Birdie] Host bridge: LocalPlayerInventory is null.");
				return;
			}
			uint num = (uint)mirrorNbNetId.GetValue(val, null);
			byte b = (byte)mirrorNbComponentIndex.GetValue(val, null);
			ulong num2 = (active ? featureMask : ulong.MaxValue);
			object obj = mirrorWriterPoolGet.Invoke(null, null);
			mirrorWriterExtWriteBool.Invoke(null, new object[2] { obj, active });
			mirrorWriterExtWriteULong.Invoke(null, new object[2] { obj, num2 });
			ArraySegment<byte> arraySegment = (ArraySegment<byte>)mirrorWriterToArraySegment.Invoke(obj, null);
			object obj2 = Activator.CreateInstance(mirrorRpcMsgType);
			mirrorRpcNetId.SetValue(obj2, num);
			mirrorRpcComponentIndex.SetValue(obj2, b);
			mirrorRpcFunctionHash.SetValue(obj2, registeredRpcHash);
			mirrorRpcPayload.SetValue(obj2, arraySegment);
			mirrorNsSendToAll.Invoke(null, new object[2] { obj2, 0 });
			mirrorWriterPoolReturn.Invoke(null, new object[1] { obj });
		}
		catch (Exception ex2)
		{
			BirdieLog.Warning("[Birdie] Host bridge (broadcast): " + ex2.Message);
		}
	}

	private static void ClientHandleSyncHostConfig(object nbObj, object readerObj, object connObj)
	{
		try
		{
			if (readerObj == null)
			{
				return;
			}
			if (mirrorReaderExtReadBool == null || mirrorReaderExtReadULong == null)
			{
				BirdieLog.Warning("[Birdie] Host bridge client handler: reflection incomplete.");
				return;
			}
			bool flag = (bool)mirrorReaderExtReadBool.Invoke(null, new object[1] { readerObj });
			ulong num = (ulong)mirrorReaderExtReadULong.Invoke(null, new object[1] { readerObj });
			if (flag)
			{
				IsUnderHostControl = true;
				ReceivedFeatureMask = num;
				if ((num & 0x1000) != 0L)
				{
					FlagExpandedSlotsForClient = true;
				}
				BirdieLog.Msg("[Birdie] Host bridge: host control active, featureMask=0x" + num.ToString("X16"));
			}
			else
			{
				IsUnderHostControl = false;
				ReceivedFeatureMask = ulong.MaxValue;
				BirdieLog.Msg("[Birdie] Host bridge: host control deactivated (all features unlocked).");
			}
		}
		catch (Exception ex)
		{
			BirdieLog.Warning("[Birdie] Host bridge client handler: " + ex.Message);
		}
	}

	private static bool CollectReflectionCaches()
	{
		Assembly assembly = null;
		Assembly assembly2 = null;
		Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
		foreach (Assembly assembly3 in assemblies)
		{
			switch (assembly3.GetName().Name)
			{
			case "Mirror":
				assembly = assembly3;
				break;
			case "Assembly-CSharp":
			case "GameAssembly":
				assembly2 = assembly3;
				break;
			}
		}
		if (assembly == null || assembly2 == null)
		{
			return false;
		}
		mirrorNbType = assembly.GetType("Mirror.NetworkBehaviour");
		mirrorReaderType = assembly.GetType("Mirror.NetworkReader");
		mirrorConnType = assembly.GetType("Mirror.NetworkConnectionToClient");
		mirrorRpcType = assembly.GetType("Mirror.RemoteCalls.RemoteProcedureCalls");
		mirrorRcdType = assembly.GetType("Mirror.RemoteCalls.RemoteCallDelegate");
		mirrorRctType = assembly.GetType("Mirror.RemoteCalls.RemoteCallType");
		mirrorRpcMsgType = assembly.GetType("Mirror.RpcMessage");
		mirrorNsType = assembly.GetType("Mirror.NetworkServer");
		mirrorNwpType = assembly.GetType("Mirror.NetworkWriterPool");
		mirrorNwExtType = assembly.GetType("Mirror.NetworkWriterExtensions");
		mirrorNrExtType = assembly.GetType("Mirror.NetworkReaderExtensions");
		if (mirrorNbType == null || mirrorReaderType == null || mirrorConnType == null || mirrorRpcType == null || mirrorRcdType == null || mirrorRctType == null || mirrorRpcMsgType == null || mirrorNsType == null || mirrorNwpType == null || mirrorNwExtType == null || mirrorNrExtType == null)
		{
			return false;
		}
		mirrorRegisterDelegate = mirrorRpcType.GetMethod("RegisterDelegate", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
		MethodInfo method = mirrorNsType.GetMethod("SendToAll", BindingFlags.Static | BindingFlags.Public);
		if (method != null)
		{
			mirrorNsSendToAll = method.MakeGenericMethod(mirrorRpcMsgType);
		}
		mirrorWriterExtWriteBool = mirrorNwExtType.GetMethod("WriteBool", BindingFlags.Static | BindingFlags.Public);
		mirrorWriterExtWriteULong = mirrorNwExtType.GetMethod("WriteULong", BindingFlags.Static | BindingFlags.Public);
		mirrorWriterPoolGet = mirrorNwpType.GetMethod("Get", BindingFlags.Static | BindingFlags.Public);
		mirrorWriterPoolReturn = mirrorNwpType.GetMethod("Return", BindingFlags.Static | BindingFlags.Public);
		Type type = assembly.GetType("Mirror.NetworkWriter");
		if (type != null)
		{
			mirrorWriterToArraySegment = type.GetMethod("ToArraySegment", BindingFlags.Instance | BindingFlags.Public);
		}
		mirrorReaderExtReadBool = mirrorNrExtType.GetMethod("ReadBool", BindingFlags.Static | BindingFlags.Public);
		mirrorReaderExtReadULong = mirrorNrExtType.GetMethod("ReadULong", BindingFlags.Static | BindingFlags.Public);
		mirrorNbNetId = mirrorNbType.GetProperty("netId", BindingFlags.Instance | BindingFlags.Public);
		mirrorNbComponentIndex = mirrorNbType.GetProperty("ComponentIndex", BindingFlags.Instance | BindingFlags.Public);
		mirrorRpcNetId = mirrorRpcMsgType.GetField("netId");
		mirrorRpcComponentIndex = mirrorRpcMsgType.GetField("componentIndex");
		mirrorRpcFunctionHash = mirrorRpcMsgType.GetField("functionHash");
		mirrorRpcPayload = mirrorRpcMsgType.GetField("payload");
		Type type2 = assembly2.GetType("PlayerInventory");
		Type type3 = assembly2.GetType("GameManager");
		if (type3 != null)
		{
			cachedLocalPlayerInventoryProperty = type3.GetProperty("LocalPlayerInventory", BindingFlags.Static | BindingFlags.Public);
		}
		if (mirrorRegisterDelegate != null && mirrorNsSendToAll != null && mirrorWriterExtWriteBool != null && mirrorWriterExtWriteULong != null && mirrorWriterPoolGet != null && mirrorWriterToArraySegment != null && mirrorReaderExtReadBool != null && mirrorReaderExtReadULong != null && mirrorNbNetId != null && mirrorNbComponentIndex != null && mirrorRpcNetId != null)
		{
			return type2 != null;
		}
		return false;
	}

	private static void RegisterRpcHandler()
	{
		if (mirrorRegisterDelegate == null || mirrorRcdType == null || mirrorNbType == null || mirrorReaderType == null || mirrorConnType == null || mirrorRctType == null)
		{
			return;
		}
		Type type = null;
		Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
		for (int i = 0; i < assemblies.Length; i++)
		{
			type = assemblies[i].GetType("PlayerInventory");
			if (type != null)
			{
				break;
			}
		}
		if (type == null)
		{
			BirdieLog.Warning("[Birdie] Host bridge: PlayerInventory type not found.");
			return;
		}
		DynamicMethod dynamicMethod = new DynamicMethod("BirdieHostConfigRpcHandler", typeof(void), new Type[3] { mirrorNbType, mirrorReaderType, mirrorConnType }, typeof(BirdieHostBridge).Module, skipVisibility: true);
		MethodInfo method = typeof(BirdieHostBridge).GetMethod("ClientHandleSyncHostConfig", BindingFlags.Static | BindingFlags.NonPublic);
		if (method == null)
		{
			BirdieLog.Warning("[Birdie] Host bridge: ClientHandleSyncHostConfig not found via reflection.");
			return;
		}
		ILGenerator iLGenerator = dynamicMethod.GetILGenerator();
		iLGenerator.Emit(OpCodes.Ldarg_0);
		iLGenerator.Emit(OpCodes.Ldarg_1);
		iLGenerator.Emit(OpCodes.Ldarg_2);
		iLGenerator.Emit(OpCodes.Call, method);
		iLGenerator.Emit(OpCodes.Ret);
		Delegate @delegate = dynamicMethod.CreateDelegate(mirrorRcdType);
		object obj = Enum.Parse(mirrorRctType, "ClientRpc");
		registeredRpcHash = (ushort)mirrorRegisterDelegate.Invoke(null, new object[5] { type, "System.Void PlayerInventory::BirdieCmdSyncHostConfig(System.Boolean,System.UInt64)", obj, @delegate, false });
		if (registeredRpcHash == 0)
		{
			BirdieLog.Warning("[Birdie] Host bridge: RegisterDelegate returned hash 0 — may indicate a collision.");
		}
	}
}
[BepInPlugin("com.cb12438.birdiemod", "Birdie Mod", "1.3.3")]
public class BirdieMod : BaseUnityPlugin
{
	[Serializable]
	[CompilerGenerated]
	private sealed class <>c
	{
		public static readonly <>c <>9 = new <>c();

		public static UnityAction <>9__633_2;

		internal void <BuildCreditsTab>b__633_2()
		{
			Application.OpenURL("https://discord.gg/EaCRS6TBH9");
		}
	}

	private ManualLogSource Logger;

	private readonly string[] cosmeticUnlockFlagNames = new string[3] { "everythingUnlocked", "forceUnlocked", "isCursorForceUnlocked" };

	private readonly string[] cosmeticRefreshMethodNames = new string[6] { "LoadCosmetics", "SaveCosmetics", "ListCosmeticsUnlocks", "RefreshOptions", "UpdateCosmeticsButtons", "UpdateLoadoutToggles" };

	private Component playerMovement;

	private Component playerGolfer;

	private Component golfBall;

	private readonly Dictionary<string, PropertyInfo> playerGolferProperties = new Dictionary<string, PropertyInfo>(8);

	private readonly Dictionary<string, FieldInfo> playerGolferFields = new Dictionary<string, FieldInfo>(4);

	private MethodInfo addSpeedBoostMethod;

	private FieldInfo swingNormalizedPowerBackingField;

	private bool playerFound;

	private bool assistEnabled;

	private bool isLeftMousePressed;

	private bool isRightMousePressed;

	private bool autoReleaseTriggeredThisCharge;

	private bool autoChargeSequenceStarted;

	private int lastAutoSwingReleaseFrame = -1;

	private float nextTryStartChargingTime;

	private readonly float tryStartChargingInterval = 0.05f;

	private float idealSwingPower;

	private float idealSwingPitch;

	private Vector3 flagPosition = Vector3.zero;

	private Vector3 holePosition = Vector3.zero;

	private Vector3 currentAimTargetPosition = Vector3.zero;

	private Vector3 currentSwingOriginPosition = Vector3.zero;

	private Vector3 aimTargetOffsetLocal = Vector3.zero;

	private readonly Vector3 swingOriginLocalOffset = new Vector3(0.86f, 0.05f, -0.12f);

	private string cachedLocalPlayerDisplayName = "";

	private float nextDisplayNameRefreshTime;

	private readonly float displayNameRefreshInterval = 0.5f;

	private int cachedAllGameObjectsFrame = -1;

	private GameObject[] cachedAllGameObjects;

	private int cachedAllComponentsFrame = -1;

	private Component[] cachedAllComponents;

	private float nextPlayerSearchTime;

	private float nextHoleSearchTime;

	private float nextIdealSwingCalculationTime;

	private float nextBallResolveTime;

	private readonly float playerSearchInterval = 1f;

	private readonly float holeSearchInterval = 0.5f;

	private readonly float idealSwingCalculationInterval = 0.25f;

	private readonly float ballResolveInterval = 0.2f;

	private readonly float puttDistanceThreshold = 12f;

	private bool hadResolvedPlayerContext;

	private bool hadResolvedBallContext;

	private string lastBallResolveSource = "missing";

	private Component initializedPlayerGolfer;

	private GameObject hudCanvas;

	private TextMeshProUGUI leftHudText;

	private TextMeshProUGUI centerHudText;

	private TextMeshProUGUI rightHudText;

	private TextMeshProUGUI bottomHudText;

	private bool isAimModeActive;

	private bool wasAimRequestedLastFrame;

	private bool reflectionCacheInitialized;

	private MethodInfo cachedTryGetMethod;

	private MethodInfo cachedOrbitSetYawMethod;

	private MethodInfo cachedOrbitSetPitchMethod;

	private MethodInfo cachedOrbitForceUpdateMethod;

	private MethodInfo cachedEnterSwingAimCameraMethod;

	private MethodInfo cachedExitSwingAimCameraMethod;

	private MethodInfo cachedReachOrbitSteadyStateMethod;

	private Component initializedYawPlayerMovement;

	private PropertyInfo cachedPlayerMovementYawProperty;

	private FieldInfo cachedPlayerMovementYawField;

	private Component initializedYawPlayerGolfer;

	private PropertyInfo cachedPlayerGolferYawProperty;

	private FieldInfo cachedPlayerGolferYawField;

	private bool cameraAimSmoothingInitialized;

	private float smoothedOrbitYaw;

	private float smoothedOrbitPitch;

	private float orbitYawVelocity;

	private float orbitPitchVelocity;

	private readonly float orbitAimSmoothTime = 0.02f;

	private readonly float orbitAimMaxSpeed = 2160f;

	private readonly object[] cachedOrbitModuleQueryArgs = new object[1];

	private readonly object[] cachedOrbitYawArgs = new object[1];

	private readonly object[] cachedOrbitPitchArgs = new object[1];

	private bool swingMathReflectionInitialized;

	private PropertyInfo cachedGolfSettingsProperty;

	private object cachedGolfSettingsObject;

	private PropertyInfo cachedGolfBallSettingsProperty;

	private object cachedGolfBallSettingsObject;

	private MethodInfo cachedBMathEaseInMethod;

	private MethodInfo cachedUpdateSwingNormalizedPowerMethod;

	private bool matchSetupRulesReflectionInitialized;

	private Type cachedMatchSetupRuleEnumType;

	private MethodInfo cachedMatchSetupGetValueMethod;

	private object cachedMatchSetupSwingPowerRuleValue;

	private PropertyInfo cachedLocalPlayerAsGolferProperty;

	private bool localGolferResolverInitialized;

	private MethodInfo cachedTryStartChargingSwingMethod;

	private MethodInfo cachedSetIsChargingSwingMethod;

	private MethodInfo cachedReleaseSwingChargeMethod;

	private float lastObservedSwingPower;

	private readonly float[] launchModelPowers = new float[4] { 0.1f, 0.5f, 1f, 1.15f };

	private readonly float[] launchModelSpeeds = new float[4] { 17f, 85f, 170f, 195.5f };

	private readonly float launchModelReferenceSrvMul = 2f;

	private bool golfBallVelocityReflectionInitialized;

	private Type cachedGolfBallTypeForVelocity;

	private PropertyInfo cachedGolfBallRigidbodyProperty;

	private bool rigidbodyVelocityReflectionInitialized;

	private PropertyInfo cachedRigidbodyLinearVelocityProperty;

	private readonly float trajectoryGravity = 9.81f;

	private bool windReflectionInitialized;

	private PropertyInfo cachedWindManagerWindProperty;

	private float windFactor = 1f;

	private float crossWindFactor = 1f;

	private bool swingHittableReflectionInitialized;

	private Component cachedGolfBallForHittable;

	private float cachedMaxPowerSwingHitSpeed = 85f;

	private float cachedMaxPowerPuttHitSpeed = 15f;

	private Vector3 windAimOffset = Vector3.zero;

	private GameObject shotPathObject;

	private LineRenderer shotPathLine;

	private Material shotPathMaterial;

	private GameObject predictedPathObject;

	private LineRenderer predictedPathLine;

	private Material predictedPathMaterial;

	private GameObject frozenPredictedPathObject;

	private LineRenderer frozenPredictedPathLine;

	private Material frozenPredictedPathMaterial;

	private readonly List<Vector3> shotPathPoints = new List<Vector3>(768);

	private readonly List<Vector3> predictedPathPoints = new List<Vector3>(384);

	private readonly List<Vector3> frozenPredictedPathPoints = new List<Vector3>(384);

	private bool predictedImpactPreviewValid;

	private Vector3 predictedImpactPreviewPoint = Vector3.zero;

	private Vector3 predictedImpactPreviewApproachDirection = Vector3.forward;

	private bool frozenImpactPreviewValid;

	private Vector3 frozenImpactPreviewPoint = Vector3.zero;

	private Vector3 frozenImpactPreviewApproachDirection = Vector3.forward;

	private bool lockLivePredictedPath;

	private bool observedBallMotionSinceLastShot;

	private bool isRecordingShotPath;

	private float predictedTrajectoryHideStartTime;

	private float nextPredictedPathRefreshTime;

	private Vector3 lastShotPathBallPosition = Vector3.zero;

	private float lastShotPathMoveTime;

	private readonly float predictedUnlockSpeedThreshold = 0.12f;

	private readonly float shotPathHeightOffset = 0.14f;

	private readonly float shotPathMoveThreshold = 0.004f;

	private readonly float shotPathPointSpacing = 0.012f;

	private readonly int shotPathMaxPoints = 3072;

	private readonly float shotPathStationaryDelay = 0.65f;

	private readonly int predictedPathMaxSteps = 360;

	private readonly float predictedPathMaxTime = 7.2f;

	private readonly float predictedPathPointSpacing = 0.3f;

	private readonly float predictedPathRefreshInterval = 0.05f;

	private readonly float predictedTrajectoryUnlockFallbackDelay = 0.75f;

	private bool predictedPathCacheValid;

	private Component cachedPredictedPathBall;

	private Vector3 cachedPredictedShotOrigin = Vector3.zero;

	private Vector3 cachedPredictedAimTargetPosition = Vector3.zero;

	private float cachedPredictedSwingPower;

	private float cachedPredictedSwingPitch;

	private readonly float predictedPathRebuildDistanceEpsilon = 0.015f;

	private readonly float predictedPathRebuildPowerEpsilon = 0.0025f;

	private readonly float predictedPathRebuildPitchEpsilon = 0.05f;

	private readonly string configPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Mods", "BirdieMod.cfg");

	private string assistToggleKeyName = "F";

	private string coffeeBoostKeyName = "F2";

	private string nearestBallModeKeyName = "F3";

	private string unlockAllCosmeticsKeyName = "F4";

	private string itemSpawnerKeyName = "F5";

	private string hudToggleKeyName = "H";

	private string randomItemKeyName = "G";

	private string assistToggleKeyLabel = "F";

	private string coffeeBoostKeyLabel = "F2";

	private string nearestBallModeKeyLabel = "F3";

	private string unlockAllCosmeticsKeyLabel = "F4";

	private string itemSpawnerKeyLabel = "F5";

	private string hudToggleKeyLabel = "H";

	private string randomItemKeyLabel = "G";

	private Key assistToggleKey = (Key)20;

	private Key coffeeBoostKey = (Key)95;

	private Key nearestBallModeKey = (Key)96;

	private Key unlockAllCosmeticsKey = (Key)97;

	private Key itemSpawnerKey = (Key)98;

	private Key hudToggleKey = (Key)22;

	private Key randomItemKey = (Key)21;

	private bool hudVisible = true;

	private bool itemMenuOpen;

	private GameObject itemMenuPanelObject;

	private TextMeshProUGUI itemMenuText;

	private bool actualTrailEnabled = true;

	private bool predictedTrailEnabled = true;

	private bool frozenTrailEnabled = true;

	private bool impactPreviewEnabled = true;

	private float impactPreviewTargetFps;

	private int impactPreviewTextureWidth = 640;

	private int impactPreviewTextureHeight = 360;

	private float actualTrailStartWidth = 0.22f;

	private float actualTrailEndWidth = 0.18f;

	private float predictedTrailStartWidth = 0.18f;

	private float predictedTrailEndWidth = 0.14f;

	private float frozenTrailStartWidth = 0.2f;

	private float frozenTrailEndWidth = 0.16f;

	private Color actualTrailColor = new Color(1f, 0.58f, 0.2f, 1f);

	private Color predictedTrailColor = new Color(0.36f, 0.95f, 0.46f, 0.95f);

	private Color frozenTrailColor = new Color(0.36f, 0.74f, 1f, 0.92f);

	private bool visualsInitialized;

	private readonly float visualsInitializationDelay = 2.5f;

	private bool trailVisualSettingsDirty = true;

	private bool actualTrailLineDirty = true;

	private bool predictedTrailLineDirty = true;

	private bool frozenTrailLineDirty = true;

	private bool hudDirty = true;

	private float nextHudRefreshTime;

	private readonly float hudRefreshInterval = 0.1f;

	private string cachedLeftHudText = "";

	private string cachedCenterHudText = "";

	private string cachedRightHudText = "";

	private string cachedBottomHudText = "";

	private bool nearestAnyBallModeEnabled;

	private float nextNearestAnyBallResolveTime;

	private readonly float nearestAnyBallResolveInterval = 0.1f;

	private readonly List<Component> cachedGolfBalls = new List<Component>(64);

	private float nextGolfBallCacheRefreshTime;

	private readonly float golfBallCacheRefreshInterval = 0.75f;

	private readonly float emptyGolfBallCacheRefreshInterval = 2f;

	private float nextImpactPreviewRenderTime;

	private Camera cachedImpactPreviewReferenceCamera;

	private float nextImpactPreviewReferenceCameraRefreshTime;

	private readonly float impactPreviewReferenceCameraRefreshInterval = 1f;

	private readonly float impactPreviewAutoTargetFps = 60f;

	private readonly RaycastHit[] impactPreviewRaycastHits = (RaycastHit[])(object)new RaycastHit[24];

	private readonly RaycastHit[] impactPreviewGroundProbeHits = (RaycastHit[])(object)new RaycastHit[24];

	private readonly object[] cachedSpeedBoostArgs = new object[1];

	private readonly object[] cachedEaseInArgs = new object[1];

	private readonly object[] cachedMatchSetupGetValueArgs = new object[1];

	private readonly object[] cachedChargingStateArgs = new object[1];

	private readonly object[] cachedUpdateSwingPowerArgs = new object[2] { true, false };

	private string iceToggleKeyName = "I";

	private string iceToggleKeyLabel = "I";

	private Key iceToggleKey = (Key)23;

	private bool iceImmunityEnabled;

	private bool iceReflectionInitialized;

	private FieldInfo cachedHorizontalDragField;

	private PropertyInfo cachedPlayerMovementSettingsProperty;

	private float normalHorizontalDragValue = 10f;

	private string settingsKeyName = "F6";

	private string settingsKeyLabel = "F6";

	private Key settingsKey = (Key)99;

	private bool settingsPanelOpen;

	private int settingsTabIndex;

	private bool keybindRebindMode;

	private int keybindRebindIndex = -1;

	private GameObject settingsPanelObject;

	private static Sprite s_roundedLg = null;

	private static Sprite s_roundedMd = null;

	private static Sprite s_roundedSm = null;

	private static Sprite s_pillSprite = null;

	private static Sprite s_circleSprite = null;

	private Button[] settingsV2NavButtons = (Button[])(object)new Button[5];

	private GameObject[] settingsV2TabPanels = (GameObject[])(object)new GameObject[5];

	private Button[] settingsKeybindRowButtons;

	private Image[] settingsHudTogglePillBgs;

	private TMP_InputField settingsCreditsInputField;

	private TextMeshProUGUI settingsKeybindRebindStatusLabel;

	private bool settingsInputReflectionInitialized;

	private MethodInfo cachedCursorSetForceUnlockedMethod;

	private MethodInfo cachedInputManagerEnableModeMethod;

	private MethodInfo cachedInputManagerDisableModeMethod;

	private object cachedInputModePausedValue;

	private int creditsGrantAmount = 1000;

	private bool creditsReflectionInitialized;

	private MethodInfo cachedRewardCreditsMethod;

	private bool hudShowBottomBar = true;

	private bool hudShowBallDistance = true;

	private bool hudShowIceIndicator = true;

	private bool hudShowCenterTitle = true;

	private bool hudShowPlayerInfo = true;

	private bool tracersEnabled = true;

	private string noWindKeyName = "F7";

	private string noWindKeyLabel = "F7";

	private Key noWindKey = (Key)100;

	private bool noWindEnabled;

	private bool windExtrasReflectionInitialized;

	private object cachedWindSettingsInstance;

	private FieldInfo cachedWindForceScaleField;

	private float savedWindForceScale = 1f;

	private string perfectShotKeyName = "F8";

	private string perfectShotKeyLabel = "F8";

	private Key perfectShotKey = (Key)101;

	private bool perfectShotEnabled;

	private string noAirDragKeyName = "F9";

	private string noAirDragKeyLabel = "F9";

	private Key noAirDragKey = (Key)102;

	private bool noAirDragEnabled;

	private bool airDragExtrasReflectionInitialized;

	private FieldInfo cachedLinearAirDragField;

	private float savedLinearAirDrag = 0.01f;

	private string speedMultiplierKeyName = "F10";

	private string speedMultiplierKeyLabel = "F10";

	private Key speedMultiplierKey = (Key)103;

	private bool speedMultiplierEnabled;

	private float speedMultiplierFactor = 2f;

	private bool moveSpeedExtrasReflectionInitialized;

	private PropertyInfo cachedPlayerMovSettingsProperty;

	private FieldInfo cachedDefaultMoveSpeedField;

	private float savedDefaultMoveSpeed = 7f;

	private string infiniteAmmoKeyName = "F11";

	private string infiniteAmmoKeyLabel = "F11";

	private Key infiniteAmmoKey = (Key)104;

	private bool infiniteAmmoEnabled;

	private bool ammoInventoryReflectionReady;

	private FieldInfo cachedInventorySlotsSyncListField;

	private FieldInfo cachedInventoryOverridesDictField;

	private FieldInfo cachedInvSlotItemTypeField;

	private ConstructorInfo cachedInvSlotConstructor;

	private readonly Dictionary<int, object> ammoItemTypeBackup = new Dictionary<int, object>();

	private string noRecoilKeyName = "F12";

	private string noRecoilKeyLabel = "F12";

	private Key noRecoilKey = (Key)105;

	private bool noRecoilEnabled;

	private bool screenshakeExtrasReflectionInitialized;

	private object cachedScreenshakeOwner;

	private FieldInfo cachedScreenshakeFactorField;

	private float savedScreenshakeFactor = 1f;

	private string noKnockbackKeyName = "N";

	private string noKnockbackKeyLabel = "N";

	private Key noKnockbackKey = (Key)28;

	private bool noKnockbackEnabled;

	private bool knockbackImmunityReflectionReady;

	private FieldInfo cachedKnockoutImmunityStatusField;

	private FieldInfo cachedHasImmunityField;

	private Component localPlayerHittable;

	private string landmineImmunityKeyName = "M";

	private string landmineImmunityKeyLabel = "M";

	private Key landmineImmunityKey = (Key)27;

	private bool landmineImmunityEnabled;

	private string lockOnAnyDistanceKeyName = "L";

	private string lockOnAnyDistanceKeyLabel = "L";

	private Key lockOnAnyDistanceKey = (Key)26;

	private bool lockOnAnyDistanceEnabled;

	private bool lockOnReflectionInitialized;

	private FieldInfo cachedLockOnMaxDistanceField;

	private float savedLockOnMaxDistance = 60f;

	private string expandedSlotsKeyName = "U";

	private string expandedSlotsKeyLabel = "U";

	private Key expandedSlotsKey = (Key)35;

	private bool expandedSlotsEnabled;

	private bool expandedSlotsAllPlayers = true;

	private const int ExpandedSlotsTarget = 7;

	private bool expandedSlotsReflectionInitialized;

	private object cachedExpandedHotkeysInstance;

	private FieldInfo cachedHotkeyUisField;

	private object cachedExpandedPlayerInvSettings;

	private FieldInfo cachedMaxItemsBackingField;

	private int savedOriginalMaxItems = 3;

	private Array savedOriginalHotkeyUisArray;

	private List<GameObject> spawnedExtraHotkeyUiObjects = new List<GameObject>();

	private Vector2 savedSlotParentSizeDelta;

	private bool savedSlotParentMaskEnabled;

	private Transform savedSlotParentTransform;

	private bool hostControlsActive;

	private ulong hostAllowedFeatureMask = 65535uL;

	private byte _hostSelectedWeather;

	private bool _hostWeatherRunning;

	private static bool _perfectShotLogged;

	private GameObject impactPreviewPanelObject;

	private RawImage impactPreviewRawImage;

	private RenderTexture impactPreviewTexture;

	private GameObject impactPreviewCameraObject;

	private Camera impactPreviewCamera;

	private readonly float impactPreviewLookHeightOffset = 0.65f;

	private readonly float impactPreviewProbeHeight = 36f;

	private readonly float impactPreviewCameraMinDistance = 9.5f;

	private readonly float impactPreviewCameraMaxDistance = 20f;

	private readonly float impactPreviewCameraMinHeight = 6.2f;

	private readonly float impactPreviewCameraMaxHeight = 12.5f;

	private readonly float impactPreviewFieldOfView = 52f;

	private readonly float impactPreviewOrbitDegreesPerSecond = 26f;

	private readonly float impactPreviewGroundClearance = 1.85f;

	private readonly float impactPreviewMinVerticalLookOffset = 2.25f;

	private const int CoffeeItemTypeInt = 1;

	private static readonly int[] SpawnableItemTypeInts = new int[12]
	{
		1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
		11, 12
	};

	private static readonly string[] SpawnableItemNames = new string[12]
	{
		"Coffee", "Dueling Pistol", "Elephant Gun", "Airhorn", "Spring Boots", "Golf Cart", "Rocket Launcher", "Landmine", "Electromagnet", "Orbital Laser",
		"Rocket Driver", "Freeze Bomb"
	};

	private static readonly Key[] SpawnableItemKeys;

	private static readonly string[] SpawnableItemKeyLabels;

	private bool itemSpawnerReflectionInitialized;

	private bool dispenserReflectionInitialized;

	private Type cachedItemDispenserType;

	private FieldInfo cachedItemDispenserItemTypeField;

	private PropertyInfo cachedItemDispenserIsEnabledProperty;

	private MethodInfo cachedItemDispenserCmdDispenseMethod;

	private Type cachedPhysicalItemType;

	private FieldInfo cachedPhysicalItemItemTypeField;

	private MethodInfo cachedCmdGiveToPlayerMethod;

	private bool dispenserPickupPending;

	private int dispenserPickupItemTypeInt;

	private Component dispenserPickupLocalInventory;

	private float dispenserPickupDeadline;

	private const float dispenserPickupTimeout = 2.5f;

	private bool crateReflectionInitialized;

	private bool pendingCrateTeleport;

	private float pendingCrateTeleportExpiry;

	private const float crateTeleportConfirmWindow = 3f;

	private bool crateReturnPending;

	private Vector3 crateReturnPosition;

	private Type cachedItemSpawnerType;

	private FieldInfo cachedItemSpawnerSettingsField;

	private PropertyInfo cachedItemSpawnerNetHasItemBoxProp;

	private Type cachedItemSpawnerSettingsType;

	private MethodInfo cachedGetRandomItemForMethod;

	private PropertyInfo cachedInventoryPlayerInfoProp;

	private PropertyInfo cachedNetworkServerActiveProperty;

	private bool cachedNetworkServerPropertyInit;

	private PropertyInfo cachedLocalPlayerInventoryProperty;

	private PropertyInfo cachedAllItemsProperty;

	private MethodInfo cachedTryGetItemDataMethod;

	private PropertyInfo cachedItemDataMaxUsesProperty;

	private Type cachedItemTypeEnumType;

	private MethodInfo cachedServerTryAddItemMethod;

	private Rect _imRect;

	private bool _imRectInit;

	private Vector2 _imFeaturesScroll;

	private Vector2 _imKeysScroll;

	private bool _imStylesReady;

	private GUIStyle _imWindowStyle;

	private GUIStyle _imTitleStyle;

	private GUIStyle _imTabActive;

	private GUIStyle _imTabIdle;

	private GUIStyle _imSectionLabel;

	private GUIStyle _imToggleOn;

	private GUIStyle _imToggleOff;

	private GUIStyle _imActionLabel;

	private GUIStyle _imKeyBadge;

	private GUIStyle _imRebindActive;

	private GUIStyle _imButton;

	private GUIStyle _imCloseBtn;

	private GUIStyle _imInfoLabel;

	private GUIStyle _imDescLabel;

	private Texture2D _imTxDark;

	private Texture2D _imTxBlue;

	private Texture2D _imTxGrey;

	private Texture2D _imTxDarker;

	private Texture2D _imTxRed;

	private Texture2D _imTxGreen;

	private Texture2D _imTxSeparator;

	private Vector2 _imItemsScroll;

	private Vector2 _imNetScroll;

	private static readonly string[] SettingsKeybindDisplayNames;

	private static readonly Key[] SettingsSelectionKeys;

	private byte _currentWeatherType;

	private bool _weatherPhysicsApplied;

	private float _originalLinearAirDrag;

	private bool _originalAirDragCached;

	private float _originalWindForceScale;

	private bool _originalWindForceScaleCached;

	private float _nextLightningTime;

	private float _nextGustTime;

	private float _tornadoMoveTimer;

	private Vector3 _tornadoWorldPosition;

	private bool _tornadoPositionSet;

	private float _lightningFlashEndTime;

	private bool _lightningStrikePending;

	private Vector3 _pendingLightningStrikePosition;

	internal bool autoWeatherEnabled;

	internal int autoWeatherChance = 40;

	internal int[] autoWeatherChances = new int[8] { 50, 35, 20, 40, 25, 10, 15, 5 };

	private bool _holeEventSubscribed;

	private float _tornadoFlingNextTime;

	private bool _wAirDragReady;

	private FieldInfo _wAirDragField;

	private object _wBallSettings;

	private bool _wWindReady;

	private object _wWindSettings;

	private FieldInfo _wWindScaleField;

	private bool _wWmReady;

	private Type _wWmType;

	private PropertyInfo _wWmSpeedProp;

	private PropertyInfo _wWmAngleProp;

	private bool _gustRunning;

	private bool _lightningRunning;

	private float _currentRainDragMul = 1f;

	private float _nextWindDragUpdateTime;

	private float _nextErraticWindShiftTime;

	private object _cachedWmObject;

	private float _nextWmCacheRefreshTime;

	private readonly List<Material> _weatherMaterials = new List<Material>();

	private GameObject _weatherVfxRoot;

	private ParticleSystem _rainPs;

	private ParticleSystem _tornadoPs;

	private Light _lightningLight;

	private AudioSource _weatherAudio;

	private bool _lightningScreenFlash;

	private float _lightningScreenFlashEnd;

	private bool _playerStruckFlash;

	private float _playerStruckFlashEnd;

	private AudioSource _weatherAudio2;

	private AudioClip _clipRainLoop;

	private AudioClip _clipWindLoop;

	private AudioClip _clipWindGust;

	private AudioClip _clipThunderCrack;

	private AudioClip _clipTornadoLoop;

	private bool _soundsLoaded;

	private void Awake()
	{
		Logger = ((BaseUnityPlugin)this).Logger;
		BirdieLog.MsgImpl = delegate(string s)
		{
			Logger.LogInfo((object)s);
		};
		BirdieLog.WarnImpl = delegate(string s)
		{
			Logger.LogWarning((object)s);
		};
		BirdieCoroutine.StartImpl = delegate(IEnumerator e)
		{
			((MonoBehaviour)this).StartCoroutine(e);
		};
		BirdieInit();
	}

	private void Update()
	{
		BirdieUpdate();
	}

	private void LateUpdate()
	{
		BirdieLateUpdate();
	}

	private void OnGUI()
	{
		BirdieOnGUI();
	}

	private void InitializeReflectionCache()
	{
		if (reflectionCacheInitialized)
		{
			return;
		}
		try
		{
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			foreach (Assembly assembly in assemblies)
			{
				if (cachedTryGetMethod == null)
				{
					Type type = assembly.GetType("CameraModuleController");
					if (type != null)
					{
						cachedTryGetMethod = type.GetMethod("TryGetOrbitModule", BindingFlags.Static | BindingFlags.Public);
					}
				}
				if (cachedEnterSwingAimCameraMethod == null)
				{
					Type type2 = assembly.GetType("GameplayCameraManager");
					if (type2 != null)
					{
						cachedEnterSwingAimCameraMethod = type2.GetMethod("EnterSwingAimCamera", BindingFlags.Static | BindingFlags.Public);
						cachedExitSwingAimCameraMethod = type2.GetMethod("ExitSwingAimCamera", BindingFlags.Static | BindingFlags.Public);
						cachedReachOrbitSteadyStateMethod = type2.GetMethod("ReachOrbitCameraSteadyState", BindingFlags.Static | BindingFlags.Public);
					}
				}
				if (cachedTryGetMethod != null && cachedEnterSwingAimCameraMethod != null)
				{
					break;
				}
			}
			object obj = TryGetOrbitModule();
			if (obj != null)
			{
				Type type3 = obj.GetType();
				cachedOrbitSetYawMethod = type3.GetMethod("SetYaw", BindingFlags.Instance | BindingFlags.Public);
				cachedOrbitSetPitchMethod = type3.GetMethod("SetPitch", BindingFlags.Instance | BindingFlags.Public);
				cachedOrbitForceUpdateMethod = type3.GetMethod("ForceUpdateModule", BindingFlags.Instance | BindingFlags.Public);
			}
		}
		catch
		{
		}
		reflectionCacheInitialized = true;
	}

	private object TryGetOrbitModule()
	{
		if (cachedTryGetMethod == null)
		{
			return null;
		}
		try
		{
			cachedOrbitModuleQueryArgs[0] = null;
			return ((bool)cachedTryGetMethod.Invoke(null, cachedOrbitModuleQueryArgs)) ? cachedOrbitModuleQueryArgs[0] : null;
		}
		catch
		{
			return null;
		}
	}

	private FieldInfo FindYawField(Type componentType)
	{
		FieldInfo field = componentType.GetField("targetYaw", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
		if (!(field != null) || !(field.FieldType == typeof(float)))
		{
			return null;
		}
		return field;
	}

	private void CacheYawAccessorsForComponent(Component component, ref Component initializedComponent, ref PropertyInfo yawProperty, ref FieldInfo yawField)
	{
		if ((Object)(object)component == (Object)null)
		{
			initializedComponent = null;
			yawProperty = null;
			yawField = null;
		}
		else if (initializedComponent != component)
		{
			initializedComponent = component;
			Type type = ((object)component).GetType();
			yawProperty = type.GetProperty("Yaw", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			yawField = FindYawField(type);
		}
	}

	private void EnsureAimYawAccessors()
	{
		CacheYawAccessorsForComponent(playerMovement, ref initializedYawPlayerMovement, ref cachedPlayerMovementYawProperty, ref cachedPlayerMovementYawField);
		CacheYawAccessorsForComponent(playerGolfer, ref initializedYawPlayerGolfer, ref cachedPlayerGolferYawProperty, ref cachedPlayerGolferYawField);
	}

	private void ApplyYawToAimComponent(Component component, PropertyInfo yawProperty, FieldInfo yawField, float targetYaw)
	{
		//IL_008e: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)component == (Object)null)
		{
			return;
		}
		try
		{
			if (yawProperty != null && yawProperty.CanWrite && yawProperty.PropertyType == typeof(float))
			{
				yawProperty.SetValue(component, targetYaw, null);
			}
		}
		catch
		{
		}
		try
		{
			if (yawField != null && yawField.FieldType == typeof(float))
			{
				yawField.SetValue(component, targetYaw);
			}
		}
		catch
		{
		}
		try
		{
			component.transform.rotation = Quaternion.Euler(0f, targetYaw, 0f);
		}
		catch
		{
		}
	}

	private void ApplyAimDirectionToSwingSubject(float targetYaw)
	{
		EnsureAimYawAccessors();
		ApplyYawToAimComponent(playerMovement, cachedPlayerMovementYawProperty, cachedPlayerMovementYawField, targetYaw);
		if (playerGolfer != playerMovement)
		{
			ApplyYawToAimComponent(playerGolfer, cachedPlayerGolferYawProperty, cachedPlayerGolferYawField, targetYaw);
		}
	}

	private void SetSwingAimCameraState(bool enabled)
	{
		if (enabled == wasAimRequestedLastFrame)
		{
			return;
		}
		wasAimRequestedLastFrame = enabled;
		MethodInfo methodInfo = (enabled ? cachedEnterSwingAimCameraMethod : cachedExitSwingAimCameraMethod);
		if (methodInfo == null)
		{
			return;
		}
		try
		{
			methodInfo.Invoke(null, null);
			if (enabled && cachedReachOrbitSteadyStateMethod != null)
			{
				cachedReachOrbitSteadyStateMethod.Invoke(null, null);
			}
		}
		catch
		{
		}
	}

	private void DisableAutoAimCamera()
	{
		isAimModeActive = false;
		cameraAimSmoothingInitialized = false;
		orbitYawVelocity = 0f;
		orbitPitchVelocity = 0f;
		SetSwingAimCameraState(enabled: false);
	}

	private bool IsPlayerAimingSwing()
	{
		if ((Object)(object)playerGolfer == (Object)null)
		{
			return false;
		}
		if (!playerGolferProperties.TryGetValue("IsAimingSwing", out var value) || value == null)
		{
			return false;
		}
		try
		{
			return Convert.ToBoolean(value.GetValue(playerGolfer, null));
		}
		catch
		{
			return false;
		}
	}

	private void AutoAimCamera()
	{
		//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_0094: Unknown result type (might be due to invalid IL or missing references)
		//IL_0099: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
		//IL_00be: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00db: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f8: 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_0116: Unknown result type (might be due to invalid IL or missing references)
		//IL_011b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0120: Unknown result type (might be due to invalid IL or missing references)
		//IL_0146: Unknown result type (might be due to invalid IL or missing references)
		//IL_014c: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b7: 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_01cc: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
		if (!assistEnabled || (!isLeftMousePressed && !isRightMousePressed) || !IsPlayerAimingSwing() || (Object)(object)playerGolfer == (Object)null || holePosition == Vector3.zero)
		{
			DisableAutoAimCamera();
			return;
		}
		try
		{
			InitializeReflectionCache();
			object obj = TryGetOrbitModule();
			if (obj == null || cachedOrbitSetYawMethod == null || cachedOrbitSetPitchMethod == null)
			{
				DisableAutoAimCamera();
				return;
			}
			SetSwingAimCameraState(enabled: true);
			Vector3 position = playerGolfer.transform.position;
			Vector3 playerPosition = (((Object)(object)golfBall != (Object)null) ? golfBall.transform.position : position);
			currentAimTargetPosition = GetAimTargetPosition(playerPosition) + windAimOffset;
			currentSwingOriginPosition = GetSwingOriginPosition();
			if (currentAimTargetPosition == Vector3.zero || currentSwingOriginPosition == Vector3.zero)
			{
				DisableAutoAimCamera();
				return;
			}
			Vector3 val = currentAimTargetPosition - currentSwingOriginPosition;
			val.y = 0f;
			if (((Vector3)(ref val)).sqrMagnitude < 0.0001f)
			{
				DisableAutoAimCamera();
				return;
			}
			float num = Mathf.Atan2(val.x, val.z) * 57.29578f;
			float magnitude = ((Vector3)(ref val)).magnitude;
			float num2 = Mathf.Clamp(magnitude * 0.9f, 4f, 15f);
			float num3 = Mathf.Lerp(3.25f, 8f, Mathf.InverseLerp(0f, 25f, magnitude));
			Vector3 val2 = position - ((Vector3)(ref val)).normalized * num2;
			val2.y += num3;
			Vector3 val3 = currentAimTargetPosition - val2;
			float num4 = (0f - Mathf.Asin(Mathf.Clamp(((Vector3)(ref val3)).normalized.y, -0.999f, 0.999f))) * 57.29578f;
			if (!cameraAimSmoothingInitialized || !isAimModeActive)
			{
				smoothedOrbitYaw = num;
				smoothedOrbitPitch = num4;
				orbitYawVelocity = 0f;
				orbitPitchVelocity = 0f;
				cameraAimSmoothingInitialized = true;
			}
			else
			{
				float num5 = Mathf.Max(0.0001f, Time.deltaTime);
				smoothedOrbitYaw = Mathf.SmoothDampAngle(smoothedOrbitYaw, num, ref orbitYawVelocity, orbitAimSmoothTime, orbitAimMaxSpeed, num5);
				smoothedOrbitPitch = Mathf.SmoothDampAngle(smoothedOrbitPitch, num4, ref orbitPitchVelocity, orbitAimSmoothTime, orbitAimMaxSpeed, num5);
			}
			ApplyAimDirectionToSwingSubject(smoothedOrbitYaw);
			cachedOrbitYawArgs[0] = smoothedOrbitYaw;
			cachedOrbitPitchArgs[0] = smoothedOrbitPitch;
			cachedOrbitSetYawMethod.Invoke(obj, cachedOrbitYawArgs);
			cachedOrbitSetPitchMethod.Invoke(obj, cachedOrbitPitchArgs);
			if (cachedOrbitForceUpdateMethod != null)
			{
				cachedOrbitForceUpdateMethod.Invoke(obj, null);
			}
			isAimModeActive = true;
		}
		catch
		{
			DisableAutoAimCamera();
		}
	}

	private void LoadOrCreateConfig()
	{
		ApplyDefaultConfig();
		try
		{
			string directoryName = Path.GetDirectoryName(configPath);
			if (!string.IsNullOrEmpty(directoryName))
			{
				Directory.CreateDirectory(directoryName);
			}
			if (!File.Exists(configPath))
			{
				File.WriteAllText(configPath, BuildDefaultConfigText(), Encoding.ASCII);
			}
			else
			{
				LoadConfigFromFile(configPath);
			}
		}
		catch
		{
		}
		UpdateConfigLabels();
		MarkHudDirty();
		MarkTrailVisualSettingsDirty();
		nextImpactPreviewRenderTime = 0f;
	}

	private void ApplyDefaultConfig()
	{
		//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c5: 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_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)
		assistToggleKeyName = "F1";
		coffeeBoostKeyName = "F2";
		nearestBallModeKeyName = "F3";
		unlockAllCosmeticsKeyName = "F4";
		itemSpawnerKeyName = "F5";
		hudToggleKeyName = "H";
		randomItemKeyName = "G";
		iceToggleKeyName = "I";
		settingsKeyName = "F6";
		noWindKeyName = "W";
		perfectShotKeyName = "P";
		noAirDragKeyName = "D";
		speedMultiplierKeyName = "S";
		speedMultiplierFactor = 2f;
		infiniteAmmoKeyName = "A";
		noRecoilKeyName = "R";
		noKnockbackKeyName = "K";
		landmineImmunityKeyName = "M";
		lockOnAnyDistanceKeyName = "L";
		expandedSlotsKeyName = "U";
		hudShowBottomBar = true;
		hudShowBallDistance = true;
		hudShowIceIndicator = true;
		hudShowCenterTitle = true;
		hudShowPlayerInfo = true;
		tracersEnabled = true;
		creditsGrantAmount = 1000;
		actualTrailEnabled = true;
		predictedTrailEnabled = true;
		frozenTrailEnabled = true;
		impactPreviewEnabled = true;
		impactPreviewTargetFps = impactPreviewAutoTargetFps;
		impactPreviewTextureWidth = 640;
		impactPreviewTextureHeight = 360;
		actualTrailStartWidth = 0.22f;
		actualTrailEndWidth = 0.18f;
		predictedTrailStartWidth = 0.18f;
		predictedTrailEndWidth = 0.14f;
		frozenTrailStartWidth = 0.2f;
		frozenTrailEndWidth = 0.16f;
		actualTrailColor = new Color(1f, 0.58f, 0.2f, 1f);
		predictedTrailColor = new Color(0.36f, 0.95f, 0.46f, 0.95f);
		frozenTrailColor = new Color(0.36f, 0.74f, 1f, 0.92f);
		hostAllowedFeatureMask = 16383uL;
	}

	private void LoadConfigFromFile(string path)
	{
		//IL_0bee: Unknown result type (might be due to invalid IL or missing references)
		//IL_0bf3: Unknown result type (might be due to invalid IL or missing references)
		//IL_0bf8: Unknown result type (might be due to invalid IL or missing references)
		//IL_0bc2: Unknown result type (might be due to invalid IL or missing references)
		//IL_0bc7: Unknown result type (might be due to invalid IL or missing references)
		//IL_0bcc: Unknown result type (might be due to invalid IL or missing references)
		//IL_0bd8: Unknown result type (might be due to invalid IL or missing references)
		//IL_0bdd: Unknown result type (might be due to invalid IL or missing references)
		//IL_0be2: Unknown result type (might be due to invalid IL or missing references)
		string[] array = File.ReadAllLines(path);
		foreach (string text in array)
		{
			if (string.IsNullOrWhiteSpace(text))
			{
				continue;
			}
			string text2 = text.Trim();
			if (text2.StartsWith("#", StringComparison.Ordinal) || text2.StartsWith(";", StringComparison.Ordinal))
			{
				continue;
			}
			int num = text2.IndexOf('=');
			if (num <= 0)
			{
				continue;
			}
			string text3 = text2.Substring(0, num).Trim().ToLowerInvariant();
			string text4 = text2.Substring(num + 1).Trim();
			switch (text3)
			{
			case "assist_toggle_key":
				assistToggleKeyName = ParseKeyNameOrDefault(text4, assistToggleKeyName);
				break;
			case "coffee_boost_key":
				coffeeBoostKeyName = ParseKeyNameOrDefault(text4, coffeeBoostKeyName);
				break;
			case "nearest_ball_mode_key":
				nearestBallModeKeyName = ParseKeyNameOrDefault(text4, nearestBallModeKeyName);
				break;
			case "unlock_all_cosmetics_key":
				unlockAllCosmeticsKeyName = ParseKeyNameOrDefault(text4, unlockAllCosmeticsKeyName);
				break;
			case "item_spawner_key":
				itemSpawnerKeyName = ParseKeyNameOrDefault(text4, itemSpawnerKeyName);
				break;
			case "hud_toggle_key":
				hudToggleKeyName = ParseKeyNameOrDefault(text4, hudToggleKeyName);
				break;
			case "random_item_key":
				randomItemKeyName = ParseKeyNameOrDefault(text4, randomItemKeyName);
				break;
			case "ice_toggle_key":
				iceToggleKeyName = ParseKeyNameOrDefault(text4, iceToggleKeyName);
				break;
			case "settings_key":
				settingsKeyName = ParseKeyNameOrDefault(text4, settingsKeyName);
				break;
			case "no_wind_key":
				noWindKeyName = ParseKeyNameOrDefault(text4, noWindKeyName);
				break;
			case "perfect_shot_key":
				perfectShotKeyName = ParseKeyNameOrDefault(text4, perfectShotKeyName);
				break;
			case "no_air_drag_key":
				noAirDragKeyName = ParseKeyNameOrDefault(text4, noAirDragKeyName);
				break;
			case "speed_multiplier_key":
				speedMultiplierKeyName = ParseKeyNameOrDefault(text4, speedMultiplierKeyName);
				break;
			case "speed_multiplier_factor":
				speedMultiplierFactor = ParseFloatOrDefault(text4, speedMultiplierFactor, 0.1f, 20f);
				break;
			case "infinite_ammo_key":
				infiniteAmmoKeyName = ParseKeyNameOrDefault(text4, infiniteAmmoKeyName);
				break;
			case "no_recoil_key":
				noRecoilKeyName = ParseKeyNameOrDefault(text4, noRecoilKeyName);
				break;
			case "no_knockback_key":
				noKnockbackKeyName = ParseKeyNameOrDefault(text4, noKnockbackKeyName);
				break;
			case "landmine_immunity_key":
				landmineImmunityKeyName = ParseKeyNameOrDefault(text4, landmineImmunityKeyName);
				break;
			case "lock_on_any_distance_key":
				lockOnAnyDistanceKeyName = ParseKeyNameOrDefault(text4, lockOnAnyDistanceKeyName);
				break;
			case "expanded_slots_key":
				expandedSlotsKeyName = ParseKeyNameOrDefault(text4, expandedSlotsKeyName);
				break;
			case "expanded_slots_all_players":
				expandedSlotsAllPlayers = ParseBoolOrDefault(text4, expandedSlotsAllPlayers);
				break;
			case "hud_show_bottom_bar":
				hudShowBottomBar = ParseBoolOrDefault(text4, hudShowBottomBar);
				break;
			case "hud_show_ball_distance":
				hudShowBallDistance = ParseBoolOrDefault(text4, hudShowBallDistance);
				break;
			case "hud_show_ice_indicator":
				hudShowIceIndicator = ParseBoolOrDefault(text4, hudShowIceIndicator);
				break;
			case "hud_show_center_title":
				hudShowCenterTitle = ParseBoolOrDefault(text4, hudShowCenterTitle);
				break;
			case "hud_show_player_info":
				hudShowPlayerInfo = ParseBoolOrDefault(text4, hudShowPlayerInfo);
				break;
			case "tracers_enabled":
				tracersEnabled = ParseBoolOrDefault(text4, tracersEnabled);
				break;
			case "credits_grant_amount":
				creditsGrantAmount = ParseIntOrDefault(text4, creditsGrantAmount, 0, 999999);
				break;
			case "actual_trail_enabled":
				actualTrailEnabled = ParseBoolOrDefault(text4, actualTrailEnabled);
				break;
			case "predicted_trail_enabled":
				predictedTrailEnabled = ParseBoolOrDefault(text4, predictedTrailEnabled);
				break;
			case "frozen_trail_enabled":
				frozenTrailEnabled = ParseBoolOrDefault(text4, frozenTrailEnabled);
				break;
			case "impact_preview_enabled":
				impactPreviewEnabled = ParseBoolOrDefault(text4, impactPreviewEnabled);
				break;
			case "impact_preview_fps":
				impactPreviewTargetFps = ParseFloatOrDefault(text4, impactPreviewTargetFps, 0f, 360f);
				break;
			case "impact_preview_width":
				impactPreviewTextureWidth = ParseIntOrDefault(text4, impactPreviewTextureWidth, 320, 3840);
				break;
			case "impact_preview_height":
				impactPreviewTextureHeight = ParseIntOrDefault(text4, impactPreviewTextureHeight, 180, 2160);
				break;
			case "actual_trail_start_width":
				actualTrailStartWidth = ParseFloatOrDefault(text4, actualTrailStartWidth, 0.005f, 1f);
				break;
			case "actual_trail_end_width":
				actualTrailEndWidth = ParseFloatOrDefault(text4, actualTrailEndWidth, 0.005f, 1f);
				break;
			case "predicted_trail_start_width":
				predictedTrailStartWidth = ParseFloatOrDefault(text4, predictedTrailStartWidth, 0.005f, 1f);
				break;
			case "predicted_trail_end_width":
				predictedTrailEndWidth = ParseFloatOrDefault(text4, predictedTrailEndWidth, 0.005f, 1f);
				break;
			case "frozen_trail_start_width":
				frozenTrailStartWidth = ParseFloatOrDefault(text4, frozenTrailStartWidth, 0.005f, 1f);
				break;
			case "frozen_trail_end_width":
				frozenTrailEndWidth = ParseFloatOrDefault(text4, frozenTrailEndWidth, 0.005f, 1f);
				break;
			case "actual_trail_color":
				actualTrailColor = ParseColorOrDefault(text4, actualTrailColor);
				break;
			case "predicted_trail_color":
				predictedTrailColor = ParseColorOrDefault(text4, predictedTrailColor);
				break;
			case "frozen_trail_color":
				frozenTrailColor = ParseColorOrDefault(text4, frozenTrailColor);
				break;
			case "hostallowedfeaturemask":
			{
				if (ulong.TryParse(text4, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
				{
					hostAllowedFeatureMask = result;
				}
				break;
			}
			}
		}
	}

	private string BuildDefaultConfigText()
	{
		StringBuilder stringBuilder = new StringBuilder(512);
		stringBuilder.AppendLine("# Birdie Mod config");
		stringBuilder.AppendLine("# Restart the game after editing this file for trail/visual settings.");
		stringBuilder.AppendLine("# Keybind and HUD changes can also be made in-game via the settings panel (F6).");
		stringBuilder.AppendLine();
		stringBuilder.AppendLine("assist_toggle_key=F1");
		stringBuilder.AppendLine("coffee_boost_key=F2");
		stringBuilder.AppendLine("nearest_ball_mode_key=F3");
		stringBuilder.AppendLine("unlock_all_cosmetics_key=F4");
		stringBuilder.AppendLine("item_spawner_key=F5");
		stringBuilder.AppendLine("hud_toggle_key=H");
		stringBuilder.AppendLine("random_item_key=G");
		stringBuilder.AppendLine("ice_toggle_key=I");
		stringBuilder.AppendLine("settings_key=F6");
		stringBuilder.AppendLine();
		stringBuilder.AppendLine("no_wind_key=W");
		stringBuilder.AppendLine("perfect_shot_key=P");
		stringBuilder.AppendLine("no_air_drag_key=D");
		stringBuilder.AppendLine("speed_multiplier_key=S");
		stringBuilder.AppendLine("speed_multiplier_factor=2.0");
		stringBuilder.AppendLine("infinite_ammo_key=A");
		stringBuilder.AppendLine("no_recoil_key=R");
		stringBuilder.AppendLine("no_knockback_key=K");
		stringBuilder.AppendLine("landmine_immunity_key=M");
		stringBuilder.AppendLine("lock_on_any_distance_key=L");
		stringBuilder.AppendLine("expanded_slots_key=U");
		stringBuilder.AppendLine();
		stringBuilder.AppendLine("hud_show_bottom_bar=true");
		stringBuilder.AppendLine("hud_show_ball_distance=true");
		stringBuilder.AppendLine("hud_show_ice_indicator=true");
		stringBuilder.AppendLine("hud_show_center_title=true");
		stringBuilder.AppendLine("hud_show_player_info=true");
		stringBuilder.AppendLine("tracers_enabled=true");
		stringBuilder.AppendLine();
		stringBuilder.AppendLine("credits_grant_amount=1000");
		stringBuilder.AppendLine();
		stringBuilder.AppendLine("actual_trail_enabled=true");
		stringBuilder.AppendLine("actual_trail_start_width=0.22");
		stringBuilder.AppendLine("actual_trail_end_width=0.18");
		stringBuilder.AppendLine("actual_trail_color=#FF9433");
		stringBuilder.AppendLine();
		stringBuilder.AppendLine("predicted_trail_enabled=true");
		stringBuilder.AppendLine("predicted_trail_start_width=0.18");
		stringBuilder.AppendLine("predicted_trail_end_width=0.14");
		stringBuilder.AppendLine("predicted_trail_color=#39F26E");
		stringBuilder.AppendLine();
		stringBuilder.AppendLine("frozen_trail_enabled=true");
		stringBuilder.AppendLine("frozen_trail_start_width=0.20");
		stringBuilder.AppendLine("frozen_trail_end_width=0.16");
		stringBuilder.AppendLine("frozen_trail_color=#53ACFF");
		stringBuilder.AppendLine();
		stringBuilder.AppendLine("impact_preview_enabled=true");
		stringBuilder.AppendLine("impact_preview_fps=60");
		stringBuilder.AppendLine("impact_preview_width=640");
		stringBuilder.AppendLine("impact_preview_height=360");
		return stringBuilder.ToString();
	}

	private string ParseKeyNameOrDefault(string value, string fallbackValue)
	{
		string text = ((value == null) ? "" : value.Trim());
		if (!string.IsNullOrEmpty(text))
		{
			return text;
		}
		return fallbackValue;
	}

	private bool ParseBoolOrDefault(string value, bool fallbackValue)
	{
		if (!bool.TryParse(value, out var result))
		{
			return fallbackValue;
		}
		return result;
	}

	private float ParseFloatOrDefault(string value, float fallbackValue, float minValue, float maxValue)
	{
		if (!float.TryParse(value, NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
		{
			return fallbackValue;
		}
		return Mathf.Clamp(result, minValue, maxValue);
	}

	private int ParseIntOrDefault(string value, int fallbackValue, int minValue, int maxValue)
	{
		if (!int.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
		{
			return fallbackValue;
		}
		return Mathf.Clamp(result, minValue, maxValue);
	}

	private Color ParseColorOrDefault(string value, Color fallbackValue)
	{
		//IL_000a: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
		//IL_0038: 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_004a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0053: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
		//IL_007a: Unknown result type (might be due to invalid IL or missing references)
		Color result = default(Color);
		if (ColorUtility.TryParseHtmlString(value, ref result))
		{
			return result;
		}
		string[] array = value.Split(new char[1] { ',' });
		if (array.Length >= 3 && array.Length <= 4)
		{
			float[] array2 = new float[4] { fallbackValue.r, fallbackValue.g, fallbackValue.b, fallbackValue.a };
			for (int i = 0; i < array.Length; i++)
			{
				if (!float.TryParse(array[i].Trim(), NumberStyles.Float, CultureInfo.InvariantCulture, out var result2))
				{
					return fallbackValue;
				}
				array2[i] = ((result2 > 1f) ? Mathf.Clamp01(result2 / 255f) : Mathf.Clamp01(result2));
			}
			return new Color(array2[0], array2[1], array2[2], array2[3]);
		}
		return fallbackValue;
	}

	private void UpdateConfigLabels()
	{
		//IL_000a: Unknown result type (might be due to invalid IL or missing references)
		//IL_000f: Unknown result type (might be due to invalid IL or missing references)
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		//IL_0037: Unknown result type (might be due to invalid IL or missing references)
		//IL_0046: Unknown result type (might be due to invalid IL or missing references)
		//IL_004b: Unknown result type (might be due to invalid IL or missing references)
		//IL_005a: 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_006e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0073: Unknown result type (might be due to invalid IL or missing references)
		//IL_0082: Unknown result type (might be due to invalid IL or missing references)
		//IL_0087: 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_00aa: Unknown result type (might be due to invalid IL or missing references)
		//IL_00af: Unknown result type (might be due to invalid IL or missing references)
		//IL_00be: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
		//IL_010e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0113: Unknown result type (might be due to invalid IL or missing references)
		//IL_0122: Unknown result type (might be due to invalid IL or missing references)
		//IL_0127: Unknown result type (might be due to invalid IL or missing references)
		//IL_0136: Unknown result type (might be due to invalid IL or missing references)
		//IL_013b: 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_015e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0163: 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)
		assistToggleKey = ParseConfiguredKey(assistToggleKeyName, (Key)94);
		coffeeBoostKey = ParseConfiguredKey(coffeeBoostKeyName, (Key)95);
		nearestBallModeKey = ParseConfiguredKey(nearestBallModeKeyName, (Key)96);
		unlockAllCosmeticsKey = ParseConfiguredKey(unlockAllCosmeticsKeyName, (Key)97);
		itemSpawnerKey = ParseConfiguredKey(itemSpawnerKeyName, (Key)98);
		hudToggleKey = ParseConfiguredKey(hudToggleKeyName, (Key)22);
		randomItemKey = ParseConfiguredKey(randomItemKeyName, (Key)21);
		iceToggleKey = ParseConfiguredKey(iceToggleKeyName, (Key)23);
		settingsKey = ParseConfiguredKey(settingsKeyName, (Key)99);
		noWindKey = ParseConfiguredKey(noWindKeyName, (Key)37);
		perfectShotKey = ParseConfiguredKey(perfectShotKeyName, (Key)30);
		noAirDragKey = ParseConfiguredKey(noAirDragKeyName, (Key)18);
		speedMultiplierKey = ParseConfiguredKey(speedMultiplierKeyName, (Key)33);
		infiniteAmmoKey = ParseConfiguredKey(infiniteAmmoKeyName, (Key)15);
		noRecoilKey = ParseConfiguredKey(noRecoilKeyName, (Key)32);
		noKnockbackKey = ParseConfiguredKey(noKnockbackKeyName, (Key)25);
		landmineImmunityKey = ParseConfiguredKey(landmineImmunityKeyName, (Key)27);
		lockOnAnyDistanceKey = ParseConfiguredKey(lockOnAnyDistanceKeyName, (Key)26);
		expandedSlotsKey = ParseConfiguredKey(expandedSlotsKeyName, (Key)35);
		assistToggleKeyLabel = FormatKeyLabel(assistToggleKeyName);
		coffeeBoostKeyLabel = FormatKeyLabel(coffeeBoostKeyName);
		nearestBallModeKeyLabel = FormatKeyLabel(nearestBallModeKeyName);
		unlockAllCosmeticsKeyLabel = FormatKeyLabel(unlockAllCosmeticsKeyName);
		itemSpawnerKeyLabel = FormatKeyLabel(itemSpawnerKeyName);
		hudToggleKeyLabel = FormatKeyLabel(hudToggleKeyName);
		randomItemKeyLabel = FormatKeyLabel(randomItemKeyName);
		iceToggleKeyLabel = FormatKeyLabel(iceToggleKeyName);
		settingsKeyLabel = FormatKeyLabel(settingsKeyName);
		noWindKeyLabel = FormatKeyLabel(noWindKeyName);
		perfectShotKeyLabel = FormatKeyLabel(perfectShotKeyName);
		noAirDragKeyLabel = FormatKeyLabel(noAirDragKeyName);
		speedMultiplierKeyLabel = FormatKeyLabel(speedMultiplierKeyName);
		infiniteAmmoKeyLabel = FormatKeyLabel(infiniteAmmoKeyName);
		noRecoilKeyLabel = FormatKeyLabel(noRecoilKeyName);
		noKnockbackKeyLabel = FormatKeyLabel(noKnockbackKeyName);
		landmineImmunityKeyLabel = FormatKeyLabel(landmineImmunityKeyName);
		lockOnAnyDistanceKeyLabel = FormatKeyLabel(lockOnAnyDistanceKeyName);
		expandedSlotsKeyLabel = FormatKeyLabel(expandedSlotsKeyName);
	}

	private void SaveCurrentConfig()
	{
		try
		{
			string directoryName = Path.GetDirectoryName(configPath);
			if (!string.IsNullOrEmpty(directoryName))
			{
				Directory.CreateDirectory(directoryName);
			}
			File.WriteAllText(configPath, BuildCurrentConfigText(), Encoding.ASCII);
		}
		catch
		{
		}
	}

	private string BuildCurrentConfigText()
	{
		//IL_0394: Unknown result type (might be due to invalid IL or missing references)
		//IL_041a: Unknown result type (might be due to invalid IL or missing references)
		//IL_04a0: Unknown result type (might be due to invalid IL or missing references)
		StringBuilder stringBuilder = new StringBuilder(1024);
		stringBuilder.AppendLine("# Birdie Mod config");
		stringBuilder.AppendLine("# Restart the game after editing this file for trail/visual settings.");
		stringBuilder.AppendLine("# Keybind and HUD changes can also be made in-game via the settings panel.");
		stringBuilder.AppendLine();
		stringBuilder.AppendLine("assist_toggle_key=" + assistToggleKeyName);
		stringBuilder.AppendLine("coffee_boost_key=" + coffeeBoostKeyName);
		stringBuilder.AppendLine("nearest_ball_mode_key=" + nearestBallModeKeyName);
		stringBuilder.AppendLine("unlock_all_cosmetics_key=" + unlockAllCosmeticsKeyName);
		stringBuilder.AppendLine("item_spawner_key=" + itemSpawnerKeyName);
		stringBuilder.AppendLine("hud_toggle_key=" + hudToggleKeyName);
		stringBuilder.AppendLine("random_item_key=" + randomItemKeyName);
		stringBuilder.AppendLine("ice_toggle_key=" + iceToggleKeyName);
		stringBuilder.AppendLine("settings_key=" + settingsKeyName);
		stringBuilder.AppendLine();
		stringBuilder.AppendLine("no_wind_key=" + noWindKeyName);
		stringBuilder.AppendLine("perfect_shot_key=" + perfectShotKeyName);
		stringBuilder.AppendLine("no_air_drag_key=" + noAirDragKeyName);
		stringBuilder.AppendLine("speed_multiplier_key=" + speedMultiplierKeyName);
		stringBuilder.AppendLine("speed_multiplier_factor=" + speedMultiplierFactor.ToString(CultureInfo.InvariantCulture));
		stringBuilder.AppendLine("infinite_ammo_key=" + infiniteAmmoKeyName);
		stringBuilder.AppendLine("no_recoil_key=" + noRecoilKeyName);
		stringBuilder.AppendLine("no_knockback_key=" + noKnockbackKeyName);
		stringBuilder.AppendLine("landmine_immunity_key=" + landmineImmunityKeyName);
		stringBuilder.AppendLine("lock_on_any_distance_key=" + lockOnAnyDistanceKeyName);
		stringBuilder.AppendLine("expanded_slots_key=" + expandedSlotsKeyName);
		stringBuilder.AppendLine("expanded_slots_all_players=" + expandedSlotsAllPlayers.ToString().ToLowerInvariant());
		stringBuilder.AppendLine();
		stringBuilder.AppendLine("hud_show_bottom_bar=" + hudShowBottomBar.ToString().ToLowerInvariant());
		stringBuilder.AppendLine("hud_show_ball_distance=" + hudShowBallDistance.ToString().ToLowerInvariant());
		stringBuilder.AppendLine("hud_show_ice_indicator=" + hudShowIceIndicator.ToString().ToLowerInvariant());
		stringBuilder.AppendLine("hud_show_center_title=" + hudShowCenterTitle.ToString().ToLowerInvariant());
		stringBuilder.AppendLine("hud_show_player_info=" + hudShowPlayerInfo.ToString().ToLowerInvariant());
		stringBuilder.AppendLine("tracers_enabled=" + tracersEnabled.ToString().ToLowerInvariant());
		stringBuilder.AppendLine();
		stringBuilder.AppendLine("credits_grant_amount=" + creditsGrantAmount);
		stringBuilder.AppendLine();
		stringBuilder.AppendLine("actual_trail_enabled=" + actualTrailEnabled.ToString().ToLowerInvariant());
		stringBuilder.AppendLine("actual_trail_start_width=" + actualTrailStartWidth.ToString(CultureInfo.InvariantCulture));
		stringBuilder.AppendLine("actual_trail_end_width=" + actualTrailEndWidth.ToString(CultureInfo.InvariantCulture));
		stringBuilder.AppendLine("actual_trail_color=#" + ColorUtility.ToHtmlStringRGB(actualTrailColor));
		stringBuilder.AppendLine();
		stringBuilder.AppendLine("predicted_trail_enabled=" + predictedTrailEnabled.ToString().ToLowerInvariant());
		stringBuilder.AppendLine("predicted_trail_start_width=" + predictedTrailStartWidth.ToString(CultureInfo.InvariantCulture));
		stringBuilder.AppendLine("predicted_trail_end_width=" + predictedTrailEndWidth.ToString(CultureInfo.InvariantCulture));
		stringBuilder.AppendLine("predicted_trail_color=#" + ColorUtility.ToHtmlStringRGB(predictedTrailColor));
		stringBuilder.AppendLine();
		stringBuilder.AppendLine("frozen_trail_enabled=" + frozenTrailEnabled.ToString().ToLowerInvariant());
		stringBuilder.AppendLine("frozen_trail_start_width=" + frozenTrailStartWidth.ToString(CultureInfo.InvariantCulture));
		stringBuilder.AppendLine("frozen_trail_end_width=" + frozenTrailEndWidth.ToString(CultureInfo.InvariantCulture));
		stringBuilder.AppendLine("frozen_trail_color=#" + ColorUtility.ToHtmlStringRGB(frozenTrailColor));
		stringBuilder.AppendLine();
		stringBuilder.AppendLine("impact_preview_enabled=" + impactPreviewEnabled.ToString().ToLowerInvariant());
		stringBuilder.AppendLine("impact_preview_fps=" + ((int)impactPreviewTargetFps).ToString(CultureInfo.InvariantCulture));
		stringBuilder.AppendLine("impact_preview_width=" + impactPreviewTextureWidth.ToString(CultureInfo.InvariantCulture));
		stringBuilder.AppendLine("impact_preview_height=" + impactPreviewTextureHeight.ToString(CultureInfo.InvariantCulture));
		stringBuilder.AppendLine();
		stringBuilder.AppendLine("hostAllowedFeatureMask=" + hostAllowedFeatureMask.ToString(CultureInfo.InvariantCulture));
		return stringBuilder.ToString();
	}

	private Key ParseConfiguredKey(string configuredKeyName, Key fallbackKey)
	{
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_001d: Unknown result type (might be due to invalid IL or missing references)
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		if (string.IsNullOrWhiteSpace(configuredKeyName))
		{
			return fallbackKey;
		}
		if (!Enum.TryParse<Key>(configuredKeyName.Trim(), ignoreCase: true, out Key result) || (int)result == 0)
		{
			return fallbackKey;
		}
		return result;
	}

	private string FormatKeyLabel(string configuredKeyName)
	{
		if (string.IsNullOrWhiteSpace(configuredKeyName))
		{
			return "?";
		}
		string text = configuredKeyName.Trim();
		if (Enum.TryParse<Key>(text, ignoreCase: true, out Key result))
		{
			text = ((object)(Key)(ref result)).ToString();
		}
		if (text.StartsWith("Digit", StringComparison.OrdinalIgnoreCase))
		{
			return text.Substring("Digit".Length);
		}
		return text.ToUpperInvariant();
	}

	private bool WasConfiguredKeyPressed(Key configuredKey)
	{
		//IL_0009: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		Keyboard current = Keyboard.current;
		if (current == null || (int)configuredKey == 0)
		{
			return false;
		}
		try
		{
			return current[configuredKey] != null && ((ButtonControl)current[configuredKey]).wasPressedThisFrame;
		}
		catch
		{
			return false;
		}
	}

	private Color BrightenColor(Color color, float factor)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		//IL_002d: Unknown result type (might be due to invalid IL or missing references)
		return new Color(Mathf.Clamp01(color.r * factor), Mathf.Clamp01(color.g * factor), Mathf.Clamp01(color.b * factor), color.a);
	}

	private Color DarkenColor(Color color, float factor)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		//IL_002d: Unknown result type (might be due to invalid IL or missing references)
		return new Color(Mathf.Clamp01(color.r * factor), Mathf.Clamp01(color.g * factor), Mathf.Clamp01(color.b * factor), color.a);
	}

	private Gradient CreateTrailGradient(Color baseColor, float startFactor, float midFactor, float endFactor, float startAlpha, float midAlpha, float endAlpha)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0003: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_000a: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		//IL_001c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0022: Expected O, but got Unknown
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_0036: Unknown result type (might be due to invalid IL or missing references)
		//IL_003d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		//IL_0048: Unknown result type (might be due to invalid IL or missing references)
		//IL_004f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0055: Unknown result type (might be due to invalid IL or missing references)
		//IL_005a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0079: Unknown result type (might be due to invalid IL or missing references)
		//IL_007e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0091: 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_00a9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
		Color val = BrightenColor(baseColor, startFactor);
		Color val2 = BrightenColor(baseColor, midFactor);
		Color val3 = DarkenColor(baseColor, endFactor);
		Gradient val4 = new Gradient();
		val4.colorKeys = (GradientColorKey[])(object)new GradientColorKey[3]
		{
			new GradientColorKey(val, 0f),
			new GradientColorKey(val2, 0.55f),
			new GradientColorKey(val3, 1f)
		};
		val4.alphaKeys = (GradientAlphaKey[])(object)new GradientAlphaKey[3]
		{
			new GradientAlphaKey(Mathf.Clamp01(startAlpha), 0f),
			new GradientAlphaKey(Mathf.Clamp01(midAlpha), 0.6f),
			new GradientAlphaKey(Mathf.Clamp01(endAlpha), 1f)
		};
		return val4;
	}

	private void ApplyTrailVisualSettings()
	{
		//IL_0020: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
		ApplyTrailVisualSettings(shotPathLine, shotPathMaterial, actualTrailEnabled, actualTrailStartWidth, actualTrailEndWidth, actualTrailColor, 1.2f, 1f, 0.78f, 0.96f, 0.8f, 0.62f);
		ApplyTrailVisualSettings(predictedPathLine, predictedPathMaterial, predictedTrailEnabled, predictedTrailStartWidth, predictedTrailEndWidth, predictedTrailColor, 1.15f, 1f, 0.82f, 0.94f, 0.78f, 0.55f);
		ApplyTrailVisualSettings(frozenPredictedPathLine, frozenPredictedPathMaterial, frozenTrailEnabled, frozenTrailStartWidth, frozenTrailEndWidth, frozenTrailColor, 1.18f, 1f, 0.8f, 0.92f, 0.76f, 0.52f);
	}

	private void ApplyTrailVisualSettings(LineRenderer lineRenderer, Material material, bool enabled, float startWidth, float endWidth, Color baseColor, float startFactor, float midFactor, float endFactor, float startAlpha, float midAlpha, float endAlpha)
	{
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_004f: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)lineRenderer == (Object)null))
		{
			lineRenderer.startWidth = startWidth;
			lineRenderer.endWidth = endWidth;
			((Renderer)lineRenderer).enabled = enabled;
			lineRenderer.colorGradient = CreateTrailGradient(baseColor, startFactor, midFactor, endFactor, startAlpha, midAlpha, endAlpha);
			if (!enabled)
			{
				lineRenderer.positionCount = 0;
			}
			if ((Object)(object)material != (Object)null)
			{
				material.color = baseColor;
			}
		}
	}

	private void ResolvePlayerContext()
	{
		Component val = playerMovement;
		Component val2 = playerGolfer;
		TryResolveLocalPlayerGolferViaGameManager();
		if ((Object)(object)playerMovement == (Object)null)
		{
			GameObject[] array = FindAllGameObjects();
			for (int i = 0; i < array.Length; i++)
			{
				GameObject val3 = array[i];
				if ((Object)(object)val3 == (Object)null)
				{
					continue;
				}
				Component[] components = val3.GetComponents<Component>();
				foreach (Component val4 in components)
				{
					if (!((Object)(object)val4 == (Object)null) && !(((object)val4).GetType().Name != "PlayerMovement") && IsLocalPlayerMovement(val4))
					{
						playerMovement = val4;
						addSpeedBoostMethod = ((object)val4).GetType().GetMethod("AddSpeedBoost", BindingFlags.Instance | BindingFlags.NonPublic);
						i = array.Length;
						break;
					}
				}
			}
		}
		else if (addSpeedBoostMethod == null)
		{
			addSpeedBoostMethod = ((object)playerMovement).GetType().GetMethod("AddSpeedBoost", BindingFlags.Instance | BindingFlags.NonPublic);
		}
		EnsureLocalGolfBallReference(force: true);
		playerFound = (Object)(object)playerMovement != (Object)null && (Object)(object)playerGolfer != (Object)null;
		if (((Object)(object)val != (Object)null && val != playerMovement) || ((Object)(object)val2 != (Object)null && val2 != playerGolfer))
		{
			ClearRuntimeState();
		}
		hadResolvedPlayerContext = (Object)(object)playerMovement != (Object)null && (Object)(object)playerGolfer != (Object)null;
	}

	private bool IsLocalPlayerMovement(Component component)
	{
		try
		{
			PropertyInfo property = ((object)component).GetType().GetProperty("isLocalPlayer", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			return property != null && property.PropertyType == typeof(bool) && (bool)property.GetValue(component, null);
		}
		catch
		{
			return false;
		}
	}

	private void CachePlayerGolferAccessors(Component golfer)
	{
		if (!((Object)(object)golfer == (Object)null))
		{
			EnsurePlayerGolferMetadataCached(golfer);
		}
	}

	private void EnsurePlayerGolferMetadataCached(Component golfer)
	{
		if ((Object)(object)golfer == (Object)null || initializedPlayerGolfer == golfer)
		{
			return;
		}
		initializedPlayerGolfer = golfer;
		playerGolferProperties.Clear();
		playerGolferFields.Clear();
		cachedTryStartChargingSwingMethod = null;
		cachedSetIsChargingSwingMethod = null;
		cachedReleaseSwingChargeMethod = null;
		cachedUpdateSwingNormalizedPowerMethod = null;
		swingNormalizedPowerBackingField = null;
		try
		{
			Type type = ((object)golfer).GetType();
			BindingFlags bindingAttr = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
			string[] array = new string[6] { "SwingNormalizedPower", "SwingPitch", "IsChargingSwing", "IsSwinging", "IsAimingSwing", "OwnBall" };
			for (int i = 0; i < array.Length; i++)
			{
				PropertyInfo property = type.GetProperty(array[i], bindingAttr);
				if (property != null)
				{
					playerGolferProperties[array[i]] = property;
				}
			}
			string[] array2 = new string[1] { "swingPowerTimestamp" };
			for (int j = 0; j < array2.Length; j++)
			{
				FieldInfo field = type.GetField(array2[j], bindingAttr);
				if (field != null)
				{
					playerGolferFields[array2[j]] = field;
				}
			}
			cachedTryStartChargingSwingMethod = type.GetMethod("TryStartChargingSwing", bindingAttr);
			cachedSetIsChargingSwingMethod = type.GetMethod("SetIsChargingSwing", BindingFlags.Instance | BindingFlags.NonPublic);
			cachedReleaseSwingChargeMethod = type.GetMethod("ReleaseSwingCharge", bindingAttr);
			cachedUpdateSwingNormalizedPowerMethod = type.GetMethod("UpdateSwingNormalizedPower", BindingFlags.Instance | BindingFlags.NonPublic);
		}
		catch
		{
		}
	}

	private bool TryGetCurrentSwingValues(out float swingPower, out float swingPitch, out bool isChargingSwing, out bool isSwinging)
	{
		swingPower = idealSwingPower;
		swingPitch = idealSwingPitch;
		isChargingSwing = false;
		isSwinging = false;
		if ((Object)(object)playerGolfer == (Object)null)
		{
			return false;
		}
		try
		{
			if (!playerGolferProperties.TryGetValue("SwingNormalizedPower", out var value) || !playerGolferProperties.TryGetValue("SwingPitch", out var value2) || !playerGolferProperties.TryGetValue("IsChargingSwing", out var value3) || !playerGolferProperties.TryGetValue("IsSwinging", out var value4))
			{
				return false;
			}
			swingPower = Convert.ToSingle(value.GetValue(playerGolfer, null));
			swingPitch = Convert.ToSingle(value2.GetValue(playerGolfer, null));
			isChargingSwing = Convert.ToBoolean(value3.GetValue(playerGolfer, null));
			isSwinging = Convert.ToBoolean(value4.GetValue(playerGolfer, null));
			return true;
		}
		catch
		{
			return false;
		}
	}

	private void InitializeLocalGolferResolver()
	{
		if (localGolferResolverInitialized)
		{
			return;
		}
		localGolferResolverInitialized = true;
		try
		{
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			for (int i = 0; i < assemblies.Length; i++)
			{
				Type type = assemblies[i].GetType("GameManager");
				if (!(type == null))
				{
					PropertyInfo property = type.GetProperty("LocalPlayerAsGolfer", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
					if (property != null)
					{
						cachedLocalPlayerAsGolferProperty = property;
						break;
					}
				}
			}
		}
		catch
		{
		}
	}

	private bool TryResolveLocalPlayerGolferViaGameManager()
	{
		InitializeLocalGolferResolver();
		if (cachedLocalPlayerAsGolferProperty == null)
		{
			return false;
		}
		try
		{
			object? value = cachedLocalPlayerAsGolferProperty.GetValue(null, null);
			Component val = (Component)((value is Component) ? value : null);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			if (playerGolfer != val)
			{
				playerGolfer = val;
				CachePlayerGolferAccessors(val);
			}
			return true;
		}
		catch
		{
			return false;
		}
	}

	private bool EnsureLocalGolfBallReference(bool force)
	{
		if (nearestAnyBallModeEnabled)
		{
			return EnsureNearestAnyGolfBallReference(force);
		}
		if (!force && (Object)(object)golfBall != (Object)null && (Object)(object)golfBall.gameObject != (Object)null)
		{
			hadResolvedBallContext = true;
			return true;
		}
		float time = Time.time;
		if (!force && time < nextBallResolveTime)
		{
			return (Object)(object)golfBall != (Object)null;
		}
		nextBallResolveTime = time + ballResolveInterval;
		Component ownBall = null;
		string text = "missing";
		TryResolveLocalPlayerGolferViaGameManager();
		if (TryGetOwnBallFromGolfer(playerGolfer, out ownBall))
		{
			text = "OwnBall";
		}
		if ((Object)(object)ownBall == (Object)null)
		{
			HandleTrackedGolfBallChanged(golfBall, null);
			golfBall = null;
			lastBallResolveSource = "missing";
			hadResolvedBallContext = false;
			return false;
		}
		HandleTrackedGolfBallChanged(golfBall, ownBall);
		golfBall = ownBall;
		lastBallResolveSource = text;
		hadResolvedBallContext = true;
		return true;
	}

	private bool EnsureNearestAnyGolfBallReference(bool force)
	{
		if ((Object)(object)playerMovement == (Object)null && (Object)(object)playerGolfer == (Object)null)
		{
			golfBall = null;
			lastBallResolveSource = "missing";
			hadResolvedBallContext = false;
			return false;
		}
		float time = Time.time;
		if (!force && (Object)(object)golfBall != (Object)null && (Object)(object)golfBall.gameObject != (Object)null && time < nextNearestAnyBallResolveTime)
		{
			hadResolvedBallContext = true;
			return true;
		}
		nextNearestAnyBallResolveTime = time + nearestAnyBallResolveInterval;
		Component val = FindNearestGolfBallToPlayer(force);
		if ((Object)(object)val == (Object)null)
		{
			HandleTrackedGolfBallChanged(golfBall, null);
			golfBall = null;
			lastBallResolveSource = "missing";
			hadResolvedBallContext = false;
			return false;
		}
		HandleTrackedGolfBallChanged(golfBall, val);
		golfBall = val;
		lastBallResolveSource = "nearest-any";
		hadResolvedBallContext = true;
		return true;
	}

	private void HandleTrackedGolfBallChanged(Component previousBall, Component nextBall)
	{
		//IL_003a: Unknown result type (might be due to invalid IL or missing references)
		//IL_003f: Unknown result type (might be due to invalid IL or missing references)
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		//IL_004f: Unknown result type (might be due to invalid IL or missing references)
		//IL_002d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0054: Unknown result type (might be due to invalid IL or missing references)
		if (previousBall != nextBall)
		{
			ResetTrailState();
			HideImpactPreview();
			nextPredictedPathRefreshTime = 0f;
			swingHittableReflectionInitialized = false;
			lastShotPathBallPosition = (((Object)(object)nextBall != (Object)null) ? (nextBall.transform.position + Vector3.up * shotPathHeightOffset) : Vector3.zero);
		}
	}

	private void RefreshGolfBallCache(bool force)
	{
		float time = Time.time;
		if (!force && time < nextGolfBallCacheRefreshTime)
		{
			return;
		}
		cachedGolfBalls.Clear();
		Component[] array = FindAllComponents();
		foreach (Component val in array)
		{
			if (!((Object)(object)val == (Object)null) && !((Object)(object)val.gameObject == (Object)null) && !(((object)val).GetType().Name != "GolfBall"))
			{
				cachedGolfBalls.Add(val);
			}
		}
		nextGolfBallCacheRefreshTime = time + ((cachedGolfBalls.Count > 0) ? golfBallCacheRefreshInterval : emptyGolfBallCacheRefreshInterval);
	}

	private Component FindNearestGolfBallToPlayer(bool forceRefreshCache)
	{
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_003a: Unknown result type (might be due to invalid IL or missing references)
		//IL_003f: Unknown result type (might be due to invalid IL or missing references)
		//IL_009f: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
		Vector3 position;
		if ((Object)(object)playerMovement != (Object)null)
		{
			position = playerMovement.transform.position;
		}
		else
		{
			if (!((Object)(object)playerGolfer != (Object)null))
			{
				return null;
			}
			position = playerGolfer.transform.position;
		}
		RefreshGolfBallCache(forceRefreshCache);
		Component result = null;
		float num = float.MaxValue;
		for (int num2 = cachedGolfBalls.Count - 1; num2 >= 0; num2--)
		{
			Component val = cachedGolfBalls[num2];
			if ((Object)(object)val == (Object)null || (Object)(object)val.gameObject == (Object)null)
			{
				cachedGolfBalls.RemoveAt(num2);
			}
			else
			{
				Vector3 val2 = val.transform.position - position;
				float sqrMagnitude = ((Vector3)(ref val2)).sqrMagnitude;
				if (sqrMagnitude < num)
				{
					num = sqrMagnitude;
					result = val;
				}
			}
		}
		return result;
	}

	private bool TryGetOwnBallFromGolfer(Component golfer, out Component ownBall)
	{
		ownBall = null;
		if ((Object)(object)golfer == (Object)null)
		{
			return false;
		}
		try
		{
			if (playerGolferProperties.TryGetValue("OwnBall", out var value) && value != null)
			{
				object? value2 = value.GetValue(golfer, null);
				ownBall = (Component)((value2 is Component) ? value2 : null);
				return (Object)(object)ownBall != (Object)null;
			}
		}
		catch
		{
		}
		return false;
	}

	private bool TryResolveDisplayNameFromObject(object source, out string displayName)
	{
		displayName = null;
		if (source == null)
		{
			return false;
		}
		BindingFlags bindingAttr = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
		Type type = source.GetType();
		string[] array = new string[4] { "PlayerName", "displayName", "playerNickname", "NetworkplayerName" };
		foreach (string name in array)
		{
			PropertyInfo property = type.GetProperty(name, bindingAttr);
			if (property != null && property.PropertyType == typeof(string) && property.GetIndexParameters().Length == 0)
			{
				try
				{
					if (ModTextHelper.TryGetValidDisplayName(property.GetValue(source, null) as string, out displayName))
					{
						return true;
					}
				}
				catch
				{
				}
			}
			FieldInfo field = type.GetField(name, bindingAttr);
			if (!(field != null) || !(field.FieldType == typeof(string)))
			{
				continue;
			}
			try
			{
				if (ModTextHelper.TryGetValidDisplayName(field.GetValue(source) as string, out displayName))
				{
					return true;
				}
			}
			catch
			{
			}
		}
		return false;
	}

	private string GetLocalPlayerDisplayName()
	{
		if ((Object)(object)playerMovement == (Object)null)
		{
			return "Searching...";
		}
		float time = Time.time;
		if (time < nextDisplayNameRefreshTime && !string.IsNullOrEmpty(cachedLocalPlayerDisplayName))
		{
			return cachedLocalPlayerDisplayName;
		}
		nextDisplayNameRefreshTime = time + displayNameRefreshInterval;
		if (TryResolveDisplayNameFromObject(playerMovement, out var displayName))
		{
			cachedLocalPlayerDisplayName = displayName;
			return cachedLocalPlayerDisplayName;
		}
		GameObject gameObject = playerMovement.gameObject;
		if ((Object)(object)gameObject != (Object)null)
		{
			Component[] components = gameObject.GetComponents<Component>();
			foreach (Component val in components)
			{
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val == (Object)(object)playerMovement) && TryResolveDisplayNameFromObject(val, out displayName))
				{
					cachedLocalPlayerDisplayName = displayName;
					return cachedLocalPlayerDisplayName;
				}
			}
			string value = ModTextHelper.NormalizeDisplayName(((Object)gameObject).name);
			if (!string.IsNullOrEmpty(value))
			{
				cachedLocalPlayerDisplayName = value;
				return cachedLocalPlayerDisplayName;
			}
		}
		cachedLocalPlayerDisplayName = "Unknown";
		return cachedLocalPlayerDisplayName;
	}

	private GameObject[] FindAllGameObjects()
	{
		int frameCount = Time.frameCount;
		if (cachedAllGameObjects == null || cachedAllGameObjectsFrame != frameCount)
		{
			cachedAllGameObjects = Object.FindObjectsByType<GameObject>((FindObjectsSortMode)0);
			cachedAllGameObjectsFrame = frameCount;
		}
		return cachedAllGameObjects;
	}

	private Component[] FindAllComponents()
	{
		int frameCount = Time.frameCount;
		if (cachedAllComponents == null || cachedAllComponentsFrame != frameCount)
		{
			cachedAllComponents = Object.FindObjectsByType<Component>((FindObjectsSortMode)0);
			cachedAllComponentsFrame = frameCount;
		}
		return cachedAllComponents;
	}

	private void UnlockAllCosmetics()
	{
		bool flag = false;
		bool flag2 = false;
		try
		{
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			foreach (Assembly obj in assemblies)
			{
				Type type = obj.GetType("CosmeticsUnlocksManager");
				if (type != null)
				{
					flag |= ApplyCosmeticsUnlocksToType(type);
					flag2 |= InvokeCosmeticsRefreshMethods(type);
				}
				Type type2 = obj.GetType("PlayerCosmetics");
				if (type2 != null)
				{
					flag |= ApplyCosmeticsUnlocksToType(type2);
					flag2 |= InvokeCosmeticsRefreshMethods(type2);
				}
				Type type3 = obj.GetType("PlayerCustomizationMenu");
				if (type3 != null)
				{
					flag |= ApplyCosmeticsUnlocksToType(type3);
					flag2 |= InvokeCosmeticsRefreshMethods(type3);
				}
			}
			Component[] array = FindAllComponents();
			foreach (Component val in array)
			{
				if (!((Object)(object)val == (Object)null))
				{
					string name = ((object)val).GetType().Name;
					if (name.IndexOf("Cosmetic", StringComparison.OrdinalIgnoreCase) >= 0 || name.IndexOf("Customization", StringComparison.OrdinalIgnoreCase) >= 0 || name.IndexOf("Unlock", StringComparison.OrdinalIgnoreCase) >= 0)
					{
						flag |= ApplyCosmeticsUnlocksToObject(val, ((object)val).GetType());
						flag2 |= InvokeCosmeticsRefreshMethods(val, ((object)val).GetType());
					}
				}
			}
		}
		catch (Exception ex)
		{
			BirdieLog.Warning("[Birdie] Cosmetic unlock failed: " + ex.Message);
		}
		if (flag)
		{
			BirdieLog.Msg("[Birdie] Cosmetics unlock applied.");
		}
		else if (flag2)
		{
			BirdieLog.Msg("[Birdie] Cosmetics UI refresh triggered.");
		}
		else
		{
			BirdieLog.Warning("[Birdie] Cosmetics manager not found.");
		}
	}

	private bool ApplyCosmeticsUnlocksToType(Type type)
	{
		if (type == null)
		{
			return false;
		}
		bool flag = false;
		flag |= ApplyCosmeticsUnlocksToObject(null, type);
		object obj = ResolveSingletonInstance(type);
		if (obj != null)
		{
			flag |= ApplyCosmeticsUnlocksToObject(obj, type);
		}
		return flag;
	}

	private bool ApplyCosmeticsUnlocksToObject(object target, Type type)
	{
		if (type == null)
		{
			return false;
		}
		bool flag = false;
		for (int i = 0; i < cosmeticUnlockFlagNames.Length; i++)
		{
			flag |= TrySetBoolMember(type, target, cosmeticUnlockFlagNames[i], value: true);
		}
		return flag;
	}

	private bool InvokeCosmeticsRefreshMethods(Type type)
	{
		if (type == null)
		{
			return false;
		}
		bool flag = false;
		flag |= InvokeCosmeticsRefreshMethods(null, type);
		object obj = ResolveSingletonInstance(type);
		if (obj != null)
		{
			flag |= InvokeCosmeticsRefreshMethods(obj, type);
		}
		return flag;
	}

	private bool InvokeCosmeticsRefreshMethods(object target, Type type)
	{
		if (type == null)
		{
			return false;
		}
		bool flag = false;
		for (int i = 0; i < cosmeticRefreshMethodNames.Length; i++)
		{
			flag |= InvokeParameterlessMethodIfExists(type, target, cosmeticRefreshMethodNames[i]);
		}
		return flag;
	}

	private object ResolveSingletonInstance(Type type)
	{
		if (type == null)
		{
			return null;
		}
		BindingFlags bindingAttr = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;
		string[] array = new string[6] { "Instance", "instance", "Singleton", "singleton", "Current", "current" };
		for (int i = 0; i < array.Length; i++)
		{
			try
			{
				PropertyInfo property = type.GetProperty(array[i], bindingAttr);
				if (property != null && property.GetIndexParameters().Length == 0 && property.GetMethod != null && property.GetMethod.IsStatic)
				{
					object value = property.GetValue(null, null);
					if (value != null)
					{
						return value;
					}
				}
			}
			catch
			{
			}
			try
			{
				FieldInfo field = type.GetField(array[i], bindingAttr);
				if (field != null && field.IsStatic)
				{
					object value2 = field.GetValue(null);
					if (value2 != null)
					{
						return value2;
					}
				}
			}
			catch
			{
			}
		}
		Component[] array2 = FindAllComponents();
		foreach (Component val in array2)
		{
			if ((Object)(object)val != (Object)null && ((object)val).GetType() == type)
			{
				return val;
			}
		}
		return null;
	}

	private bool TrySetBoolMember(Type type, object target, string memberName, bool value)
	{
		if (type == null || string.IsNullOrEmpty(memberName))
		{
			return false;
		}
		BindingFlags bindingAttr = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;
		try
		{
			FieldInfo field = type.GetField(memberName, bindingAttr);
			if (field != null && field.FieldType == typeof(bool))
			{
				object obj = (field.IsStatic ? null : target);
				if (field.IsStatic || obj != null)
				{
					field.SetValue(obj, value);
					return true;
				}
			}
		}
		catch
		{
		}
		try
		{
			PropertyInfo property = type.GetProperty(memberName, bindingAttr);
			if (property != null && property.PropertyType == typeof(bool) && property.CanWrite && property.GetIndexParameters().Length == 0)
			{
				MethodInfo setMethod = property.GetSetMethod(nonPublic: true);
				object obj3 = ((setMethod != null && setMethod.IsStatic) ? null : target);
				if ((setMethod != null && setMethod.IsStatic) || obj3 != null)
				{
					property.SetValue(obj3, value, null);
					return true;
				}
			}
		}
		catch
		{
		}
		return false;
	}

	private bool InvokeParameterlessMethodIfExists(Type type, object target, string methodName)
	{
		if (type == null || string.IsNullOrEmpty(methodName))
		{
			return false;
		}
		BindingFlags bindingAttr = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;
		try
		{
			MethodInfo method = type.GetMethod(methodName, bindingAttr, null, Type.EmptyTypes, null);
			if (method == null)
			{
				return false;
			}
			object obj = (method.IsStatic ? null : target);
			if (!method.IsStatic && obj == null)
			{
				return false;
			}
			method.Invoke(obj, null);
			return true;
		}
		catch
		{
			return false;
		}
	}

	private bool IsFeatureAllowed(int featureBit)
	{
		if (!BirdieHostBridge.IsUnderHostControl)
		{
			return true;
		}
		if (featureBit < 0)
		{
			return true;
		}
		return (BirdieHostBridge.ReceivedFeatureMask & (ulong)(1L << featureBit)) != 0;
	}

	private void SetHostControlsActive(bool active)
	{
		hostControlsActive = active;
		BirdieHostBridge.BroadcastToClients(active, active ? hostAllowedFeatureMask : ulong.MaxValue);
		MarkHudDirty();
	}

	private void SetHostFeatureBit(int bit, bool enabled)
	{
		if (enabled)
		{
			hostAllowedFeatureMask |= (ulong)(1L << bit);
		}
		else
		{
			hostAllowedFeatureMask &= (ulong)(~(1L << bit));
		}
		if (hostControlsActive)
		{
			BirdieHostBridge.BroadcastToClients(active: true, hostAllowedFeatureMask);
		}
	}

	private void InitializeWindExtrasReflection()
	{
		if (windExtrasReflectionInitialized)
		{
			return;
		}
		windExtrasReflectionInitialized = true;
		try
		{
			Type type = null;
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			for (int i = 0; i < assemblies.Length; i++)
			{
				type = assemblies[i].GetType("WindManager");
				if (type != null)
				{
					break;
				}
			}
			if (type == null)
			{
				BirdieLog.Warning("[Birdie] WindManager type not found");
				return;
			}
			Object val = Object.FindObjectOfType(type);
			if (val == (Object)null)
			{
				BirdieLog.Warning("[Birdie] WindManager not found in scene");
				return;
			}
			FieldInfo field = type.GetField("windSettings", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (field == null)
			{
				BirdieLog.Warning("[Birdie] WindManager.windSettings field not found");
				return;
			}
			object value = field.GetValue(val);
			if (value == null)
			{
				BirdieLog.Warning("[Birdie] WindManager.windSettings value is null");
				return;
			}
			cachedWindForceScaleField = value.GetType().GetField("forceScale", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (cachedWindForceScaleField != null && cachedWindForceScaleField.FieldType == typeof(float))
			{
				savedWindForceScale = (float)cachedWindForceScaleField.GetValue(value);
				cachedWindSettingsInstance = value;
			}
			else
			{
				BirdieLog.Warning("[Birdie] WindSettings.forceScale field not found");
			}
		}
		catch (Exception ex)
		{
			BirdieLog.Warning("[Birdie] Wind reflection error: " + ex.Message);
		}
	}

	private void ToggleNoWind()
	{
		if (IsFeatureAllowed(3))
		{
			noWindEnabled = !noWindEnabled;
			InitializeWindExtrasReflection();
			BirdieLog.Msg(string.Format("[Birdie] No Wind {0} | ws={1} field={2}", noWindEnabled ? "ON" : "OFF", (cachedWindSettingsInstance != null) ? "OK" : "NULL", (cachedWindForceScaleField != null) ? cachedWindForceScaleField.Name : "NULL"));
			if (noWindEnabled)
			{
				ApplyNoWindState();
			}
			else
			{
				RestoreWindState();
			}
			MarkHudDirty();
		}
	}

	private void ApplyNoWindState()
	{
		if (cachedWindSettingsInstance == null || cachedWindForceScaleField == null)
		{
			return;
		}
		try
		{
			cachedWindForceScaleField.SetValue(cachedWindSettingsInstance, 0f);
		}
		catch
		{
		}
	}

	private void RestoreWindState()
	{
		if (cachedWindSettingsInstance == null || cachedWindForceScaleField == null)
		{
			return;
		}
		try
		{
			cachedWindForceScaleField.SetValue(cachedWindSettingsInstance, savedWindForceScale);
		}
		catch
		{
		}
	}

	private void TogglePerfectShot()
	{
		if (IsFeatureAllowed(4))
		{
			perfectShotEnabled = !perfectShotEnabled;
			BirdieLog.Msg(perfectShotEnabled ? "[Birdie] Perfect Shot ON" : "[Birdie] Perfect Shot OFF");
			MarkHudDirty();
		}
	}

	private void ApplyPerfectShotForcing()
	{
		if (!perfectShotEnabled || (Object)(object)playerGolfer == (Object)null || !isLeftMousePressed)
		{
			return;
		}
		try
		{
			if (swingNormalizedPowerBackingField == null)
			{
				swingNormalizedPowerBackingField = ((object)playerGolfer).GetType().GetField("<SwingNormalizedPower>k__BackingField", BindingFlags.Instance | BindingFlags.NonPublic);
				if (swingNormalizedPowerBackingField == null)
				{
					FieldInfo[] fields = ((object)playerGolfer).GetType().GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					foreach (FieldInfo fieldInfo in fields)
					{
						if (fieldInfo.FieldType == typeof(float))
						{
							string text = fieldInfo.Name.ToLower();
							if (text.Contains("swing") && text.Contains("power"))
							{
								swingNormalizedPowerBackingField = fieldInfo;
								break;
							}
						}
					}
				}
				if (!_perfectShotLogged)
				{
					_perfectShotLogged = true;
					BirdieLog.Msg("[Birdie] Perfect Shot backing field: " + ((swingNormalizedPowerBackingField != null) ? swingNormalizedPowerBackingField.Name : "NOT FOUND") + " | type=" + ((object)playerGolfer).GetType().Name);
					FieldInfo[] fields = ((object)playerGolfer).GetType().GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					foreach (FieldInfo fieldInfo2 in fields)
					{
						if (fieldInfo2.FieldType == typeof(float))
						{
							BirdieLog.Msg("[Birdie] float field: " + fieldInfo2.Name);
						}
					}
				}
			}
			if (swingNormalizedPowerBackingField != null)
			{
				swingNormalizedPowerBackingField.SetValue(playerGolfer, 0.999f);
			}
		}
		catch (Exception ex)
		{
			BirdieLog.Warning("[Birdie] Perfect Shot error: " + ex.Message);
		}
	}

	private void InitializeAirDragExtrasReflection()
	{
		if (airDragExtrasReflectionInitialized)
		{
			return;
		}
		airDragExtrasReflectionInitialized = true;
		try
		{
			object golfBallSettingsObject = GetGolfBallSettingsObject();
			if (golfBallSettingsObject == null)
			{
				BirdieLog.Warning("[Birdie] GolfBallSettings is null");
				return;
			}
			Type type = golfBallSettingsObject.GetType();
			cachedLinearAirDragField = type.GetField("<LinearAirDragFactor>k__BackingField", BindingFlags.Instance | BindingFlags.NonPublic);
			if (cachedLinearAirDragField != null && cachedLinearAirDragField.FieldType == typeof(float))
			{
				savedLinearAirDrag = (float)cachedLinearAirDragField.GetValue(golfBallSettingsObject);
			}
			else
			{
				BirdieLog.Warning("[Birdie] <LinearAirDragFactor>k__BackingField not found on " + type.Name);
			}
		}
		catch (Exception ex)
		{
			BirdieLog.Warning("[Birdie] AirDrag reflection error: " + ex.Message);
		}
	}

	private void ToggleNoAirDrag()
	{
		if (IsFeatureAllowed(5))
		{
			noAirDragEnabled = !noAirDragEnabled;
			InitializeAirDragExtrasReflection();
			if (noAirDragEnabled)
			{
				ApplyNoAirDragState();
				BirdieLog.Msg($"[Birdie] No Air Drag ON (saved={savedLinearAirDrag:F5})");
			}
			else
			{
				RestoreAirDragState();
				BirdieLog.Msg("[Birdie] No Air Drag OFF");
			}
			MarkHudDirty();
		}
	}

	private void ApplyNoAirDragState()
	{
		if (cachedLinearAirDragField == null)
		{
			return;
		}
		try
		{
			object golfBallSettingsObject = GetGolfBallSettingsObject();
			if (golfBallSettingsObject != null)
			{
				cachedLinearAirDragField.SetValue(golfBallSettingsObject, 1E-05f);
			}
		}
		catch
		{
		}
	}

	private void RestoreAirDragState()
	{
		if (cachedLinearAirDragField == null)
		{
			return;
		}
		try
		{
			object golfBallSettingsObject = GetGolfBallSettingsObject();
			if (golfBallSettingsObject != null)
			{
				cachedLinearAirDragField.SetValue(golfBallSettingsObject, savedLinearAirDrag);
			}
		}
		catch
		{
		}
	}

	private void InitializeMoveSpeedExtrasReflection()
	{
		if (moveSpeedExtrasReflectionInitialized)
		{
			return;
		}
		moveSpeedExtrasReflectionInitialized = true;
		try
		{
			Type type = null;
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			for (int i = 0; i < assemblies.Length; i++)
			{
				type = assemblies[i].GetType("GameManager");
				if (type != null)
				{
					break;
				}
			}
			if (type == null)
			{
				BirdieLog.Warning("[Birdie] GameManager type not found");
				return;
			}
			cachedPlayerMovSettingsProperty = type.GetProperty("PlayerMovementSettings", BindingFlags.Static | BindingFlags.Public);
			if (cachedPlayerMovSettingsProperty == null)
			{
				BirdieLog.Warning("[Birdie] GameManager.PlayerMovementSettings property not found");
				return;
			}
			object value = cachedPlayerMovSettingsProperty.GetValue(null, null);
			if (value == null)
			{
				BirdieLog.Warning("[Birdie] PlayerMovementSettings value is null");
				return;
			}
			Type type2 = value.GetType();
			cachedDefaultMoveSpeedField = type2.GetField("<DefaultMoveSpeed>k__BackingField", BindingFlags.Instance | BindingFlags.NonPublic);
			if (cachedDefaultMoveSpeedField != null && cachedDefaultMoveSpeedField.FieldType == typeof(float))
			{
				savedDefaultMoveSpeed = (float)cachedDefaultMoveSpeedField.GetValue(value);
			}
			else
			{
				BirdieLog.Warning("[Birdie] <DefaultMoveSpeed>k__BackingField not found on " + type2.Name);
			}
		}
		catch (Exception ex)
		{
			BirdieLog.Warning("[Birdie] MoveSpeed reflection error: " + ex.Message);
		}
	}

	private void ToggleSpeedMultiplier()
	{
		if (IsFeatureAllowed(6))
		{
			speedMultiplierEnabled = !speedMultiplierEnabled;
			InitializeMoveSpeedExtrasReflection();
			if (speedMultiplierEnabled)
			{
				ApplySpeedMultiplierState();
				BirdieLog.Msg($"[Birdie] Speed Multiplier ON (x{speedMultiplierFactor:F1}, base={savedDefaultMoveSpeed:F2})");
			}
			else
			{
				RestoreSpeedState();
				BirdieLog.Msg("[Birdie] Speed Multiplier OFF");
			}
			MarkHudDirty();
		}
	}

	private void ApplySpeedMultiplierState()
	{
		if (cachedPlayerMovSettingsProperty == null || cachedDefaultMoveSpeedField == null)
		{
			return;
		}
		try
		{
			object value = cachedPlayerMovSettingsProperty.GetValue(null, null);
			if (value != null)
			{
				cachedDefaultMoveSpeedField.SetValue(value, savedDefaultMoveSpeed * speedMultiplierFactor);
			}
		}
		catch
		{
		}
	}

	private void RestoreSpeedState()
	{
		if (cachedPlayerMovSettingsProperty == null || cachedDefaultMoveSpeedField == null)
		{
			return;
		}
		try
		{
			object value = cachedPlayerMovSettingsProperty.GetValue(null, null);
			if (value != null)
			{
				cachedDefaultMoveSpeedField.SetValue(value, savedDefaultMoveSpeed);
			}
		}
		catch
		{
		}
	}

	private void InitializeAmmoInventoryReflection()
	{
		if (ammoInventoryReflectionReady)
		{
			return;
		}
		ammoInventoryReflectionReady = true;
		try
		{
			Type type = null;
			Type type2 = null;
			Type type3 = null;
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			foreach (Assembly assembly in assemblies)
			{
				if (type == null)
				{
					type = assembly.GetType("GameManager");
				}
				if (type2 == null)
				{
					type2 = assembly.GetType("PlayerInventory");
				}
				if (type3 == null)
				{
					type3 = assembly.GetType("InventorySlot");
				}
				if (type != null && type2 != null && type3 != null)
				{
					break;
				}
			}
			if (type == null || type2 == null || type3 == null)
			{
				BirdieLog.Warning("[Birdie] Ammo: required types not found (GM=" + ((type != null) ? "ok" : "NULL") + " PI=" + ((type2 != null) ? "ok" : "NULL") + " IS=" + ((type3 != null) ? "ok" : "NULL") + ")");
				return;
			}
			cachedLocalPlayerInventoryProperty = type.GetProperty("LocalPlayerInventory", BindingFlags.Static | BindingFlags.Public);
			cachedInventorySlotsSyncListField = type2.GetField("slots", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			cachedInventoryOverridesDictField = type2.GetField("localPlayerSlotOverrides", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			cachedInvSlotItemTypeField = type3.GetField("itemType", BindingFlags.Instance | BindingFlags.Public);
			Type type4 = cachedInvSlotItemTypeField?.FieldType;
			if (type4 != null)
			{
				cachedInvSlotConstructor = type3.GetConstructor(new Type[2]
				{
					type4,
					typeof(int)
				});
			}
			if (cachedLocalPlayerInventoryProperty != null && cachedInventorySlotsSyncListField != null && cachedInventoryOverridesDictField != null && cachedInvSlotItemTypeField != null && cachedInvSlotConstructor != null)
			{
				BirdieLog.Msg("[Birdie] Ammo inventory reflection ready");
				return;
			}
			BirdieLog.Warning("[Birdie] Ammo: one or more fields missing — inv=" + ((cachedLocalPlayerInventoryProperty != null) ? "ok" : "NULL") + " slots=" + ((cachedInventorySlotsSyncListField != null) ? "ok" : "NULL") + " overrides=" + ((cachedInventoryOverridesDictField != null) ? "ok" : "NULL") + " itemType=" + ((cachedInvSlotItemTypeField != null) ? "ok" : "NULL") + " ctor=" + ((cachedInvSlotConstructor != null) ? "ok" : "NULL"));
		}
		catch (Exception ex)
		{
			BirdieLog.Warning("[Birdie] Ammo inventory reflection error: " + ex.Message);
		}
	}

	private void ToggleInfiniteAmmo()
	{
		if (IsFeatureAllowed(7))
		{
			infiniteAmmoEnabled = !infiniteAmmoEnabled;
			if (!infiniteAmmoEnabled)
			{
				ammoItemTypeBackup.Clear();
				BirdieInfiniteAmmoBridge.LocalPlayerInventory = null;
			}
			BirdieInfiniteAmmoBridge.EnsurePatchApplied();
			BirdieInfiniteAmmoBridge.IsActive = infiniteAmmoEnabled;
			BirdieLog.Msg(infiniteAmmoEnabled ? "[Birdie] Infinite Item Usage ON" : "[Birdie] Infinite Item Usage OFF");
			MarkHudDirty();
		}
	}

	private void TickInfiniteAmmo()
	{
		if (!infiniteAmmoEnabled)
		{
			return;
		}
		if (!ammoInventoryReflectionReady)
		{
			InitializeAmmoInventoryReflection();
		}
		if (cachedLocalPlayerInventoryProperty == null || cachedInventorySlotsSyncListField == null || cachedInventoryOverridesDictField == null || cachedInvSlotItemTypeField == null || cachedInvSlotConstructor == null)
		{
			return;
		}
		try
		{
			object value = cachedLocalPlayerInventoryProperty.GetValue(null, null);
			if (value == null)
			{
				return;
			}
			BirdieInfiniteAmmoBridge.LocalPlayerInventory = value;
			IList list = cachedInventorySlotsSyncListField.GetValue(value) as IList;
			IDictionary dictionary = cachedInventoryOverridesDictField.GetValue(value) as IDictionary;
			if (list == null || dictionary == null)
			{
				return;
			}
			for (int i = 0; i < list.Count; i++)
			{
				object obj = list[i];
				object obj2 = ((obj != null) ? cachedInvSlotItemTypeField.GetValue(obj) : null);
				object obj3 = (dictionary.Contains(i) ? dictionary[i] : null);
				object obj4 = ((obj3 != null) ? cachedInvSlotItemTypeField.GetValue(obj3) : null);
				object value2 = null;
				if (obj4 != null && (int)obj4 != 0)
				{
					value2 = obj4;
				}
				else if (obj2 != null && (int)obj2 != 0)
				{
					value2 = obj2;
				}
				else
				{
					ammoItemTypeBackup.TryGetValue(i, out value2);
				}
				if (value2 != null && (int)value2 != 0)
				{
					ammoItemTypeBackup[i] = value2;
					dictionary[i] = cachedInvSlotConstructor.Invoke(new object[2] { value2, 99 });
				}
			}
		}
		catch (Exception ex)
		{
			BirdieLog.Warning("[Birdie] Infinite ammo tick error: " + ex.Message);
		}
	}

	private void InitializeScreenshakeExtrasReflection()
	{
		if (screenshakeExtrasReflectionInitialized)
		{
			return;
		}
		screenshakeExtrasReflectionInitialized = true;
		try
		{
			Type type = null;
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			for (int i = 0; i < assemblies.Length; i++)
			{
				type = assemblies[i].GetType("GameSettings");
				if (type != null)
				{
					break;
				}
			}
			if (type == null)
			{
				BirdieLog.Warning("[Birdie] GameSettings type not found");
				return;
			}
			PropertyInfo property = type.GetProperty("All", BindingFlags.Static | BindingFlags.Public);
			if (property == null)
			{
				BirdieLog.Warning("[Birdie] GameSettings.All property not found");
				return;
			}
			object value = property.GetValue(null, null);
			if (value == null)
			{
				BirdieLog.Warning("[Birdie] GameSettings.All is null");
				return;
			}
			PropertyInfo property2 = value.GetType().GetProperty("General", BindingFlags.Instance | BindingFlags.Public);
			if (property2 == null)
			{
				BirdieLog.Warning("[Birdie] AllSettings.General property not found");
				return;
			}
			object value2 = property2.GetValue(value, null);
			if (value2 == null)
			{
				BirdieLog.Warning("[Birdie] AllSettings.General is null");
				return;
			}
			FieldInfo field = value2.GetType().GetField("screenshakeFactor", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (field != null && field.FieldType == typeof(float))
			{
				cachedScreenshakeOwner = value2;
				cachedScreenshakeFactorField = field;
				savedScreenshakeFactor = (float)field.GetValue(value2);
			}
			else
			{
				BirdieLog.Warning("[Birdie] screenshakeFactor field not found on GeneralSettings");
			}
		}
		catch (Exception ex)
		{
			BirdieLog.Warning("[Birdie] Screenshake reflection error: " + ex.Message);
		}
	}

	private void ToggleNoRecoil()
	{
		if (IsFeatureAllowed(8))
		{
			noRecoilEnabled = !noRecoilEnabled;
			InitializeScreenshakeExtrasReflection();
			if (noRecoilEnabled)
			{
				ApplyNoRecoilState();
				BirdieLog.Msg($"[Birdie] No Recoil ON (saved shake={savedScreenshakeFactor:F3})");
			}
			else
			{
				RestoreRecoilState();
				BirdieLog.Msg("[Birdie] No Recoil OFF");
			}
			MarkHudDirty();
		}
	}

	private void ApplyNoRecoilState()
	{
		if (cachedScreenshakeOwner == null || cachedScreenshakeFactorField == null)
		{
			return;
		}
		try
		{
			cachedScreenshakeFactorField.SetValue(cachedScreenshakeOwner, 0f);
		}
		catch
		{
		}
	}

	private void RestoreRecoilState()
	{
		if (cachedScreenshakeOwner == null || cachedScreenshakeFactorField == null)
		{
			return;
		}
		try
		{
			cachedScreenshakeFactorField.SetValue(cachedScreenshakeOwner, savedScreenshakeFactor);
		}
		catch
		{
		}
	}

	private void InitializeKnockbackImmunityReflection()
	{
		if (knockbackImmunityReflectionReady)
		{
			return;
		}
		knockbackImmunityReflectionReady = true;
		try
		{
			Type type = null;
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			for (int i = 0; i < assemblies.Length; i++)
			{
				type = assemblies[i].GetType("PlayerMovement");
				if (type != null)
				{
					break;
				}
			}
			if (type == null)
			{
				BirdieLog.Warning("[Birdie] No Knockback: PlayerMovement type not found");
				return;
			}
			cachedKnockoutImmunityStatusField = type.GetField("knockoutImmunityStatus", BindingFlags.Instance | BindingFlags.NonPublic);
			if (cachedKnockoutImmunityStatusField == null)
			{
				BirdieLog.Warning("[Birdie] No Knockback: knockoutImmunityStatus field not found");
				return;
			}
			Type fieldType = cachedKnockoutImmunityStatusField.FieldType;
			cachedHasImmunityField = fieldType.GetField("hasImmunity", BindingFlags.Instance | BindingFlags.Public);
			if (cachedHasImmunityField == null)
			{
				BirdieLog.Warning("[Birdie] No Knockback: hasImmunity field not found on " + fieldType.Name);
			}
			else
			{
				BirdieLog.Msg("[Birdie] Knockback immunity reflection ready (struct=" + fieldType.Name + ")");
			}
		}
		catch (Exception ex)
		{
			BirdieLog.Warning("[Birdie] Knockback immunity reflection error: " + ex.Message);
			knockbackImmunityReflectionReady = false;
		}
	}

	private void ToggleNoKnockback()
	{
		if (IsFeatureAllowed(9))
		{
			noKnockbackEnabled = !noKnockbackEnabled;
			BirdieNoKnockbackBridge.EnsurePatchApplied();
			BirdieNoKnockbackBridge.IsActive = noKnockbackEnabled;
			BirdieLog.Msg(noKnockbackEnabled ? "[Birdie] No Knockback ON" : "[Birdie] No Knockback OFF");
			MarkHudDirty();
		}
	}

	private void ToggleLandmineImmunity()
	{
		if (IsFeatureAllowed(10))
		{
			landmineImmunityEnabled = !landmineImmunityEnabled;
			BirdieLandmineImmunityBridge.EnsurePatchApplied();
			BirdieLandmineImmunityBridge.IsActive = landmineImmunityEnabled;
			BirdieLog.Msg(landmineImmunityEnabled ? "[Birdie] Landmine Immunity ON" : "[Birdie] Landmine Immunity OFF");
			MarkHudDirty();
		}
	}

	private void InitializeLockOnReflection()
	{
		if (lockOnReflectionInitialized)
		{
			return;
		}
		lockOnReflectionInitialized = true;
		try
		{
			Type type = null;
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			for (int i = 0; i < assemblies.Length; i++)
			{
				type = assemblies[i].GetType("GameManager");
				if (type != null)
				{
					break;
				}
			}
			if (type == null)
			{
				BirdieLog.Warning("[Birdie] Lock-On: GameManager not found");
				return;
			}
			PropertyInfo property = type.GetProperty("GolfSettings", BindingFlags.Static | BindingFlags.Public);
			if (property == null)
			{
				BirdieLog.Warning("[Birdie] Lock-On: GolfSettings property not found");
				return;
			}
			object value = property.GetValue(null, null);
			if (value == null)
			{
				BirdieLog.Warning("[Birdie] Lock-On: GolfSettings is null");
				return;
			}
			Type type2 = value.GetType();
			cachedLockOnMaxDistanceField = type2.GetField("<LockOnMaxDistance>k__BackingField", BindingFlags.Instance | BindingFlags.NonPublic);
			if (cachedLockOnMaxDistanceField == null)
			{
				cachedLockOnMaxDistanceField = type2.GetField("LockOnMaxDistance", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			}
			if (cachedLockOnMaxDistanceField != null && cachedLockOnMaxDistanceField.FieldType == typeof(float))
			{
				savedLockOnMaxDistance = (float)cachedLockOnMaxDistanceField.GetValue(value);
				BirdieLog.Msg("[Birdie] Lock-On reflection ready, default dist=" + savedLockOnMaxDistance);
			}
			else
			{
				BirdieLog.Warning("[Birdie] Lock-On: LockOnMaxDistance field not found");
				cachedLockOnMaxDistanceField = null;
			}
		}
		catch (Exception ex)
		{
			BirdieLog.Warning("[Birdie] Lock-On reflection error: " + ex.Message);
		}
	}

	private void ToggleLockOnAnyDistance()
	{
		if (IsFeatureAllowed(11))
		{
			lockOnAnyDistanceEnabled = !lockOnAnyDistanceEnabled;
			InitializeLockOnReflection();
			if (lockOnAnyDistanceEnabled)
			{
				ApplyLockOnAnyDistance();
			}
			else
			{
				RestoreLockOnDistance();
			}
			BirdieLog.Msg(lockOnAnyDistanceEnabled ? "[Birdie] Lock-On Any Distance ON" : "[Birdie] Lock-On Any Distance OFF");
			MarkHudDirty();
		}
	}

	private void ApplyLockOnAnyDistance()
	{
		if (cachedLockOnMaxDistanceField == null)
		{
			return;
		}
		try
		{
			Type type = null;
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			for (int i = 0; i < assemblies.Length; i++)
			{
				type = assemblies[i].GetType("GameManager");
				if (type != null)
				{
					break;
				}
			}
			if (type == null)
			{
				return;
			}
			PropertyInfo property = type.GetProperty("GolfSettings", BindingFlags.Static | BindingFlags.Public);
			if (!(property == null))
			{
				object value = property.GetValue(null, null);
				if (value != null)
				{
					cachedLockOnMaxDistanceField.SetValue(value, 9999f);
				}
			}
		}
		catch
		{
		}
	}

	private void RestoreLockOnDistance()
	{
		if (cachedLockOnMaxDistanceField == null)
		{
			return;
		}
		try
		{
			Type type = null;
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			for (int i = 0; i < assemblies.Length; i++)
			{
				type = assemblies[i].GetType("GameManager");
				if (type != null)
				{
					break;
				}
			}
			if (type == null)
			{
				return;
			}
			PropertyInfo property = type.GetProperty("GolfSettings", BindingFlags.Static | BindingFlags.Public);
			if (!(property == null))
			{
				object value = property.GetValue(null, null);
				if (value != null)
				{
					cachedLockOnMaxDistanceField.SetValue(value, savedLockOnMaxDistance);
				}
			}
		}
		catch
		{
		}
	}

	private void TickNoKnockback()
	{
		if ((!noKnockbackEnabled && !landmineImmunityEnabled) || (Object)(object)playerMovement == (Object)null)
		{
			BirdieNoKnockbackBridge.LocalPlayerHittable = null;
			BirdieLandmineImmunityBridge.LocalPlayerHittable = null;
			return;
		}
		if ((Object)(object)localPlayerHittable == (Object)null)
		{
			Transform val = playerMovement.transform;
			while ((Object)(object)val != (Object)null && (Object)(object)localPlayerHittable == (Object)null)
			{
				Component[] components = ((Component)val).GetComponents<Component>();
				for (int i = 0; i < components.Length; i++)
				{
					if ((Object)(object)components[i] != (Object)null && ((object)components[i]).GetType().Name == "Hittable")
					{
						localPlayerHittable = components[i];
						break;
					}
				}
				val = val.parent;
			}
			if ((Object)(object)localPlayerHittable == (Object)null)
			{
				Component[] componentsInChildren = playerMovement.GetComponentsInChildren<Component>();
				for (int j = 0; j < componentsInChildren.Length; j++)
				{
					if ((Object)(object)componentsInChildren[j] != (Object)null && ((object)componentsInChildren[j]).GetType().Name == "Hittable")
					{
						localPlayerHittable = componentsInChildren[j];
						break;
					}
				}
			}
		}
		BirdieNoKnockbackBridge.LocalPlayerHittable = (noKnockbackEnabled ? localPlayerHittable : null);
		BirdieLandmineImmunityBridge.LocalPlayerHittable = (landmineImmunityEnabled ? localPlayerHittable : null);
		if (!noKnockbackEnabled)
		{
			return;
		}
		if (!knockbackImmunityReflectionReady)
		{
			InitializeKnockbackImmunityReflection();
		}
		if (cachedKnockoutImmunityStatusField == null || cachedHasImmunityField == null)
		{
			return;
		}
		try
		{
			object value = cachedKnockoutImmunityStatusField.GetValue(playerMovement);
			if (value != null && !(bool)cachedHasImmunityField.GetValue(value))
			{
				cachedHasImmunityField.SetValue(value, true);
				cachedKnockoutImmunityStatusField.SetValue(playerMovement, value);
			}
		}
		catch
		{
		}
	}

	private void InitializeExpandedSlotsReflection()
	{
		if (expandedSlotsReflectionInitialized)
		{
			return;
		}
		expandedSlotsReflectionInitialized = true;
		try
		{
			Type type = null;
			Type type2 = null;
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			foreach (Assembly assembly in assemblies)
			{
				if (type == null)
				{
					type = assembly.GetType("Hotkeys");
				}
				if (type2 == null)
				{
					type2 = assembly.GetType("GameManager");
				}
				if (type != null && type2 != null)
				{
					break;
				}
			}
			if (type == null || type2 == null)
			{
				BirdieLog.Warning("[Birdie] ExpandedSlots: Hotkeys or GameManager type not found");
				return;
			}
			Object val = Object.FindObjectOfType(type);
			if (val == (Object)null)
			{
				BirdieLog.Warning("[Birdie] ExpandedSlots: Hotkeys instance not in scene");
				return;
			}
			cachedExpandedHotkeysInstance = val;
			cachedHotkeyUisField = type.GetField("hotkeyUis", BindingFlags.Instance | BindingFlags.NonPublic);
			if (cachedHotkeyUisField == null)
			{
				BirdieLog.Warning("[Birdie] ExpandedSlots: hotkeyUis field not found");
				return;
			}
			PropertyInfo property = type2.GetProperty("PlayerInventorySettings", BindingFlags.Static | BindingFlags.Public);
			if (property == null)
			{
				BirdieLog.Warning("[Birdie] ExpandedSlots: PlayerInventorySettings property not found");
				return;
			}
			cachedExpandedPlayerInvSettings = property.GetValue(null);
			if (cachedExpandedPlayerInvSettings == null)
			{
				BirdieLog.Warning("[Birdie] ExpandedSlots: PlayerInventorySettings is null");
				return;
			}
			cachedMaxItemsBackingField = cachedExpandedPlayerInvSettings.GetType().GetField("<MaxItems>k__BackingField", BindingFlags.Instance | BindingFlags.NonPublic);
			if (cachedMaxItemsBackingField == null)
			{
				cachedMaxItemsBackingField = cachedExpandedPlayerInvSettings.GetType().GetField("MaxItems", BindingFlags.Instance | BindingFlags.NonPublic);
			}
			if (cachedMaxItemsBackingField == null)
			{
				BirdieLog.Warning("[Birdie] ExpandedSlots: MaxItems field not found");
			}
		}
		catch (Exception ex)
		{
			BirdieLog.Warning("[Birdie] ExpandedSlots init error: " + ex.Message);
		}
	}

	private void ToggleExpandedSlots()
	{
		if (IsFeatureAllowed(12))
		{
			expandedSlotsEnabled = !expandedSlotsEnabled;
			if (expandedSlotsEnabled)
			{
				ApplyExpandedSlots();
			}
			else
			{
				RestoreExpandedSlots();
			}
			MarkHudDirty();
		}
	}

	private void ApplyExpandedSlots()
	{
		//IL_0109: Unknown result type (might be due to invalid IL or missing references)
		//IL_0110: Expected O, but got Unknown
		//IL_013a: Unknown result type (might be due to invalid IL or missing references)
		//IL_013f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0174: Unknown result type (might be due to invalid IL or missing references)
		//IL_0192: Unknown result type (might be due to invalid IL or missing references)
		//IL_0199: Unknown result type (might be due to invalid IL or missing references)
		//IL_019e: 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_01a3: Unknown result type (might be due to invalid IL or missing references)
		//IL_02f7: Unknown result type (might be due to invalid IL or missing references)
		//IL_02fc: Unknown result type (might be due to invalid IL or missing references)
		//IL_0301: Unknown result type (might be due to invalid IL or missing references)
		//IL_0339: Unknown result type (might be due to invalid IL or missing references)
		//IL_0356: Unknown result type (might be due to invalid IL or missing references)
		//IL_0360: Unknown result type (might be due to invalid IL or missing references)
		//IL_0327: Unknown result type (might be due to invalid IL or missing references)
		//IL_0285: Unknown result type (might be due to invalid IL or missing references)
		//IL_028a: Unknown result type (might be due to invalid IL or missing references)
		//IL_028c: Unknown result type (might be due to invalid IL or missing references)
		InitializeExpandedSlotsReflection();
		if (cachedExpandedHotkeysInstance == null || cachedHotkeyUisField == null || cachedMaxItemsBackingField == null)
		{
			BirdieLog.Warning("[Birdie] ExpandedSlots: reflection not ready, cannot apply");
			expandedSlotsEnabled = false;
			return;
		}
		try
		{
			int num = (int)cachedMaxItemsBackingField.GetValue(cachedExpandedPlayerInvSettings);
			if (num >= 7)
			{
				BirdieLog.Warning("[Birdie] ExpandedSlots: already at target or beyond (" + num + ")");
				return;
			}
			savedOriginalMaxItems = num;
			Array array = (Array)cachedHotkeyUisField.GetValue(cachedExpandedHotkeysInstance);
			if (array == null || array.Length < 2)
			{
				BirdieLog.Warning("[Birdie] ExpandedSlots: hotkeyUis array is null or too small");
				expandedSlotsEnabled = false;
				return;
			}
			savedOriginalHotkeyUisArray = array;
			int num2 = 8;
			Type elementType = array.GetType().GetElementType();
			Array array2 = Array.CreateInstance(elementType, num2);
			for (int i = 0; i < Math.Min(array.Length, num2); i++)
			{
				array2.SetValue(array.GetValue(i), i);
			}
			Component val = (Component)array.GetValue(1);
			Transform parent = val.transform.parent;
			RectTransform component = val.GetComponent<RectTransform>();
			object obj;
			if (array.Length <= 2)
			{
				obj = null;
			}
			else
			{
				Component val2 = (Component)array.GetValue(2);
				obj = (((int)val2 != 0) ? val2.GetComponent<RectTransform>() : null);
			}
			RectTransform val3 = (RectTransform)obj;
			Vector2 val4 = (Vector2)(((Object)(object)component != (Object)null && (Object)(object)val3 != (Object)null) ? (val3.anchoredPosition - component.anchoredPosition) : new Vector2(((Object)(object)component != (Object)null) ? (component.sizeDelta.x + 4f) : 80f, 0f));
			for (int j = num + 1; j <= 7; j++)
			{
				if (j < array.Length)
				{
					object value = array.GetValue(j);
					if (value != null)
					{
						Component val5 = (Component)((value is Component) ? value : null);
						if (val5 != null && (Object)(object)val5 != (Object)null && (Object)(object)val5.gameObject != (Object)null)
						{
							array2.SetValue(value, j);
							continue;
						}
					}
				}
				GameObject val6 = Object.Instantiate<GameObject>(val.gameObject, parent);
				((Object)val6).name = "HotkeyUi_Extra_" + j;
				RectTransform component2 = val6.GetComponent<RectTransform>();
				if ((Object)(object)component2 != (Object)null && (Object)(object)component != (Object)null)
				{
					RectTransform val7 = null;
					if (j > 1)
					{
						object? value2 = array2.GetValue(j - 1);
						Component val8 = (Component)((value2 is Component) ? value2 : null);
						if (val8 != null && (Object)(object)val8 != (Object)null)
						{
							val7 = val8.GetComponent<RectTransform>();
						}
					}
					if ((Object)(object)val7 == (Object)null)
					{
						val7 = component;
					}
					component2.anchoredPosition = val7.anchoredPosition + val4;
				}
				val6.SetActive(true);
				Component value3 = val6.GetComponent(elementType) ?? val6.GetComponent<Component>();
				array2.SetValue(value3, j);
				spawnedExtraHotkeyUiObjects.Add(val6);
			}
			savedSlotParentTransform = parent;
			RectTransform component3 = ((Component)parent).GetComponent<RectTransform>();
			if ((Object)(object)component3 != (Object)null)
			{
				savedSlotParentSizeDelta = component3.sizeDelta;
				float num3 = ((Mathf.Abs(val4.x) > 1f) ? Mathf.Abs(val4.x) : (((Object)(object)component != (Object)null) ? (component.sizeDelta.x + 4f) : 84f));
				component3.sizeDelta = new Vector2(num3 * (float)num2 + 20f, component3.sizeDelta.y);
			}
			Mask component4 = ((Component)parent).GetComponent<Mask>();
			savedSlotParentMaskEnabled = (Object)(object)component4 != (Object)null && ((Behaviour)component4).enabled;
			if ((Object)(object)component4 != (Object)null)
			{
				((Behaviour)component4).enabled = false;
			}
			RectMask2D component5 = ((Component)parent).GetComponent<RectMask2D>();
			if ((Object)(object)component5 != (Object)null)
			{
				((Behaviour)component5).enabled = false;
			}
			cachedHotkeyUisField.SetValue(cachedExpandedHotkeysInstance, array2);
			cachedMaxItemsBackingField.SetValue(cachedExpandedPlayerInvSettings, 7);
			try
			{
				cachedExpandedHotkeysInstance.GetType().GetMethod("ForceRefreshCurrentModeInternal", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.Invoke(cachedExpandedHotkeysInstance, null);
			}
			catch
			{
			}
			TryExpandServerInventorySlots();
			BirdieLog.Msg("[Birdie] ExpandedSlots: expanded to " + 7 + " slots (orig array len=" + array.Length + ", currentMax=" + num + ")");
		}
		catch (Exception ex)
		{
			BirdieLog.Warning("[Birdie] ExpandedSlots apply error: " + ex.Message + "\n" + ex.StackTrace);
			expandedSlotsEnabled = false;
			RestoreExpandedSlots();
		}
	}

	private void TryExpandServerInventorySlotsPublic()
	{
		TryExpandServerInventorySlots();
	}

	private Component GetLocalPlayerInventoryComponent(Type piType)
	{
		try
		{
			Type type = null;
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			for (int i = 0; i < assemblies.Length; i++)
			{
				type = assemblies[i].GetType("GameManager");
				if (type != null)
				{
					break;
				}
			}
			if (type == null)
			{
				return null;
			}
			object? obj = type.GetProperty("LocalPlayerInventory", BindingFlags.Static | BindingFlags.Public)?.GetValue(null);
			return (Component)((obj is Component) ? obj : null);
		}
		catch
		{
			return null;
		}
	}

	private void TryExpandServerInventorySlots()
	{
		try
		{
			bool flag = false;
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			for (int i = 0; i < assemblies.Length; i++)
			{
				Type type = assemblies[i].GetType("Mirror.NetworkServer");
				if (!(type == null))
				{
					PropertyInfo property = type.GetProperty("active", BindingFlags.Static | BindingFlags.Public);
					if (property != null)
					{
						flag = (bool)property.GetValue(null);
					}
					break;
				}
			}
			if (!flag)
			{
				return;
			}
			Type type2 = null;
			Type type3 = null;
			assemblies = AppDomain.CurrentDomain.GetAssemblies();
			foreach (Assembly assembly in assemblies)
			{
				if (type2 == null)
				{
					type2 = assembly.GetType("PlayerInventory");
				}
				if (type3 == null)
				{
					type3 = assembly.GetType("InventorySlot");
				}
				if (type2 != null && type3 != null)
				{
					break;
				}
			}
			if (type2 == null || type3 == null)
			{
				return;
			}
			object obj = Activator.CreateInstance(type3);
			Array obj2 = (expandedSlotsAllPlayers ? ((Array)Object.FindObjectsOfType(type2)) : ((Array)new Object[1] { (Object)GetLocalPlayerInventoryComponent(type2) }));
			int num = 0;
			Object[] array = (Object[])obj2;
			foreach (Object obj3 in array)
			{
				Component val = (Component)(object)((obj3 is Component) ? obj3 : null);
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				FieldInfo field = ((object)val).GetType().GetField("slots", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (field == null)
				{
					continue;
				}
				object value = field.GetValue(val);
				if (value == null)
				{
					continue;
				}
				PropertyInfo property2 = value.GetType().GetProperty("Count");
				if (property2 == null)
				{
					continue;
				}
				int num2 = (int)property2.GetValue(value);
				if (num2 >= 7)
				{
					continue;
				}
				MethodInfo method = value.GetType().GetMethod("Add");
				if (!(method == null))
				{
					int num3 = 7 - num2;
					for (int j = 0; j < num3; j++)
					{
						method.Invoke(value, new object[1] { obj });
					}
					num++;
				}
			}
			BirdieLog.Msg("[Birdie] ExpandedSlots: expanded " + num + " player inventories to " + 7 + " slots");
		}
		catch (Exception ex)
		{
			BirdieLog.Warning("[Birdie] ExpandedSlots server slots error: " + ex.Message);
		}
	}

	private void RestoreExpandedSlots()
	{
		//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			if (cachedMaxItemsBackingField != null && cachedExpandedPlayerInvSettings != null)
			{
				cachedMaxItemsBackingField.SetValue(cachedExpandedPlayerInvSettings, savedOriginalMaxItems);
			}
			if (cachedHotkeyUisField != null && cachedExpandedHotkeysInstance != null && savedOriginalHotkeyUisArray != null)
			{
				cachedHotkeyUisField.SetValue(cachedExpandedHotkeysInstance, savedOriginalHotkeyUisArray);
			}
			savedOriginalHotkeyUisArray = null;
			foreach (GameObject spawnedExtraHotkeyUiObject in spawnedExtraHotkeyUiObjects)
			{
				if ((Object)(object)spawnedExtraHotkeyUiObject != (Object)null)
				{
					Object.Destroy((Object)(object)spawnedExtraHotkeyUiObject);
				}
			}
			spawnedExtraHotkeyUiObjects.Clear();
			try
			{
				if ((Object)(object)savedSlotParentTransform != (Object)null)
				{
					RectTransform component = ((Component)savedSlotParentTransform).GetComponent<RectTransform>();
					if ((Object)(object)component != (Object)null)
					{
						component.sizeDelta = savedSlotParentSizeDelta;
					}
					Mask component2 = ((Component)savedSlotParentTransform).GetComponent<Mask>();
					if ((Object)(object)component2 != (Object)null)
					{
						((Behaviour)component2).enabled = savedSlotParentMaskEnabled;
					}
					RectMask2D component3 = ((Component)savedSlotParentTransform).GetComponent<RectMask2D>();
					if ((Object)(object)component3 != (Object)null)
					{
						((Behaviour)component3).enabled = true;
					}
					savedSlotParentTransform = null;
				}
			}
			catch
			{
			}
			BirdieLog.Msg("[Birdie] ExpandedSlots: restored to " + savedOriginalMaxItems + " slots");
		}
		catch (Exception ex)
		{
			BirdieLog.Warning("[Birdie] ExpandedSlots restore error: " + ex.Message);
		}
	}

	private void CreateImpactPreviewHud(Transform parent)
	{
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Expected O, but got Unknown
		//IL_0047: Unknown result type (might be due to invalid IL or missing references)
		//IL_005c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0071: Unknown result type (might be due to invalid IL or missing references)
		//IL_0086: Unknown result type (might be due to invalid IL or missing references)
		//IL_009a: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d8: Expected O, but got Unknown
		//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
		//IL_0101: Unknown result type (might be due to invalid IL or missing references)
		//IL_0116: Unknown result type (might be due to invalid IL or missing references)
		//IL_012a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0146: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)impactPreviewPanelObject != (Object)null))
		{
			impactPreviewPanelObject = new GameObject("BirdieImpactPreviewPanel");
			impactPreviewPanelObject.transform.SetParent(parent, false);
			RectTransform obj = impactPreviewPanelObject.AddComponent<RectTransform>();
			obj.anchorMin = new Vector2(1f, 1f);
			obj.anchorMax = new Vector2(1f, 1f);
			obj.pivot = new Vector2(1f, 1f);
			obj.offsetMin = new Vector2(-374f, -274f);
			obj.offsetMax = new Vector2(-14f, -54f);
			((Graphic)impactPreviewPanelObject.AddComponent<Image>()).color = new Color(0.03f, 0.05f, 0.07f, 0.92f);
			GameObject val = new GameObject("BirdieImpactPreviewViewport");
			val.transform.SetParent(impactPreviewPanelObject.transform, false);
			RectTransform obj2 = val.AddComponent<RectTransform>();
			obj2.anchorMin = Vector2.zero;
			obj2.anchorMax = Vector2.one;
			obj2.offsetMin = new Vector2(3f, 3f);
			obj2.offsetMax = new Vector2(-3f, -3f);
			impactPreviewRawImage = val.AddComponent<RawImage>();
			((Graphic)impactPreviewRawImage).color = Color.white;
			((Graphic)impactPreviewRawImage).raycastTarget = false;
			impactPreviewPanelObject.SetActive(false);
		}
	}

	private void EnsureImpactPreviewResources()
	{
		//IL_009c: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a6: Expected O, but got Unknown
		//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ef: Expected O, but got Unknown
		//IL_018f: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)impactPreviewTexture == (Object)null || ((Texture)impactPreviewTexture).width != impactPreviewTextureWidth || ((Texture)impactPreviewTexture).height != impactPreviewTextureHeight)
		{
			if ((Object)(object)impactPreviewTexture != (Object)null)
			{
				if ((Object)(object)impactPreviewCamera != (Object)null && (Object)(object)impactPreviewCamera.targetTexture == (Object)(object)impactPreviewTexture)
				{
					impactPreviewCamera.targetTexture = null;
				}
				impactPreviewTexture.Release();
				Object.Destroy((Object)(object)impactPreviewTexture);
			}
			impactPreviewTexture = new RenderTexture(impactPreviewTextureWidth, impactPreviewTextureHeight, 16);
			((Object)impactPreviewTexture).name = "BirdieImpactPreviewTexture";
			impactPreviewTexture.antiAliasing = 1;
			impactPreviewTexture.Create();
		}
		if ((Object)(object)impactPreviewCamera == (Object)null)
		{
			impactPreviewCameraObject = new GameObject("BirdieImpactPreviewCamera");
			Object.DontDestroyOnLoad((Object)(object)impactPreviewCameraObject);
			impactPreviewCamera = impactPreviewCameraObject.AddComponent<Camera>();
			((Behaviour)impactPreviewCamera).enabled = false;
			impactPreviewCamera.depth = -100f;
			impactPreviewCamera.targetTexture = impactPreviewTexture;
			impactPreviewCamera.fieldOfView = impactPreviewFieldOfView;
			impactPreviewCamera.nearClipPlane = 0.05f;
			impactPreviewCamera.farClipPlane = 500f;
			impactPreviewCamera.clearFlags = (CameraClearFlags)1;
			impactPreviewCamera.backgroundColor = new Color(0.09f, 0.11f, 0.14f, 1f);
			impactPreviewCamera.cullingMask = -1;
		}
		if ((Object)(object)impactPreviewRawImage != (Object)null && (Object)(object)impactPreviewRawImage.texture != (Object)(object)impactPreviewTexture)
		{
			impactPreviewRawImage.texture = (Texture)(object)impactPreviewTexture;
		}
	}

	private void UpdateImpactPreview()
	{
		//IL_00ee: 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)
		if ((Object)(object)impactPreviewPanelObject == (Object)null || (Object)(object)impactPreviewRawImage == (Object)null)
		{
			return;
		}
		if (!assistEnabled || !impactPreviewEnabled)
		{
			HideImpactPreview();
			return;
		}
		if (!TryGetCachedImpactPreviewFocus(out var focusPoint, out var approachDirection))
		{
			HideImpactPreview();
			return;
		}
		EnsureImpactPreviewResources();
		if ((Object)(object)impactPreviewCamera == (Object)null || (Object)(object)impactPreviewTexture == (Object)null)
		{
			HideImpactPreview();
			return;
		}
		float unscaledTime = Time.unscaledTime;
		bool flag = !impactPreviewPanelObject.activeSelf;
		float impactPreviewRenderInterval = GetImpactPreviewRenderInterval();
		if (!flag && impactPreviewRenderInterval > 0f && unscaledTime < nextImpactPreviewRenderTime)
		{
			return;
		}
		if ((Object)(object)cachedImpactPreviewReferenceCamera == (Object)null || !((Behaviour)cachedImpactPreviewReferenceCamera).isActiveAndEnabled || unscaledTime >= nextImpactPreviewReferenceCameraRefreshTime)
		{
			cachedImpactPreviewReferenceCamera = FindReferenceGameplayCamera();
			nextImpactPreviewReferenceCameraRefreshTime = unscaledTime + impactPreviewReferenceCameraRefreshInterval;
		}
		SyncImpactPreviewCameraSettings(cachedImpactPreviewReferenceCamera);
		PositionImpactPreviewCamera(focusPoint, approachDirection);
		try
		{
			impactPreviewCamera.Render();
			nextImpactPreviewRenderTime = ((impactPreviewRenderInterval > 0f) ? (unscaledTime + impactPreviewRenderInterval) : 0f);
			if (flag)
			{
				impactPreviewPanelObject.SetActive(true);
			}
		}
		catch
		{
			HideImpactPreview();
		}
	}

	private void HideImpactPreview()
	{
		if ((Object)(object)impactPreviewPanelObject != (Object)null && impactPreviewPanelObject.activeSelf)
		{
			impactPreviewPanelObject.SetActive(false);
		}
		nextImpactPreviewRenderTime = 0f;
	}

	private float GetImpactPreviewRenderInterval()
	{
		float num = ((impactPreviewTargetFps > 0.01f) ? impactPreviewTargetFps : impactPreviewAutoTargetFps);
		if (!(num > 0.01f))
		{
			return 0f;
		}
		return 1f / num;
	}

	private bool TryGetCachedImpactPreviewFocus(out Vector3 focusPoint, out Vector3 approachDirection)
	{
		//IL_000a: Unknown result type (might be due to invalid IL or missing references)
		//IL_000f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0045: Unknown result type (might be due to invalid IL or missing references)
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0051: Unknown result type (might be due to invalid IL or missing references)
		//IL_0056: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_0038: Unknown result type (might be due to invalid IL or missing references)
		//IL_003d: Unknown result type (might be due to invalid IL or missing references)
		if (predictedImpactPreviewValid)
		{
			focusPoint = predictedImpactPreviewPoint;
			approachDirection = predictedImpactPreviewApproachDirection;
			return true;
		}
		if (frozenImpactPreviewValid)
		{
			focusPoint = frozenImpactPreviewPoint;
			approachDirection = frozenImpactPreviewApproachDirection;
			return true;
		}
		focusPoint = Vector3.zero;
		approachDirection = GetFallbackPreviewDirection();
		return false;
	}

	private void ResetImpactPreviewCache(bool resetPredicted, bool resetFrozen)
	{
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0030: Unknown result type (might be due to invalid IL or missing references)
		//IL_0036: Unknown result type (might be due to invalid IL or missing references)
		//IL_003b: Unknown result type (might be due to invalid IL or missing references)
		if (resetPredicted)
		{
			predictedImpactPreviewValid = false;
			predictedImpactPreviewPoint = Vector3.zero;
			predictedImpactPreviewApproachDirection = Vector3.forward;
		}
		if (resetFrozen)
		{
			frozenImpactPreviewValid = false;
			frozenImpactPreviewPoint = Vector3.zero;
			frozenImpactPreviewApproachDirection = Vector3.forward;
		}
	}

	private void StoreImpactPreviewData(List<Vector3> sourcePoints, bool hasImpactPoint, Vector3 impactPoint, Vector3 approachDirection)
	{
		//IL_009b: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
		//IL_003b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0040: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
		//IL_0054: Unknown result type (might be due to invalid IL or missing references)
		//IL_0062: Unknown result type (might be due to invalid IL or missing references)
		//IL_0067: Unknown result type (might be due to invalid IL or missing references)
		//IL_006c: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
		//IL_007d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0082: Unknown result type (might be due to invalid IL or missing references)
		bool flag = sourcePoints == predictedPathPoints;
		bool flag2 = sourcePoints == frozenPredictedPathPoints;
		if (!flag && !flag2)
		{
			return;
		}
		if (!hasImpactPoint)
		{
			if (sourcePoints == null || sourcePoints.Count == 0)
			{
				ResetImpactPreviewCache(flag, flag2);
				return;
			}
			impactPoint = sourcePoints[sourcePoints.Count - 1];
			if (sourcePoints.Count >= 2)
			{
				Vector3 val = sourcePoints[sourcePoints.Count - 1] - sourcePoints[sourcePoints.Count - 2];
				if (((Vector3)(ref val)).sqrMagnitude >= 0.0001f)
				{
					approachDirection = ((Vector3)(ref val)).normalized;
				}
			}
			ProjectImpactPreviewPointToSurface(ref impactPoint);
		}
		if (((Vector3)(ref approachDirection)).sqrMagnitude < 0.0001f)
		{
			approachDirection = GetFallbackPreviewDirection();
		}
		else
		{
			((Vector3)(ref approachDirection)).Normalize();
		}
		if (flag)
		{
			predictedImpactPreviewValid = true;
			predictedImpactPreviewPoint = impactPoint;
			predictedImpactPreviewApproachDirection = approachDirection;
		}
		if (flag2)
		{
			frozenImpactPreviewValid = true;
			frozenImpactPreviewPoint = impactPoint;
			frozenImpactPreviewApproachDirection = approachDirection;
		}
	}

	private bool TryFindWorldImpactAlongSegment(Vector3 startPoint, Vector3 endPoint, out RaycastHit resolvedHit)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_0009: Unknown result type (might be due to invalid IL or missing references)
		//IL_000e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_004f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0054: Unknown result type (might be due to invalid IL or missing references)
		//IL_007a: Unknown result type (might be due to invalid IL or missing references)
		//IL_007c: Unknown result type (might be due to invalid IL or missing references)
		resolvedHit = default(RaycastHit);
		Vector3 val = endPoint - startPoint;
		float magnitude = ((Vector3)(ref val)).magnitude;
		if (magnitude <= 0.0001f)
		{
			return false;
		}
		Vector3 val2 = val / magnitude;
		int num = Physics.RaycastNonAlloc(startPoint, val2, impactPreviewRaycastHits, magnitude, -5, (QueryTriggerInteraction)1);
		float num2 = float.MaxValue;
		for (int i = 0; i < num; i++)
		{
			RaycastHit val3 = impactPreviewRaycastHits[i];
			if (!ShouldIgnoreImpactPreviewCollider(((RaycastHit)(ref val3)).collider) && ((RaycastHit)(ref val3)).distance < num2)
			{
				num2 = ((RaycastHit)(ref val3)).distance;
				resolvedHit = val3;
			}
		}
		return num2 < float.MaxValue;
	}

	private void ProjectImpactPreviewPointToSurface(ref Vector3 point)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0045: Unknown result type (might be due to invalid IL or missing references)
		//IL_0058: Unknown result type (might be due to invalid IL or missing references)
		//IL_005d: 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_0080: Unknown result type (might be due to invalid IL or missing references)
		//IL_0082: Unknown result type (might be due to invalid IL or missing references)
		int num = Physics.RaycastNonAlloc(point + Vector3.up * impactPreviewProbeHeight, Vector3.down, impactPreviewGroundProbeHits, impactPreviewProbeHeight * 2f, -5, (QueryTriggerInteraction)1);
		float num2 = float.MaxValue;
		bool flag = false;
		RaycastHit val = default(RaycastHit);
		for (int i = 0; i < num; i++)
		{
			RaycastHit val2 = impactPreviewGroundProbeHits[i];
			if (!ShouldIgnoreImpactPreviewCollider(((RaycastHit)(ref val2)).collider) && ((RaycastHit)(ref val2)).distance < num2)
			{
				num2 = ((RaycastHit)(ref val2)).distance;
				val = val2;
				flag = true;
			}
		}
		if (flag)
		{
			point = ((RaycastHit)(ref val)).point;
		}
	}

	private bool ShouldIgnoreImpactPreviewCollider(Collider collider)
	{
		if ((Object)(object)collider == (Object)null || collider.isTrigger)
		{
			return true;
		}
		Transform transform = ((Component)collider).transform;
		if ((Object)(object)golfBall != (Object)null && transform.IsChildOf(golfBall.transform))
		{
			return true;
		}
		if ((Object)(object)playerGolfer != (Object)null && transform.IsChildOf(playerGolfer.transform))
		{
			return true;
		}
		if ((Object)(object)playerMovement != (Object)null && transform.IsChildOf(playerMovement.transform))
		{
			return true;
		}
		if ((Object)(object)impactPreviewCameraObject != (Object)null)
		{
			return transform.IsChildOf(impactPreviewCameraObject.transform);
		}
		return false;
	}

	private Vector3 GetFallbackPreviewDirection()
	{
		//IL_000f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_009f: 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)
		//IL_007c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_0036: Unknown result type (might be due to invalid IL or missing references)
		//IL_003b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0099: Unknown result type (might be due to invalid IL or missing references)
		//IL_0058: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)golfBall != (Object)null && currentAimTargetPosition != Vector3.zero)
		{
			Vector3 val = currentAimTargetPosition - golfBall.transform.position;
			val.y = 0f;
			if (((Vector3)(ref val)).sqrMagnitude >= 0.0001f)
			{
				return ((Vector3)(ref val)).normalized;
			}
		}
		if ((Object)(object)playerGolfer != (Object)null)
		{
			Vector3 forward = playerGolfer.transform.forward;
			forward.y = 0f;
			if (((Vector3)(ref forward)).sqrMagnitude >= 0.0001f)
			{
				return ((Vector3)(ref forward)).normalized;
			}
		}
		return Vector3.forward;
	}

	private Camera FindReferenceGameplayCamera()
	{
		Camera main = Camera.main;
		if ((Object)(object)main != (Object)null && (Object)(object)main != (Object)(object)impactPreviewCamera && ((Behaviour)main).isActiveAndEnabled && (Object)(object)main.targetTexture == (Object)null)
		{
			return main;
		}
		return null;
	}

	private void SyncImpactPreviewCameraSettings(Camera referenceCamera)
	{
		//IL_0104: Unknown result type (might be due to invalid IL or missing references)
		//IL_0022: Unknown result type (might be due to invalid IL or missing references)
		//IL_0033: Unknown result type (might be due to invalid IL or missing references)
		//IL_0088: Unknown result type (might be due to invalid IL or missing references)
		//IL_0099: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)impactPreviewCamera == (Object)null))
		{
			if ((Object)(object)referenceCamera != (Object)null)
			{
				impactPreviewCamera.clearFlags = referenceCamera.clearFlags;
				impactPreviewCamera.backgroundColor = referenceCamera.backgroundColor;
				impactPreviewCamera.cullingMask = referenceCamera.cullingMask;
				impactPreviewCamera.allowHDR = referenceCamera.allowHDR;
				impactPreviewCamera.allowMSAA = referenceCamera.allowMSAA;
				impactPreviewCamera.useOcclusionCulling = referenceCamera.useOcclusionCulling;
				impactPreviewCamera.depthTextureMode = referenceCamera.depthTextureMode;
				impactPreviewCamera.renderingPath = referenceCamera.renderingPath;
				impactPreviewCamera.nearClipPlane = Mathf.Max(0.03f, referenceCamera.nearClipPlane);
				impactPreviewCamera.farClipPlane = Mathf.Max(200f, referenceCamera.farClipPlane);
			}
			else
			{
				impactPreviewCamera.clearFlags = (CameraClearFlags)1;
				impactPreviewCamera.backgroundColor = new Color(0.09f, 0.11f, 0.14f, 1f);
				impactPreviewCamera.cullingMask = -1;
				impactPreviewCamera.allowHDR = true;
				impactPreviewCamera.allowMSAA = true;
				impactPreviewCamera.useOcclusionCulling = true;
				impactPreviewCamera.depthTextureMode = (DepthTextureMode)0;
				impactPreviewCamera.renderingPath = (RenderingPath)(-1);
				impactPreviewCamera.nearClipPlane = 0.05f;
				impactPreviewCamera.farClipPlane = 500f;
			}
			impactPreviewCamera.fieldOfView = impactPreviewFieldOfView;
			impactPreviewCamera.targetTexture = impactPreviewTexture;
		}
	}

	private void PositionImpactPreviewCamera(Vector3 focusPoint, Vector3 approachDirection)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0054: Unknown result type (might be due to invalid IL or missing references)
		//IL_0059: Unknown result type (might be due to invalid IL or missing references)
		//IL_006c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0071: Unknown result type (might be due to invalid IL or missing references)
		//IL_0076: 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)
		//IL_007c: Unknown result type (might be due to invalid IL or missing references)
		//IL_00be: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00da: Unknown result type (might be due to invalid IL or missing references)
		//IL_00df: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e4: 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_00f4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
		//IL_010b: Unknown result type (might be due to invalid IL or missing references)
		//IL_011d: Unknown result type (might be due to invalid IL or missing references)
		//IL_011f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0121: Unknown result type (might be due to invalid IL or missing references)
		//IL_0126: Unknown result type (might be due to invalid IL or missing references)
		//IL_012a: Unknown result type (might be due to invalid IL or missing references)
		//IL_012f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0134: Unknown result type (might be due to invalid IL or missing references)
		Vector3 val = default(Vector3);
		((Vector3)(ref val))..ctor(approachDirection.x, 0f, approachDirection.z);
		if (((Vector3)(ref val)).sqrMagnitude < 0.0001f)
		{
			val = GetFallbackPreviewDirection();
		}
		((Vector3)(ref val)).Normalize();
		float num = (((Object)(object)golfBall != (Object)null) ? Vector3.Distance(golfBall.transform.position, focusPoint) : 24f);
		val = Quaternion.AngleAxis(Time.unscaledTime * impactPreviewOrbitDegreesPerSecond, Vector3.up) * val;
		float num2 = Mathf.Clamp(num * 0.24f + 7.5f, impactPreviewCameraMinDistance, impactPreviewCameraMaxDistance);
		float num3 = Mathf.Lerp(impactPreviewCameraMinHeight, impactPreviewCameraMaxHeight, Mathf.InverseLerp(0f, 80f, num));
		Vector3 val2 = focusPoint + Vector3.up * impactPreviewLookHeightOffset;
		Vector3 desiredPosition = val2 - val * num2 + Vector3.up * num3;
		ClampImpactPreviewPositionAboveGround(val2, ref desiredPosition);
		((Component)impactPreviewCamera).transform.position = desiredPosition;
		Transform transform = ((Component)impactPreviewCamera).transform;
		Vector3 val3 = val2 - desiredPosition;
		transform.rotation = Quaternion.LookRotation(((Vector3)(ref val3)).normalized, Vector3.up);
	}

	private void ClampImpactPreviewPositionAboveGround(Vector3 lookPoint, ref Vector3 desiredPosition)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0039: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_007b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0080: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
		float num = lookPoint.y + impactPreviewMinVerticalLookOffset;
		desiredPosition.y = Mathf.Max(desiredPosition.y, num);
		int num2 = Physics.RaycastNonAlloc(new Vector3(desiredPosition.x, desiredPosition.y + impactPreviewProbeHeight, desiredPosition.z), Vector3.down, impactPreviewGroundProbeHits, impactPreviewProbeHeight * 2f, -5, (QueryTriggerInteraction)1);
		float num3 = float.MaxValue;
		bool flag = false;
		RaycastHit val = default(RaycastHit);
		for (int i = 0; i < num2; i++)
		{
			RaycastHit val2 = impactPreviewGroundProbeHits[i];
			if (!ShouldIgnoreImpactPreviewCollider(((RaycastHit)(ref val2)).collider) && ((RaycastHit)(ref val2)).distance < num3)
			{
				num3 = ((RaycastHit)(ref val2)).distance;
				val = val2;
				flag = true;
			}
		}
		if (flag)
		{
			desiredPosition.y = Mathf.Max(new float[3]
			{
				desiredPosition.y,
				((RaycastHit)(ref val)).point.y + impactPreviewGroundClearance,
				num
			});
		}
	}

	private void InitializeItemSpawnerReflection()
	{
		if (itemSpawnerReflectionInitialized)
		{
			return;
		}
		itemSpawnerReflectionInitialized = true;
		try
		{
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			foreach (Assembly assembly in assemblies)
			{
				if (cachedNetworkServerActiveProperty == null)
				{
					Type type = assembly.GetType("Mirror.NetworkServer");
					if (type != null)
					{
						cachedNetworkServerActiveProperty = type.GetProperty("active", BindingFlags.Static | BindingFlags.Public);
					}
				}
				if (cachedLocalPlayerInventoryProperty == null || cachedAllItemsProperty == null)
				{
					Type type2 = assembly.GetType("GameManager");
					if (type2 != null)
					{
						if (cachedLocalPlayerInventoryProperty == null)
						{
							cachedLocalPlayerInventoryProperty = type2.GetProperty("LocalPlayerInventory", BindingFlags.Static | BindingFlags.Public);
						}
						if (cachedAllItemsProperty == null)
						{
							cachedAllItemsProperty = type2.GetProperty("AllItems", BindingFlags.Static | BindingFlags.Public);
						}
					}
				}
				if (cachedItemTypeEnumType == null)
				{
					cachedItemTypeEnumType = assembly.GetType("ItemType");
				}
				if (cachedTryGetItemDataMethod == null)
				{
					Type type3 = assembly.GetType("ItemCollection");
					if (type3 != null)
					{
						cachedTryGetItemDataMethod = type3.GetMethod("TryGetItemData", BindingFlags.Instance | BindingFlags.Public);
					}
				}
				if (cachedItemDataMaxUsesProperty == null)
				{
					Type type4 = assembly.GetType("ItemData");
					if (type4 != null)
					{
						cachedItemDataMaxUsesProperty = type4.GetProperty("MaxUses", BindingFlags.Instance | BindingFlags.Public);
					}
				}
				if (cachedServerTryAddItemMethod == null)
				{
					Type type5 = assembly.GetType("PlayerInventory");
					if (type5 != null)
					{
						cachedServerTryAddItemMethod = type5.GetMethod("ServerTryAddItem", BindingFlags.Instance | BindingFlags.Public);
					}
				}
			}
		}
		catch
		{
		}
	}

	private void InitializeDispenserReflection()
	{
		if (dispenserReflectionInitialized)
		{
			return;
		}
		dispenserReflectionInitialized = true;
		try
		{
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			foreach (Assembly assembly in assemblies)
			{
				if (cachedItemDispenserType == null)
				{
					Type type = assembly.GetType("ItemDispenser");
					if (type != null)
					{
						cachedItemDispenserType = type;
						cachedItemDispenserItemTypeField = type.GetField("itemType", BindingFlags.Instance | BindingFlags.NonPublic);
						cachedItemDispenserIsEnabledProperty = type.GetProperty("IsInteractionEnabled", BindingFlags.Instance | BindingFlags.Public);
						cachedItemDispenserCmdDispenseMethod = type.GetMethod("CmdDispenseItemFor", BindingFlags.Instance | BindingFlags.Public);
					}
				}
				if (cachedPhysicalItemType == null)
				{
					Type type2 = assembly.GetType("PhysicalItem");
					if (type2 != null)
					{
						cachedPhysicalItemType = type2;
						cachedPhysicalItemItemTypeField = type2.GetField("itemType", BindingFlags.Instance | BindingFlags.NonPublic);
						cachedCmdGiveToPlayerMethod = type2.GetMethod("CmdGiveToPlayer", BindingFlags.Instance | BindingFlags.Public);
					}
				}
				if (cachedItemDispenserType != null && cachedPhysicalItemType != null)
				{
					break;
				}
			}
		}
		catch
		{
		}
	}

	private Component FindMatchingDispenser(int itemTypeInt)
	{
		if (cachedItemDispenserType == null || cachedItemDispenserItemTypeField == null)
		{
			return null;
		}
		try
		{
			Object[] array = Object.FindObjectsOfType(cachedItemDispenserType);
			foreach (Object obj in array)
			{
				Component val = (Component)(object)((obj is Component) ? obj : null);
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				object value = cachedItemDispenserItemTypeField.GetValue(val);
				if (value == null || (int)value != itemTypeInt)
				{
					continue;
				}
				if (cachedItemDispenserIsEnabledProperty != null)
				{
					object value2 = cachedItemDispenserIsEnabledProperty.GetValue(val, null);
					if (value2 != null && !(bool)value2)
					{
						continue;
					}
				}
				return val;
			}
		}
		catch
		{
		}
		return null;
	}

	private Component FindPhysicalItemOfType(int itemTypeInt)
	{
		if (cachedPhysicalItemType == null || cachedPhysicalItemItemTypeField == null)
		{
			return null;
		}
		try
		{
			Object[] array = Object.FindObjectsOfType(cachedPhysicalItemType);
			foreach (Object obj in array)
			{
				Component val = (Component)(object)((obj is Component) ? obj : null);
				if (!((Object)(object)val == (Object)null))
				{
					object value = cachedPhysicalItemItemTypeField.GetValue(val);
					if (value != null && (int)value == itemTypeInt)
					{
						return val;
					}
				}
			}
		}
		catch
		{
		}
		return null;
	}

	internal void PollDispenserPickup()
	{
		if (!dispenserPickupPending)
		{
			return;
		}
		if (Time.time > dispenserPickupDeadline)
		{
			BirdieLog.Warning("[Birdie] Item spawner (dispenser): timed out waiting for spawned item.");
			dispenserPickupPending = false;
			dispenserPickupLocalInventory = null;
			return;
		}
		Component val = FindPhysicalItemOfType(dispenserPickupItemTypeInt);
		if ((Object)(object)val == (Object)null)
		{
			return;
		}
		dispenserPickupPending = false;
		if (cachedCmdGiveToPlayerMethod == null || (Object)(object)dispenserPickupLocalInventory == (Object)null)
		{
			BirdieLog.Warning("[Birdie] Item spawner (dispenser): CmdGiveToPlayer reflection not ready.");
			dispenserPickupLocalInventory = null;
			return;
		}
		try
		{
			cachedCmdGiveToPlayerMethod.Invoke(val, new object[2] { dispenserPickupLocalInventory, null });
		}
		catch (Exception ex)
		{
			BirdieLog.Warning("[Birdie] Item spawner (dispenser pickup): " + ex.Message);
		}
		dispenserPickupLocalInventory = null;
	}

	private void InitializeCrateReflection()
	{
		if (crateReflectionInitialized)
		{
			return;
		}
		crateReflectionInitialized = true;
		try
		{
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			foreach (Assembly assembly in assemblies)
			{
				if (cachedItemSpawnerType == null)
				{
					Type type = assembly.GetType("ItemSpawner");
					if (type != null)
					{
						cachedItemSpawnerType = type;
						cachedItemSpawnerSettingsField = type.GetField("settings", BindingFlags.Instance | BindingFlags.NonPublic);
						cachedItemSpawnerNetHasItemBoxProp = type.GetProperty("NetworkhasItemBox", BindingFlags.Instance | BindingFlags.Public);
					}
				}
				if (cachedItemSpawnerSettingsType == null)
				{
					Type type2 = assembly.GetType("ItemSpawnerSettings");
					if (type2 != null)
					{
						cachedItemSpawnerSettingsType = type2;
						cachedGetRandomItemForMethod = type2.GetMethod("GetRandomItemFor", BindingFlags.Instance | BindingFlags.Public);
					}
				}
				if (cachedInventoryPlayerInfoProp == null)
				{
					Type type3 = assembly.GetType("PlayerInventory");
					if (type3 != null)
					{
						cachedInventoryPlayerInfoProp = type3.GetProperty("PlayerInfo", BindingFlags.Instance | BindingFlags.Public);
					}
				}
				if (cachedItemSpawnerType != null && cachedItemSpawnerSettingsType != null && cachedInventoryPlayerInfoProp != null)
				{
					break;
				}
			}
		}
		catch
		{
		}
	}

	internal void TryCollectFromCrate()
	{
		if (!itemSpawnerReflectionInitialized)
		{
			InitializeItemSpawnerReflection();
		}
		if (!crateReflectionInitialized)
		{
			InitializeCrateReflection();
		}
		if (!(cachedLocalPlayerInventoryProperty == null))
		{
			object? value = cachedLocalPlayerInventoryProperty.GetValue(null, null);
			Component val = (Component)((value is Component) ? value : null);
			if ((Object)(object)val == (Object)null)
			{
				BirdieLog.Warning("[Birdie] Crate: local player inventory not found.");
			}
			else if (IsNetworkServerActive())
			{
				CollectFromCrateAsHost(val);
			}
			else
			{
				CollectFromCrateAsClient(val);
			}
		}
	}

	private void CollectFromCrateAsHost(Component localInventory)
	{
		//IL_004d: Unknown result type (might be due to invalid IL or missing references)
		//IL_003b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_009f: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
		if (cachedItemSpawnerType == null)
		{
			BirdieLog.Warning("[Birdie] Crate: ItemSpawner type not found.");
			return;
		}
		Object[] array = Object.FindObjectsOfType(cachedItemSpawnerType);
		Component val = null;
		float num = float.MaxValue;
		Vector3 val2 = (((Object)(object)playerMovement != (Object)null) ? playerMovement.transform.position : Vector3.zero);
		foreach (Object obj in array)
		{
			Component val3 = (Component)(object)((obj is Component) ? obj : null);
			if ((Object)(object)val3 == (Object)null)
			{
				continue;
			}
			if (cachedItemSpawnerNetHasItemBoxProp != null)
			{
				object value = cachedItemSpawnerNetHasItemBoxProp.GetValue(val3, null);
				if (value != null && !(bool)value)
				{
					continue;
				}
			}
			float num2 = Vector3.Distance(val3.transform.position, val2);
			if (num2 < num)
			{
				num = num2;
				val = val3;
			}
		}
		if ((Object)(object)val == (Object)null)
		{
			BirdieLog.Warning("[Birdie] Crate: no item crate with an available box found.");
			return;
		}
		int num3 = GetCrateRandomItemType(val, localInventory);
		if (num3 <= 0)
		{
			num3 = SpawnableItemTypeInts[Random.Range(0, SpawnableItemTypeInts.Length)];
		}
		if (cachedServerTryAddItemMethod == null || cachedItemTypeEnumType == null)
		{
			BirdieLog.Warning("[Birdie] Crate: ServerTryAddItem reflection not ready.");
			return;
		}
		object obj2 = Enum.ToObject(cachedItemTypeEnumType, num3);
		int num4 = GetItemMaxUses(num3);
		if (num4 <= 0)
		{
			num4 = 1;
		}
		try
		{
			if (!(bool)cachedServerTryAddItemMethod.Invoke(localInventory, new object[2] { obj2, num4 }))
			{
				BirdieLog.Warning("[Birdie] Crate: inventory full.");
				return;
			}
		}
		catch (Exception ex)
		{
			BirdieLog.Warning("[Birdie] Crate (host grant): " + ex.Message);
			return;
		}
		if (!(cachedItemSpawnerNetHasItemBoxProp != null))
		{
			return;
		}
		try
		{
			cachedItemSpawnerNetHasItemBoxProp.SetValue(val, false);
		}
		catch
		{
		}
	}

	private int GetCrateRandomItemType(Component spawner, Component localInventory)
	{
		try
		{
			if (cachedItemSpawnerSettingsField == null || cachedGetRandomItemForMethod == null || cachedInventoryPlayerInfoProp == null)
			{
				return 0;
			}
			object value = cachedItemSpawnerSettingsField.GetValue(spawner);
			if (value == null)
			{
				return 0;
			}
			object value2 = cachedInventoryPlayerInfoProp.GetValue(localInventory, null);
			if (value2 == null)
			{
				return 0;
			}
			object obj = cachedGetRandomItemForMethod.Invoke(value, new object[1] { value2 });
			if (obj == null)
			{
				return 0;
			}
			return Convert.ToInt32(obj);
		}
		catch
		{
			return 0;
		}
	}

	private void CollectFromCrateAsClient(Component localInventory)
	{
		//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bd: 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_0146: Unknown result type (might be due to invalid IL or missing references)
		//IL_015c: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
		//IL_0101: Unknown result type (might be due to invalid IL or missing references)
		if (BirdieGrantBridge.IsReady())
		{
			int itemTypeInt = SpawnableItemTypeInts[Random.Range(0, SpawnableItemTypeInts.Length)];
			BirdieGrantBridge.RequestGrant(localInventory, itemTypeInt);
			return;
		}
		if (!pendingCrateTeleport)
		{
			pendingCrateTeleport = true;
			pendingCrateTeleportExpiry = Time.time + 3f;
			MarkHudDirty();
			return;
		}
		pendingCrateTeleport = false;
		MarkHudDirty();
		if (cachedItemSpawnerType == null || cachedItemSpawnerNetHasItemBoxProp == null)
		{
			BirdieLog.Warning("[Birdie] Crate teleport: ItemSpawner reflection not ready.");
			return;
		}
		if ((Object)(object)playerMovement == (Object)null)
		{
			BirdieLog.Warning("[Birdie] Crate teleport: player not found.");
			return;
		}
		Object[] array = Object.FindObjectsOfType(cachedItemSpawnerType);
		Component val = null;
		float num = float.MaxValue;
		Vector3 position = playerMovement.transform.position;
		foreach (Object obj in array)
		{
			Component val2 = (Component)(object)((obj is Component) ? obj : null);
			if ((Object)(object)val2 == (Object)null)
			{
				continue;
			}
			object value = cachedItemSpawnerNetHasItemBoxProp.GetValue(val2, null);
			if (value == null || (bool)value)
			{
				float num2 = Vector3.Distance(val2.transform.position, position);
				if (num2 < num)
				{
					num = num2;
					val = val2;
				}
			}
		}
		if ((Object)(object)val == (Object)null)
		{
			BirdieLog.Warning("[Birdie] Crate teleport: no active crates in scene.");
			return;
		}
		crateReturnPosition = playerMovement.transform.position;
		playerMovement.transform.position = val.transform.position;
		crateReturnPending = true;
	}

	internal void PollCrateReturn()
	{
		//IL_004b: Unknown result type (might be due to invalid IL or missing references)
		if (pendingCrateTeleport && Time.time > pendingCrateTeleportExpiry)
		{
			pendingCrateTeleport = false;
			MarkHudDirty();
		}
		if (crateReturnPending)
		{
			crateReturnPending = false;
			if ((Object)(object)playerMovement != (Object)null)
			{
				playerMovement.transform.position = crateReturnPosition;
			}
		}
	}

	private void SpawnItemClientSide(int itemTypeInt)
	{
		if (!itemSpawnerReflectionInitialized)
		{
			InitializeItemSpawnerReflection();
		}
		if (IsNetworkServerActive())
		{
			SpawnItemAsHost(itemTypeInt);
		}
		else
		{
			SpawnItemAsClient(itemTypeInt);
		}
	}

	private void SpawnItemAsHost(int itemTypeInt)
	{
		try
		{
			if (cachedLocalPlayerInventoryProperty == null || cachedServerTryAddItemMethod == null || cachedItemTypeEnumType == null)
			{
				BirdieLog.Warning("[Birdie] Item spawner: host reflection cache incomplete.");
				return;
			}
			object? value = cachedLocalPlayerInventoryProperty.GetValue(null, null);
			Component val = (Component)((value is Component) ? value : null);
			if ((Object)(object)val == (Object)null)
			{
				BirdieLog.Warning("[Birdie] Item spawner: local player inventory not found.");
				return;
			}
			object obj = Enum.ToObject(cachedItemTypeEnumType, itemTypeInt);
			int num = GetItemMaxUses(itemTypeInt);
			if (num <= 0)
			{
				num = 1;
			}
			if (!(bool)cachedServerTryAddItemMethod.Invoke(val, new object[2] { obj, num }))
			{
				BirdieLog.Warning("[Birdie] Item spawner: inventory full or item invalid.");
			}
		}
		catch (Exception ex)
		{
			BirdieLog.Warning("[Birdie] Item spawner (host): " + ex.Message);
		}
	}

	private void SpawnItemAsClient(int itemTypeInt)
	{
		try
		{
			if (cachedLocalPlayerInventoryProperty == null)
			{
				BirdieLog.Warning("[Birdie] Item spawner: LocalPlayerInventory reflection not ready.");
				return;
			}
			object? value = cachedLocalPlayerInventoryProperty.GetValue(null, null);
			Component val = (Component)((value is Component) ? value : null);
			if ((Object)(object)val == (Object)null)
			{
				BirdieLog.Warning("[Birdie] Item spawner: local player inventory not found.");
				return;
			}
			if (itemTypeInt == 1)
			{
				if (!dispenserReflectionInitialized)
				{
					InitializeDispenserReflection();
				}
				if (cachedItemDispenserCmdDispenseMethod != null)
				{
					Component val2 = FindMatchingDispenser(1);
					if ((Object)(object)val2 != (Object)null)
					{
						try
						{
							cachedItemDispenserCmdDispenseMethod.Invoke(val2, null);
							dispenserPickupPending = true;
							dispenserPickupItemTypeInt = 1;
							dispenserPickupLocalInventory = val;
							dispenserPickupDeadline = Time.time + 2.5f;
							return;
						}
						catch (Exception ex)
						{
							BirdieLog.Warning("[Birdie] Item spawner (dispenser): " + ex.Message);
						}
					}
				}
			}
			if (BirdieGrantBridge.IsReady())
			{
				BirdieGrantBridge.RequestGrant(val, itemTypeInt);
			}
			else
			{
				BirdieLog.Warning("[Birdie] Item spawner: no client grant path available — host only.");
			}
		}
		catch (Exception ex2)
		{
			BirdieLog.Warning("[Birdie] Item spawner (client): " + ex2.Message);
		}
	}

	private bool IsNetworkServerActive()
	{
		if (!cachedNetworkServerPropertyInit)
		{
			cachedNetworkServerPropertyInit = true;
			if (cachedNetworkServerActiveProperty == null)
			{
				Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
				for (int i = 0; i < assemblies.Length; i++)
				{
					Type type = assemblies[i].GetType("Mirror.NetworkServer");
					if (type != null)
					{
						cachedNetworkServerActiveProperty = type.GetProperty("active", BindingFlags.Static | BindingFlags.Public);
						break;
					}
				}
			}
		}
		if (cachedNetworkServerActiveProperty == null)
		{
			return false;
		}
		try
		{
			return (bool)cachedNetworkServerActiveProperty.GetValue(null, null);
		}
		catch
		{
			return false;
		}
	}

	private int GetItemMaxUses(int itemTypeInt)
	{
		try
		{
			if (cachedAllItemsProperty == null || cachedTryGetItemDataMethod == null || cachedItemDataMaxUsesProperty == null || cachedItemTypeEnumType == null)
			{
				return 1;
			}
			object value = cachedAllItemsProperty.GetValue(null, null);
			if (value == null)
			{
				return 1;
			}
			object obj = Enum.ToObject(cachedItemTypeEnumType, itemTypeInt);
			object[] array = new object[2] { obj, null };
			if (!(bool)cachedTryGetItemDataMethod.Invoke(value, array) || array[1] == null)
			{
				return 1;
			}
			return (int)cachedItemDataMaxUsesProperty.GetValue(array[1], null);
		}
		catch
		{
			return 1;
		}
	}

	private string ItemIndexToName(int itemTypeInt)
	{
		int num = itemTypeInt - 1;
		if (num >= 0 && num < SpawnableItemNames.Length)
		{
			return SpawnableItemNames[num];
		}
		return "item #" + itemTypeInt;
	}

	private static Texture2D MakeTex(Color c)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_000a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		//IL_0017: Expected O, but got Unknown
		Texture2D val = new Texture2D(1, 1);
		val.SetPixel(0, 0, c);
		val.Apply();
		return val;
	}

	private void InitImStyles()
	{
		//IL_0025: Unknown result type (might be due to invalid IL or missing references)
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0091: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d9: 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_0117: Unknown result type (might be due to invalid IL or missing references)
		//IL_0121: Expected O, but got Unknown
		//IL_0157: Unknown result type (might be due to invalid IL or missing references)
		//IL_0161: Expected O, but got Unknown
		//IL_016b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0175: Expected O, but got Unknown
		//IL_0180: Unknown result type (might be due to invalid IL or missing references)
		//IL_0195: Unknown result type (might be due to invalid IL or missing references)
		//IL_019f: Expected O, but got Unknown
		//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ee: Expected O, but got Unknown
		//IL_023b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0269: Unknown result type (might be due to invalid IL or missing references)
		//IL_0273: Expected O, but got Unknown
		//IL_02cf: Unknown result type (might be due to invalid IL or missing references)
		//IL_02f1: Unknown result type (might be due to invalid IL or missing references)
		//IL_02fb: Expected O, but got Unknown
		//IL_032e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0343: Unknown result type (might be due to invalid IL or missing references)
		//IL_034d: Expected O, but got Unknown
		//IL_0365: Unknown result type (might be due to invalid IL or missing references)
		//IL_0386: Unknown result type (might be due to invalid IL or missing references)
		//IL_0390: Expected O, but got Unknown
		//IL_03c7: Unknown result type (might be due to invalid IL or missing references)
		//IL_03f5: Unknown result type (might be due to invalid IL or missing references)
		//IL_03ff: Expected O, but got Unknown
		//IL_0445: Unknown result type (might be due to invalid IL or missing references)
		//IL_0467: Unknown result type (might be due to invalid IL or missing references)
		//IL_0471: Expected O, but got Unknown
		//IL_04a8: Unknown result type (might be due to invalid IL or missing references)
		//IL_04c6: Unknown result type (might be due to invalid IL or missing references)
		//IL_04d0: Expected O, but got Unknown
		//IL_0507: Unknown result type (might be due to invalid IL or missing references)
		//IL_0511: Expected O, but got Unknown
		//IL_0548: Unknown result type (might be due to invalid IL or missing references)
		//IL_056a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0574: Expected O, but got Unknown
		//IL_05ba: Unknown result type (might be due to invalid IL or missing references)
		//IL_05e8: Unknown result type (might be due to invalid IL or missing references)
		//IL_05f2: Expected O, but got Unknown
		//IL_0625: Unknown result type (might be due to invalid IL or missing references)
		//IL_063a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0644: Expected O, but got Unknown
		//IL_0677: Unknown result type (might be due to invalid IL or missing references)
		if (!_imStylesReady)
		{
			_imStylesReady = true;
			_imTxDark = MakeTex(new Color(0.1f, 0.1f, 0.13f, 0.97f));
			_imTxBlue = MakeTex(new Color(0.22f, 0.5f, 0.9f, 1f));
			_imTxGrey = MakeTex(new Color(0.2f, 0.2f, 0.25f, 1f));
			_imTxDarker = MakeTex(new Color(0.07f, 0.07f, 0.09f, 1f));
			_imTxRed = MakeTex(new Color(0.6f, 0.12f, 0.12f, 1f));
			_imTxGreen = MakeTex(new Color(0.16f, 0.45f, 0.2f, 1f));
			_imTxSeparator = MakeTex(new Color(1f, 1f, 1f, 0.06f));
			_imWindowStyle = new GUIStyle(GUI.skin.window);
			_imWindowStyle.normal.background = _imTxDark;
			_imWindowStyle.onNormal.background = _imTxDark;
			_imWindowStyle.border = new RectOffset(4, 4, 4, 4);
			_imWindowStyle.padding = new RectOffset(0, 0, 0, 0);
			_imWindowStyle.normal.textColor = Color.clear;
			_imTitleStyle = new GUIStyle(GUI.skin.label);
			_imTitleStyle.fontSize = 14;
			_imTitleStyle.fontStyle = (FontStyle)1;
			_imTitleStyle.normal.textColor = Color.white;
			_imTitleStyle.alignment = (TextAnchor)3;
			_imTabActive = new GUIStyle(GUI.skin.button);
			_imTabActive.normal.background = _imTxBlue;
			_imTabActive.hover.background = _imTxBlue;
			_imTabActive.active.background = _imTxBlue;
			_imTabActive.normal.textColor = Color.white;
			_imTabActive.fontStyle = (FontStyle)1;
			_imTabActive.fontSize = 11;
			_imTabIdle = new GUIStyle(GUI.skin.button);
			_imTabIdle.normal.background = _imTxDarker;
			_imTabIdle.hover.background = _imTxGrey;
			_imTabIdle.active.background = _imTxGrey;
			_imTabIdle.normal.textColor = new Color(0.7f, 0.7f, 0.75f);
			_imTabIdle.fontSize = 11;
			_imSectionLabel = new GUIStyle(GUI.skin.label);
			_imSectionLabel.fontSize = 10;
			_imSectionLabel.fontStyle = (FontStyle)1;
			_imSectionLabel.normal.textColor = new Color(0.55f, 0.55f, 0.62f);
			_imActionLabel = new GUIStyle(GUI.skin.label);
			_imActionLabel.fontSize = 13;
			_imActionLabel.normal.textColor = Color.white;
			_imActionLabel.alignment = (TextAnchor)3;
			_imToggleOn = new GUIStyle(GUI.skin.button);
			_imToggleOn.normal.background = _imTxBlue;
			_imToggleOn.hover.background = _imTxBlue;
			_imToggleOn.normal.textColor = Color.white;
			_imToggleOn.fontSize = 11;
			_imToggleOn.fontStyle = (FontStyle)1;
			_imToggleOff = new GUIStyle(GUI.skin.button);
			_imToggleOff.normal.background = _imTxGrey;
			_imToggleOff.hover.background = _imTxGrey;
			_imToggleOff.normal.textColor = new Color(0.55f, 0.55f, 0.6f);
			_imToggleOff.fontSize = 11;
			_imKeyBadge = new GUIStyle(GUI.skin.button);
			_imKeyBadge.normal.background = _imTxBlue;
			_imKeyBadge.hover.background = _imTxGrey;
			_imKeyBadge.normal.textColor = Color.white;
			_imKeyBadge.fontSize = 11;
			_imRebindActive = new GUIStyle(_imKeyBadge);
			_imRebindActive.normal.background = _imTxGreen;
			_imRebindActive.hover.background = _imTxGreen;
			_imButton = new GUIStyle(GUI.skin.button);
			_imButton.normal.background = _imTxGrey;
			_imButton.hover.background = _imTxBlue;
			_imButton.normal.textColor = Color.white;
			_imButton.fontSize = 13;
			_imCloseBtn = new GUIStyle(GUI.skin.button);
			_imCloseBtn.normal.background = _imTxRed;
			_imCloseBtn.hover.background = _imTxRed;
			_imCloseBtn.normal.textColor = new Color(1f, 0.5f, 0.5f);
			_imCloseBtn.fontStyle = (FontStyle)1;
			_imCloseBtn.fontSize = 14;
			_imInfoLabel = new GUIStyle(GUI.skin.label);
			_imInfoLabel.fontSize = 12;
			_imInfoLabel.wordWrap = true;
			_imInfoLabel.normal.textColor = new Color(0.65f, 0.65f, 0.72f);
			_imDescLabel = new GUIStyle(GUI.skin.label);
			_imDescLabel.fontSize = 10;
			_imDescLabel.wordWrap = false;
			_imDescLabel.normal.textColor = new Color(0.5f, 0.5f, 0.58f);
		}
	}

	internal void BirdieOnGUI()
	{
		//IL_005e: Unknown result type (might be due to invalid IL or missing references)
		//IL_006a: Unknown result type (might be due to invalid IL or missing references)
		//IL_007f: Expected O, but got Unknown
		//IL_007a: Unknown result type (might be due to invalid IL or missing references)
		//IL_007f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0046: Unknown result type (might be due to invalid IL or missing references)
		//IL_004b: Unknown result type (might be due to invalid IL or missing references)
		if (settingsPanelOpen)
		{
			InitImStyles();
			if (!_imRectInit)
			{
				_imRect = new Rect((float)Screen.width * 0.5f - 320f, (float)Screen.height * 0.5f - 220f, 640f, 440f);
				_imRectInit = true;
			}
			_imRect = GUI.Window(9901, _imRect, new WindowFunction(DrawImWindow), string.Empty, _imWindowStyle);
		}
	}

	private void DrawImWindow(int id)
	{
		//IL_0030: Unknown result type (might be due to invalid IL or missing references)
		//IL_0058: Unknown result type (might be due to invalid IL or missing references)
		//IL_0083: 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_00d2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e6: 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_0272: Unknown result type (might be due to invalid IL or missing references)
		float width = ((Rect)(ref _imRect)).width;
		float height = ((Rect)(ref _imRect)).height;
		float num = 70f;
		float num2 = 36f;
		GUI.DrawTexture(new Rect(0f, 0f, width, num2), (Texture)(object)_imTxDarker);
		GUI.Label(new Rect(10f, 8f, width - 50f, num2 - 8f), "Birdie Settings", _imTitleStyle);
		if (GUI.Button(new Rect(width - 32f, 6f, 26f, 24f), "✕", _imCloseBtn))
		{
			CloseRosettaSettings();
		}
		GUI.DrawTexture(new Rect(0f, num2, width, 1f), (Texture)(object)_imTxSeparator);
		GUI.DrawTexture(new Rect(0f, num2 + 1f, num, height - num2 - 1f), (Texture)(object)_imTxDarker);
		GUI.DrawTexture(new Rect(num, num2 + 1f, 1f, height - num2 - 1f), (Texture)(object)_imTxSeparator);
		string[] array = new string[7] { "Features", "Keys", "HUD", "$", "Items", "Net", "Weather" };
		float num3 = 44f;
		for (int i = 0; i < array.Length; i++)
		{
			GUIStyle val = ((settingsTabIndex == i) ? _imTabActive : _imTabIdle);
			if (GUI.Button(new Rect(2f, num2 + 4f + (float)i * (num3 + 2f), num - 4f, num3), array[i], val))
			{
				settingsTabIndex = i;
			}
		}
		float num4 = num + 8f;
		float num5 = num2 + 6f;
		float num6 = width - num - 16f;
		float num7 = height - num5 - 6f;
		GUILayout.BeginArea(new Rect(num4, num5, num6, num7));
		switch (settingsTabIndex)
		{
		case 0:
			DrawImFeatures(num6);
			break;
		case 1:
			DrawImKeys(num6);
			break;
		case 2:
			DrawImHud(num6);
			break;
		case 3:
			DrawImCredits(num6);
			break;
		case 4:
			DrawImItems(num6);
			break;
		case 5:
			DrawImNetwork(num6);
			break;
		case 6:
			DrawImWeather(num6);
			break;
		}
		GUILayout.EndArea();
		GUI.DragWindow(new Rect(0f, 0f, width, num2));
	}

	private void DrawImFeatures(float w)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		_imFeaturesScroll = GUILayout.BeginScrollView(_imFeaturesScroll, Array.Empty<GUILayoutOption>());
		ImSectionHeader("CORE");
		if (IsFeatureAllowed(0))
		{
			ImToggleRowWithDesc("Ice Immunity [" + iceToggleKeyLabel + "]", iceImmunityEnabled, "Slide on ice without slipping", delegate
			{
				ToggleIceImmunity();
			});
		}
		if (IsFeatureAllowed(1))
		{
			ImToggleRowWithDesc("Shot Tracer", tracersEnabled, "Shows the ball's actual flight path", delegate
			{
				tracersEnabled = !tracersEnabled;
				SaveCurrentConfig();
				MarkTrailVisualSettingsDirty();
				MarkHudDirty();
			});
		}
		if (IsFeatureAllowed(14))
		{
			ImToggleRowWithDesc("Assist [" + assistToggleKeyLabel + "]", assistEnabled, "Auto-aims and releases at the perfect moment", delegate
			{
				ToggleAssist();
			});
		}
		if (IsFeatureAllowed(2))
		{
			ImToggleRowWithDesc("Impact Preview", impactPreviewEnabled, "Preview exactly where your shot will land", delegate
			{
				impactPreviewEnabled = !impactPreviewEnabled;
				SaveCurrentConfig();
			});
		}
		GUILayout.Space(6f);
		ImSectionHeader("EXTRAS");
		if (IsFeatureAllowed(3))
		{
			ImToggleRowWithDesc("No Wind [" + noWindKeyLabel + "]", noWindEnabled, "Removes wind deflection from your ball", delegate
			{
				ToggleNoWind();
			});
		}
		if (IsFeatureAllowed(4))
		{
			ImToggleRowWithDesc("Perfect Shot [" + perfectShotKeyLabel + "]", perfectShotEnabled, "Forces your swing into the perfect power zone", delegate
			{
				TogglePerfectShot();
			});
		}
		if (IsFeatureAllowed(5))
		{
			ImToggleRowWithDesc("No Air Drag [" + noAirDragKeyLabel + "]", noAirDragEnabled, "Removes air resistance — ball flies further", delegate
			{
				ToggleNoAirDrag();
			});
		}
		if (IsFeatureAllowed(6))
		{
			ImToggleRowWithDesc("Speed Boost [" + speedMultiplierKeyLabel + "]", speedMultiplierEnabled, "Multiplies your movement speed", delegate
			{
				ToggleSpeedMultiplier();
			});
		}
		if (IsFeatureAllowed(7))
		{
			ImToggleRowWithDesc("Inf. Item Usage [" + infiniteAmmoKeyLabel + "]", infiniteAmmoEnabled, "Weapons and items never run out", delegate
			{
				ToggleInfiniteAmmo();
			});
		}
		if (IsFeatureAllowed(8))
		{
			ImToggleRowWithDesc("No Recoil [" + noRecoilKeyLabel + "]", noRecoilEnabled, "Removes screen shake when firing weapons", delegate
			{
				ToggleNoRecoil();
			});
		}
		if (IsFeatureAllowed(9))
		{
			ImToggleRowWithDesc("No Knockback [" + noKnockbackKeyLabel + "]", noKnockbackEnabled, "Prevents weapons from flinging you back", delegate
			{
				ToggleNoKnockback();
			});
		}
		if (IsFeatureAllowed(10))
		{
			ImToggleRowWithDesc("Landmine Immunity [" + landmineImmunityKeyLabel + "]", landmineImmunityEnabled, "Walk over landmines without being hit", delegate
			{
				ToggleLandmineImmunity();
			});
		}
		if (IsFeatureAllowed(11))
		{
			ImToggleRowWithDesc("Lock-On Any Dist. [" + lockOnAnyDistanceKeyLabel + "]", lockOnAnyDistanceEnabled, "Lock-on targets golf balls at any range", delegate
			{
				ToggleLockOnAnyDistance();
			});
		}
		if (IsFeatureAllowed(12))
		{
			ImToggleRowWithDesc("Expanded Slots [" + expandedSlotsKeyLabel + "]", expandedSlotsEnabled, "Expand hotbar to 8 total slots / keys 1-8", delegate
			{
				ToggleExpandedSlots();
			});
			if (expandedSlotsEnabled && IsNetworkHost())
			{
				ImToggleRow("  Apply to all players", expandedSlotsAllPlayers, delegate
				{
					expandedSlotsAllPlayers = !expandedSlotsAllPlayers;
					SaveCurrentConfig();
					if (expandedSlotsEnabled)
					{
						TryExpandServerInventorySlotsPublic();
					}
				});
			}
		}
		if (IsFeatureAllowed(6))
		{
			GUILayout.Space(6f);
			ImSectionHeader("SPEED FACTOR");
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label("x" + speedMultiplierFactor.ToString("F1"), _imActionLabel, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(36f) });
			float num = GUILayout.HorizontalSlider(speedMultiplierFactor, 0.5f, 10f, Array.Empty<GUILayoutOption>());
			if (Math.Abs(num - speedMultiplierFactor) > 0.01f)
			{
				speedMultiplierFactor = Mathf.Round(num * 10f) / 10f;
				if (speedMultiplierEnabled)
				{
					ApplySpeedMultiplierState();
				}
				SaveCurrentConfig();
			}
			GUILayout.EndHorizontal();
		}
		GUILayout.EndScrollView();
	}

	private void DrawImKeys(float w)
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Expected O, but got Unknown
		//IL_003f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_0085: Unknown result type (might be due to invalid IL or missing references)
		//IL_008f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0094: Unknown result type (might be due to invalid IL or missing references)
		GUIStyle val = new GUIStyle(_imInfoLabel);
		val.normal.textColor = (keybindRebindMode ? new Color(0.4f, 0.9f, 0.5f) : new Color(0.55f, 0.55f, 0.62f));
		GUILayout.Label(keybindRebindMode ? ("Press any key to bind: " + SettingsKeybindDisplayNames[keybindRebindIndex]) : "Click a key badge to rebind", val, Array.Empty<GUILayoutOption>());
		GUILayout.Space(4f);
		_imKeysScroll = GUILayout.BeginScrollView(_imKeysScroll, Array.Empty<GUILayoutOption>());
		for (int num = 0; num < SettingsKeybindDisplayNames.Length; num++)
		{
			int index = num;
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label(SettingsKeybindDisplayNames[num], _imActionLabel, Array.Empty<GUILayoutOption>());
			int num2;
			GUIStyle obj;
			if (keybindRebindMode)
			{
				num2 = ((keybindRebindIndex == num) ? 1 : 0);
				if (num2 != 0)
				{
					obj = _imRebindActive;
					goto IL_00e8;
				}
			}
			else
			{
				num2 = 0;
			}
			obj = _imKeyBadge;
			goto IL_00e8;
			IL_00e8:
			GUIStyle val2 = obj;
			if (GUILayout.Button((num2 != 0) ? "..." : FormatKeyLabel(GetKeybindNameByIndex(num)), val2, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(80f),
				GUILayout.Height(24f)
			}))
			{
				StartKeybindRebindForIndex(index);
			}
			GUILayout.EndHorizontal();
			GUILayout.Space(2f);
		}
		GUILayout.EndScrollView();
	}

	private void DrawImHud(float w)
	{
		ImSectionHeader("HUD VISIBILITY");
		ImToggleRow("Bottom keybind bar", hudShowBottomBar, delegate
		{
			hudShowBottomBar = !hudShowBottomBar;
			SaveCurrentConfig();
			MarkHudDirty();
		});
		ImToggleRow("Ball distance to hole", hudShowBallDistance, delegate
		{
			hudShowBallDistance = !hudShowBallDistance;
			SaveCurrentConfig();
			MarkHudDirty();
		});
		ImToggleRow("Ice immunity indicator", hudShowIceIndicator, delegate
		{
			hudShowIceIndicator = !hudShowIceIndicator;
			SaveCurrentConfig();
			MarkHudDirty();
		});
		ImToggleRow("Center title", hudShowCenterTitle, delegate
		{
			hudShowCenterTitle = !hudShowCenterTitle;
			SaveCurrentConfig();
			MarkHudDirty();
		});
		ImToggleRow("Player info (left)", hudShowPlayerInfo, delegate
		{
			hudShowPlayerInfo = !hudShowPlayerInfo;
			SaveCurrentConfig();
			MarkHudDirty();
		});
		ImToggleRow("Shot tracers", tracersEnabled, delegate
		{
			tracersEnabled = !tracersEnabled;
			SaveCurrentConfig();
			MarkTrailVisualSettingsDirty();
			MarkHudDirty();
		});
	}

	private void DrawImCredits(float w)
	{
		//IL_0111: Unknown result type (might be due to invalid IL or missing references)
		//IL_0117: Expected O, but got Unknown
		//IL_0131: Unknown result type (might be due to invalid IL or missing references)
		GUILayout.Label("Grant credits to yourself\n(client-local, no server sync)", _imInfoLabel, Array.Empty<GUILayoutOption>());
		GUILayout.Space(8f);
		GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
		GUILayout.Label("Amount:", _imActionLabel, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(70f) });
		GUILayout.Label(creditsGrantAmount.ToString(), _imActionLabel, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(60f) });
		GUILayout.EndHorizontal();
		int num = Mathf.RoundToInt(GUILayout.HorizontalSlider((float)creditsGrantAmount, 0f, 50000f, Array.Empty<GUILayoutOption>()));
		if (num != creditsGrantAmount)
		{
			creditsGrantAmount = num;
			SaveCurrentConfig();
		}
		GUILayout.Space(8f);
		if (GUILayout.Button("Grant " + creditsGrantAmount + " Credits", _imButton, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(34f) }))
		{
			GrantCredits(creditsGrantAmount);
		}
		GUILayout.Space(12f);
		GUIStyle val = new GUIStyle(_imButton);
		val.normal.textColor = new Color(0.56f, 0.62f, 0.9f, 1f);
		if (GUILayout.Button("Join Discord", val, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(30f) }))
		{
			Application.OpenURL("https://discord.gg/wbhNEHFGMq");
		}
	}

	private void DrawImItems(float w)
	{
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: Expected O, but got Unknown
		//IL_0040: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0070: Unknown result type (might be due to invalid IL or missing references)
		//IL_007a: Unknown result type (might be due to invalid IL or missing references)
		//IL_007f: Unknown result type (might be due to invalid IL or missing references)
		bool flag = BirdieGrantBridge.IsReady();
		GUIStyle val = new GUIStyle(_imInfoLabel);
		val.normal.textColor = (flag ? new Color(0.3f, 0.85f, 0.45f) : new Color(0.8f, 0.35f, 0.35f));
		GUILayout.Label(flag ? "Host has BirdieMod — items will spawn" : "Host does not have BirdieMod — items require host", val, Array.Empty<GUILayoutOption>());
		GUILayout.Space(6f);
		_imItemsScroll = GUILayout.BeginScrollView(_imItemsScroll, Array.Empty<GUILayoutOption>());
		float num = (w - 12f) * 0.5f;
		for (int i = 0; i < SpawnableItemNames.Length; i++)
		{
			if (i % 2 == 0)
			{
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			}
			int itemTypeInt = SpawnableItemTypeInts[i];
			if (GUILayout.Button(SpawnableItemKeyLabels[i] + "  " + SpawnableItemNames[i], _imButton, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(num),
				GUILayout.Height(30f)
			}))
			{
				SpawnItemClientSide(itemTypeInt);
			}
			if (i % 2 == 1 || i == SpawnableItemNames.Length - 1)
			{
				GUILayout.EndHorizontal();
			}
			if (i % 2 == 1)
			{
				GUILayout.Space(2f);
			}
		}
		GUILayout.EndScrollView();
	}

	private void DrawImNetwork(float w)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_013f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0145: Expected O, but got Unknown
		//IL_015f: Unknown result type (might be due to invalid IL or missing references)
		_imNetScroll = GUILayout.BeginScrollView(_imNetScroll, Array.Empty<GUILayoutOption>());
		if (IsNetworkHost())
		{
			ImSectionHeader("HOST CONTROLS");
			ImToggleRow("Host Controls", hostControlsActive, delegate
			{
				SetHostControlsActive(!hostControlsActive);
			});
			if (hostControlsActive)
			{
				GUILayout.Space(4f);
				ImSectionHeader("ALLOWED FEATURES");
				ImHostFeatureToggle("Ice Immunity", 0);
				ImHostFeatureToggle("Shot Tracer", 1);
				ImHostFeatureToggle("Impact Preview", 2);
				ImHostFeatureToggle("No Wind", 3);
				ImHostFeatureToggle("Perfect Shot", 4);
				ImHostFeatureToggle("No Air Drag", 5);
				ImHostFeatureToggle("Speed Multiplier", 6);
				ImHostFeatureToggle("Infinite Item Usage", 7);
				ImHostFeatureToggle("No Recoil", 8);
				ImHostFeatureToggle("No Knockback", 9);
				ImHostFeatureToggle("Landmine Immunity", 10);
				ImHostFeatureToggle("Lock-On Any Dist.", 11);
				ImHostFeatureToggle("Expanded Slots", 12);
				ImHostFeatureToggle("Coffee Boost", 13);
				ImHostFeatureToggle("Assist", 14);
				ImHostFeatureToggle("Weather", 15);
			}
		}
		else if (BirdieHostBridge.IsUnderHostControl)
		{
			GUIStyle val = new GUIStyle(_imInfoLabel);
			val.normal.textColor = new Color(1f, 0.75f, 0.2f, 1f);
			GUILayout.Label("Host Controls Active", val, Array.Empty<GUILayoutOption>());
			GUILayout.Space(4f);
			GUILayout.Label("Some features may be restricted by the lobby host.", _imInfoLabel, Array.Empty<GUILayoutOption>());
		}
		else
		{
			GUILayout.Label("No host control active. All features available.", _imInfoLabel, Array.Empty<GUILayoutOption>());
		}
		GUILayout.EndScrollView();
	}

	private void DrawImWeather(float w)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_0195: Unknown result type (might be due to invalid IL or missing references)
		//IL_019c: Expected O, but got Unknown
		//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
		_imNetScroll = GUILayout.BeginScrollView(_imNetScroll, Array.Empty<GUILayoutOption>());
		if (!IsNetworkHost())
		{
			GUILayout.Label("Weather controls are available to the lobby host only.", _imInfoLabel, Array.Empty<GUILayoutOption>());
			GUILayout.EndScrollView();
			return;
		}
		ImSectionHeader("WEATHER EVENT");
		string[] array = new string[9] { "None (Clear)", "Rain - Light", "Rain - Medium", "Rain - Heavy", "Wind Gusts - Light", "Wind Gusts - Medium", "Wind Gusts - Heavy", "Thunderstorm", "Tornado" };
		for (int i = 0; i < array.Length; i++)
		{
			GUIStyle val = ((_hostSelectedWeather == (byte)i) ? _imToggleOn : _imToggleOff);
			if (GUILayout.Button(array[i], val, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(28f) }))
			{
				_hostSelectedWeather = (byte)i;
			}
		}
		GUILayout.Space(8f);
		GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
		if (GUILayout.Button(_hostWeatherRunning ? "Stop Weather" : "Start Weather", _imButton, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(34f) }))
		{
			if (_hostWeatherRunning)
			{
				_hostWeatherRunning = false;
				BirdieWeatherBridge.BroadcastWeather(0, weatherAllowed: true);
				ApplyWeather(0);
			}
			else
			{
				_hostWeatherRunning = true;
				bool weatherAllowed = (hostAllowedFeatureMask & 0x8000) != 0;
				BirdieWeatherBridge.BroadcastWeather(_hostSelectedWeather, weatherAllowed);
				ApplyWeather(_hostSelectedWeather);
			}
		}
		GUILayout.EndHorizontal();
		if (_hostWeatherRunning)
		{
			GUIStyle val2 = new GUIStyle(_imInfoLabel);
			val2.normal.textColor = new Color(0.3f, 0.85f, 0.45f, 1f);
			GUILayout.Label("Weather active: " + ((_hostSelectedWeather < 9) ? (new string[9] { "None", "Rain (Light)", "Rain (Medium)", "Rain (Heavy)", "Wind Gusts (Light)", "Wind Gusts (Medium)", "Wind Gusts (Heavy)", "Thunderstorm", "Tornado" })[_hostSelectedWeather] : "Unknown"), val2, Array.Empty<GUILayoutOption>());
		}
		GUILayout.Space(10f);
		ImSectionHeader("AUTO WEATHER");
		GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
		GUIStyle val3 = (autoWeatherEnabled ? _imToggleOn : _imToggleOff);
		if (GUILayout.Button(autoWeatherEnabled ? "Auto Weather  ON" : "Auto Weather  OFF", val3, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(28f) }))
		{
			autoWeatherEnabled = !autoWeatherEnabled;
		}
		GUILayout.EndHorizontal();
		GUILayout.Space(4f);
		GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
		GUILayout.Label("Spawn Chance", _imInfoLabel, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(110f) });
		autoWeatherChance = Mathf.RoundToInt(GUILayout.HorizontalSlider((float)autoWeatherChance, 0f, 100f, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(w - 180f) }));
		GUILayout.Label(autoWeatherChance + "%", _imInfoLabel, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(40f) });
		GUILayout.EndHorizontal();
		GUILayout.Space(4f);
		GUILayout.Label("Per-Type Spawn Weight (0 = disabled):", _imInfoLabel, Array.Empty<GUILayoutOption>());
		string[] array2 = new string[8] { "Rain - Light", "Rain - Medium", "Rain - Heavy", "Wind - Light", "Wind - Medium", "Wind - Heavy", "Thunderstorm", "Tornado" };
		for (int j = 0; j < array2.Length; j++)
		{
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label(array2[j], _imInfoLabel, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(115f) });
			autoWeatherChances[j] = Mathf.RoundToInt(GUILayout.HorizontalSlider((float)autoWeatherChances[j], 0f, 100f, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(w - 195f) }));
			GUILayout.Label(autoWeatherChances[j] + "%", _imInfoLabel, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(40f) });
			GUILayout.EndHorizontal();
		}
		GUILayout.Space(10f);
		ImSectionHeader("NOTES");
		GUILayout.Label("Wind changes affect all players. Rain drag and visual effects apply to Birdie clients only.", _imInfoLabel, Array.Empty<GUILayoutOption>());
		GUILayout.EndScrollView();
	}

	private void ImHostFeatureToggle(string label, int bit)
	{
		bool enabled = (hostAllowedFeatureMask & (ulong)(1L << bit)) != 0;
		ImToggleRow(label, enabled, delegate
		{
			SetHostFeatureBit(bit, !enabled);
		});
	}

	private bool IsNetworkHost()
	{
		try
		{
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			for (int i = 0; i < assemblies.Length; i++)
			{
				Type type = assemblies[i].GetType("Mirror.NetworkServer");
				if (!(type == null))
				{
					PropertyInfo property = type.GetProperty("active", BindingFlags.Static | BindingFlags.Public);
					if (property != null)
					{
						return (bool)property.GetValue(null);
					}
					break;
				}
			}
		}
		catch
		{
		}
		return false;
	}

	private void ImSectionHeader(string text)
	{
		GUILayout.Label(text, _imSectionLabel, Array.Empty<GUILayoutOption>());
	}

	private void ImToggleRow(string label, bool value, Action onToggle)
	{
		GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
		GUILayout.Label(label, _imActionLabel, Array.Empty<GUILayoutOption>());
		GUIStyle val = (value ? _imToggleOn : _imToggleOff);
		if (GUILayout.Button(value ? "ON" : "OFF", val, (GUILayoutOption[])(object)new GUILayoutOption[2]
		{
			GUILayout.Width(48f),
			GUILayout.Height(24f)
		}))
		{
			onToggle();
		}
		GUILayout.EndHorizontal();
		GUILayout.Space(1f);
	}

	private void ImToggleRowWithDesc(string label, bool value, string desc, Action onToggle)
	{
		GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
		GUILayout.BeginVertical(Array.Empty<GUILayoutOption>());
		GUILayout.Label(label, _imActionLabel, Array.Empty<GUILayoutOption>());
		GUILayout.Label(desc, _imDescLabel, Array.Empty<GUILayoutOption>());
		GUILayout.EndVertical();
		GUIStyle val = (value ? _imToggleOn : _imToggleOff);
		if (GUILayout.Button(value ? "ON" : "OFF", val, (GUILayoutOption[])(object)new GUILayoutOption[2]
		{
			GUILayout.Width(48f),
			GUILayout.Height(34f)
		}))
		{
			onToggle();
		}
		GUILayout.EndHorizontal();
		GUILayout.Space(2f);
	}

	private void OpenRosettaSettings()
	{
		settingsPanelOpen = true;
		keybindRebindMode = false;
		keybindRebindIndex = -1;
		ApplyCursorUnlockForSettings(unlock: true);
		ApplyGameInputSuppressionForSettings(suppress: true);
		MarkHudDirty();
	}

	private void CloseRosettaSettings()
	{
		settingsPanelOpen = false;
		keybindRebindMode = false;
		keybindRebindIndex = -1;
		ApplyCursorUnlockForSettings(unlock: false);
		ApplyGameInputSuppressionForSettings(suppress: false);
		MarkHudDirty();
	}

	private void ToggleRosettaSettings()
	{
		if (settingsPanelOpen)
		{
			CloseRosettaSettings();
		}
		else
		{
			OpenRosettaSettings();
		}
	}

	private void EnsureRosettaRoot()
	{
	}

	internal void BirdieInit()
	{
		LoadOrCreateConfig();
		WeatherSystemInit();
	}

	internal void BirdieUpdate()
	{
		float time = Time.time;
		BirdieGrantBridge.EnsureInitialized();
		BirdieHostBridge.EnsureHandlersRegistered();
		BirdieWeatherBridge.EnsureHandlersRegistered();
		if (BirdieHostBridge.FlagExpandedSlotsForClient && !expandedSlotsEnabled)
		{
			BirdieHostBridge.FlagExpandedSlotsForClient = false;
			ToggleExpandedSlots();
		}
		WeatherSystemUpdate();
		PollDispenserPickup();
		PollCrateReturn();
		InvalidateResolvedContextIfLost();
		HandleInput();
		if (((Object)(object)playerMovement == (Object)null || (Object)(object)playerGolfer == (Object)null) && time >= nextPlayerSearchTime)
		{
			nextPlayerSearchTime = time + playerSearchInterval;
			ResolvePlayerContext();
		}
		EnsureLocalGolfBallReference(force: false);
		if ((Object)(object)playerGolfer != (Object)null && time >= nextIdealSwingCalculationTime)
		{
			nextIdealSwingCalculationTime = time + idealSwingCalculationInterval;
			CalculateIdealSwingParameters(forceHoleRefresh: false);
		}
		EnsureVisualsInitialized();
		if (visualsInitialized)
		{
			UpdateTrails();
			UpdateHud();
			UpdateImpactPreview();
		}
	}

	internal void BirdieLateUpdate()
	{
		TickInfiniteAmmo();
		TickNoKnockback();
		AutoAimCamera();
		ApplyPerfectShotForcing();
		if (assistEnabled && isLeftMousePressed && !autoReleaseTriggeredThisCharge)
		{
			AutoSwingRelease();
		}
		WeatherSystemLateUpdate();
	}

	private void HandleInput()
	{
		UpdateMouseState();
		HandleKeyboardShortcuts();
	}

	private void UpdateMouseState()
	{
		bool flag = isLeftMousePressed;
		if (Mouse.current != null)
		{
			isLeftMousePressed = Mouse.current.leftButton.isPressed;
			isRightMousePressed = Mouse.current.rightButton.isPressed;
		}
		else
		{
			isLeftMousePressed = false;
			isRightMousePressed = false;
		}
		if (isLeftMousePressed && !flag)
		{
			ResetChargeState();
			ResetTrailState();
			if (assistEnabled)
			{
				CalculateIdealSwingParameters(forceHoleRefresh: true);
			}
		}
		else if (!isLeftMousePressed && flag)
		{
			ResetChargeState();
			DisableAutoAimCamera();
		}
	}

	private void HandleKeyboardShortcuts()
	{
		//IL_000a: Unknown result type (might be due to invalid IL or missing references)
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		//IL_0046: Unknown result type (might be due to invalid IL or missing references)
		//IL_005a: Unknown result type (might be due to invalid IL or missing references)
		//IL_006e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0082: 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_00aa: Unknown result type (might be due to invalid IL or missing references)
		//IL_00be: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
		//IL_010e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0122: Unknown result type (might be due to invalid IL or missing references)
		//IL_0136: 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_015e: Unknown result type (might be due to invalid IL or missing references)
		if (Keyboard.current != null)
		{
			if (WasConfiguredKeyPressed(assistToggleKey))
			{
				ToggleAssist();
			}
			if (WasConfiguredKeyPressed(coffeeBoostKey))
			{
				AddCoffeeBoost();
			}
			if (WasConfiguredKeyPressed(nearestBallModeKey))
			{
				ToggleNearestBallMode();
			}
			if (WasConfiguredKeyPressed(unlockAllCosmeticsKey))
			{
				UnlockAllCosmetics();
			}
			if (WasConfiguredKeyPressed(hudToggleKey))
			{
				ToggleHudVisibility();
			}
			if (WasConfiguredKeyPressed(randomItemKey))
			{
				TryCollectFromCrate();
			}
			if (WasConfiguredKeyPressed(iceToggleKey))
			{
				ToggleIceImmunity();
			}
			if (WasConfiguredKeyPressed(noWindKey))
			{
				ToggleNoWind();
			}
			if (WasConfiguredKeyPressed(perfectShotKey))
			{
				TogglePerfectShot();
			}
			if (WasConfiguredKeyPressed(noAirDragKey))
			{
				ToggleNoAirDrag();
			}
			if (WasConfiguredKeyPressed(speedMultiplierKey))
			{
				ToggleSpeedMultiplier();
			}
			if (WasConfiguredKeyPressed(infiniteAmmoKey))
			{
				ToggleInfiniteAmmo();
			}
			if (WasConfiguredKeyPressed(noRecoilKey))
			{
				ToggleNoRecoil();
			}
			if (WasConfiguredKeyPressed(noKnockbackKey))
			{
				ToggleNoKnockback();
			}
			if (WasConfiguredKeyPressed(landmineImmunityKey))
			{
				ToggleLandmineImmunity();
			}
			if (WasConfiguredKeyPressed(lockOnAnyDistanceKey))
			{
				ToggleLockOnAnyDistance();
			}
			if (WasConfiguredKeyPressed(expandedSlotsKey))
			{
				ToggleExpandedSlots();
			}
			if (WasConfiguredKeyPressed(settingsKey))
			{
				ToggleRosettaSettings();
			}
			if (settingsPanelOpen)
			{
				HandleSettingsPanelInput();
			}
		}
	}

	private void ToggleHudVisibility()
	{
		hudVisible = !hudVisible;
		ApplyHudVisibility();
	}

	private void ToggleAssist()
	{
		if (IsFeatureAllowed(-1))
		{
			assistEnabled = !assistEnabled;
			MarkHudDirty();
			if (assistEnabled)
			{
				ResolvePlayerContext();
				FindHoleOnly(force: true);
				CalculateIdealSwingParameters(forceHoleRefresh: true);
			}
			else
			{
				DisableAutoAimCamera();
				ResetChargeState();
				ClearPredictedTrails(hideFrozenSnapshot: true);
			}
		}
	}

	private void AddCoffeeBoost()
	{
		if (!IsFeatureAllowed(13))
		{
			return;
		}
		if ((Object)(object)playerMovement == (Object)null || addSpeedBoostMethod == null)
		{
			ResolvePlayerContext();
		}
		if ((Object)(object)playerMovement == (Object)null || addSpeedBoostMethod == null)
		{
			return;
		}
		try
		{
			cachedSpeedBoostArgs[0] = 500f;
			addSpeedBoostMethod.Invoke(playerMovement, cachedSpeedBoostArgs);
		}
		catch
		{
		}
	}

	private void ToggleNearestBallMode()
	{
		nearestAnyBallModeEnabled = !nearestAnyBallModeEnabled;
		nextNearestAnyBallResolveTime = 0f;
		MarkHudDirty();
		ResolvePlayerContext();
		EnsureLocalGolfBallReference(force: true);
		ResetTrailState();
		if ((Object)(object)playerGolfer != (Object)null)
		{
			FindHoleOnly(force: true);
			CalculateIdealSwingParameters(forceHoleRefresh: true);
		}
	}

	private void InvalidateResolvedContextIfLost()
	{
		if (hadResolvedPlayerContext && ((Object)(object)playerMovement == (Object)null || (Object)(object)playerGolfer == (Object)null || (Object)(object)playerMovement.gameObject == (Object)null || (Object)(object)playerGolfer.gameObject == (Object)null))
		{
			playerFound = false;
			playerMovement = null;
			playerGolfer = null;
			golfBall = null;
			addSpeedBoostMethod = null;
			localPlayerHittable = null;
			lastBallResolveSource = "missing";
			hadResolvedPlayerContext = false;
			hadResolvedBallContext = false;
			ClearRuntimeState();
		}
		else if (hadResolvedBallContext && ((Object)(object)golfBall == (Object)null || (Object)(object)golfBall.gameObject == (Object)null))
		{
			golfBall = null;
			lastBallResolveSource = "missing";
			hadResolvedBallContext = false;
			ClearRuntimeState();
		}
	}

	private void ResetChargeState()
	{
		autoReleaseTriggeredThisCharge = false;
		autoChargeSequenceStarted = false;
		nextTryStartChargingTime = 0f;
		lastAutoSwingReleaseFrame = -1;
		lastObservedSwingPower = 0f;
	}

	private void ClearRuntimeState()
	{
		//IL_008a: Unknown result type (might be due to invalid IL or missing references)
		//IL_008f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0095: Unknown result type (might be due to invalid IL or missing references)
		//IL_009a: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
		dispenserPickupPending = false;
		dispenserPickupLocalInventory = null;
		pendingCrateTeleport = false;
		crateReturnPending = false;
		settingsPanelOpen = false;
		keybindRebindMode = false;
		keybindRebindIndex = -1;
		UpdateSettingsPanelVisibility();
		DisableAutoAimCamera();
		ResetChargeState();
		ResetTrailState();
		HideImpactPreview();
		cachedImpactPreviewReferenceCamera = null;
		nextImpactPreviewReferenceCameraRefreshTime = 0f;
		nextGolfBallCacheRefreshTime = 0f;
		cachedGolfBalls.Clear();
		localPlayerHittable = null;
		nextPredictedPathRefreshTime = 0f;
		currentAimTargetPosition = Vector3.zero;
		currentSwingOriginPosition = Vector3.zero;
		windAimOffset = Vector3.zero;
		holePosition = Vector3.zero;
		flagPosition = Vector3.zero;
		nextHoleSearchTime = 0f;
		nextIdealSwingCalculationTime = 0f;
		cachedLocalPlayerDisplayName = "";
		nextDisplayNameRefreshTime = 0f;
		MarkHudDirty();
	}

	private void EnsureVisualsInitialized()
	{
		if (!visualsInitialized && !(Time.realtimeSinceStartup < visualsInitializationDelay))
		{
			CreateHud();
			EnsureTrailRenderers();
			ApplyTrailVisualSettings();
			visualsInitialized = true;
		}
	}

	private static Sprite GetRoundedSprite(ref Sprite cache, int texSize, int radius)
	{
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_0017: Expected O, but got Unknown
		//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
		//IL_006a: Unknown result type (might be due to invalid IL or missing references)
		//IL_004f: Unknown result type (might be due to invalid IL or missing references)
		//IL_006f: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)cache != (Object)null)
		{
			return cache;
		}
		Texture2D val = new Texture2D(texSize, texSize, (TextureFormat)4, false);
		((Texture)val).wrapMode = (TextureWrapMode)1;
		((Texture)val).filterMode = (FilterMode)1;
		Color32[] array = (Color32[])(object)new Color32[texSize * texSize];
		for (int i = 0; i < texSize; i++)
		{
			for (int j = 0; j < texSize; j++)
			{
				array[i * texSize + j] = (InsideRoundedRect(j, i, texSize, texSize, radius) ? new Color32(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue) : new Color32((byte)0, (byte)0, (byte)0, (byte)0));
			}
		}
		val.SetPixels32(array);
		val.Apply();
		cache = Sprite.Create(val, new Rect(0f, 0f, (float)texSize, (float)texSize), new Vector2(0.5f, 0.5f), 100f, 0u, (SpriteMeshType)0, new Vector4((float)radius, (float)radius, (float)radius, (float)radius));
		return cache;
	}

	private static bool InsideRoundedRect(int px, int py, int w, int h, int r)
	{
		int num = w - r - 1;
		int num2 = h - r - 1;
		int num3 = ((px < r) ? r : ((px > num) ? num : px));
		int num4 = ((py < r) ? r : ((py > num2) ? num2 : py));
		int num5 = px - num3;
		int num6 = py - num4;
		return num5 * num5 + num6 * num6 <= r * r;
	}

	private static void SetRounded(Image img, Sprite sprite, Color color)
	{
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		img.sprite = sprite;
		img.type = (Type)1;
		img.pixelsPerUnitMultiplier = 1f;
		((Graphic)img).color = color;
	}

	private IEnumerator AnimatePanelOpen()
	{
		CanvasGroup cg = (((Object)(object)settingsPanelObject != (Object)null) ? settingsPanelObject.GetComponent<CanvasGroup>() : null);
		if (!((Object)(object)cg == (Object)null))
		{
			float dur = 0.18f;
			float t = 0f;
			while (t < dur)
			{
				t += Time.unscaledDeltaTime;
				float num2 = (cg.alpha = Mathf.SmoothStep(0f, 1f, t / dur));
				float num3 = Mathf.Lerp(0.92f, 1f, num2);
				settingsPanelObject.transform.localScale = new Vector3(num3, num3, 1f);
				yield return null;
			}
			cg.alpha = 1f;
			settingsPanelObject.transform.localScale = Vector3.one;
		}
	}

	private IEnumerator AnimatePanelClose()
	{
		CanvasGroup cg = (((Object)(object)settingsPanelObject != (Object)null) ? settingsPanelObject.GetComponent<CanvasGroup>() : null);
		if ((Object)(object)cg == (Object)null)
		{
			if ((Object)(object)settingsPanelObject != (Object)null)
			{
				settingsPanelObject.SetActive(false);
			}
			yield break;
		}
		float dur = 0.12f;
		float t = 0f;
		while (t < dur)
		{
			t += Time.unscaledDeltaTime;
			float num = Mathf.SmoothStep(0f, 1f, t / dur);
			cg.alpha = 1f - num;
			float num2 = Mathf.Lerp(1f, 0.95f, num);
			settingsPanelObject.transform.localScale = new Vector3(num2, num2, 1f);
			yield return null;
		}
		cg.alpha = 0f;
		settingsPanelObject.SetActive(false);
		settingsPanelObject.transform.localScale = Vector3.one;
	}

	private IEnumerator AnimatePillSlide(RectTransform knob, Image pillBg, float targetX, Color targetColor)
	{
		//IL_001c: Unknown result type (might be due to invalid IL or missing references)
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		float dur = 0.14f;
		float t = 0f;
		float startX = knob.anchoredPosition.x;
		Color startColor = ((Graphic)pillBg).color;
		while (t < dur)
		{
			t += Time.unscaledDeltaTime;
			float num = Mathf.SmoothStep(0f, 1f, t / dur);
			if ((Object)(object)knob != (Object)null)
			{
				knob.anchoredPosition = new Vector2(Mathf.Lerp(startX, targetX, num), 0f);
			}
			if ((Object)(object)pillBg != (Object)null)
			{
				((Graphic)pillBg).color = Color.Lerp(startColor, targetColor, num);
			}
			yield return null;
		}
		if ((Object)(object)knob != (Object)null)
		{
			knob.anchoredPosition = new Vector2(targetX, 0f);
		}
		if ((Object)(object)pillBg != (Object)null)
		{
			((Graphic)pillBg).color = targetColor;
		}
	}

	private void OpenSettingsMenu()
	{
		//IL_007d: Unknown result type (might be due to invalid IL or missing references)
		settingsPanelOpen = true;
		keybindRebindMode = false;
		keybindRebindIndex = -1;
		ApplyCursorUnlockForSettings(unlock: true);
		ApplyGameInputSuppressionForSettings(suppress: true);
		SetSettingsV2Tab(settingsTabIndex);
		UpdateSettingsPanelVisibility();
		if ((Object)(object)settingsPanelObject != (Object)null)
		{
			CanvasGroup component = settingsPanelObject.GetComponent<CanvasGroup>();
			if ((Object)(object)component != (Object)null)
			{
				component.alpha = 0f;
				settingsPanelObject.transform.localScale = new Vector3(0.92f, 0.92f, 1f);
			}
			BirdieCoroutine.Start(AnimatePanelOpen());
		}
		MarkHudDirty();
	}

	private void CloseSettingsMenu()
	{
		settingsPanelOpen = false;
		keybindRebindMode = false;
		keybindRebindIndex = -1;
		ApplyCursorUnlockForSettings(unlock: false);
		ApplyGameInputSuppressionForSettings(suppress: false);
		BirdieCoroutine.Start(AnimatePanelClose());
		MarkHudDirty();
	}

	private void InitializeSettingsInputReflection()
	{
		if (settingsInputReflectionInitialized)
		{
			return;
		}
		settingsInputReflectionInitialized = true;
		try
		{
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			foreach (Assembly assembly in assemblies)
			{
				if (cachedCursorSetForceUnlockedMethod == null)
				{
					Type type = assembly.GetType("CursorManager");
					if (type != null)
					{
						cachedCursorSetForceUnlockedMethod = type.GetMethod("SetCursorForceUnlocked", BindingFlags.Static | BindingFlags.Public);
					}
				}
				if (cachedInputManagerEnableModeMethod == null || cachedInputManagerDisableModeMethod == null)
				{
					Type type2 = assembly.GetType("InputManager");
					if (type2 != null)
					{
						if (cachedInputManagerEnableModeMethod == null)
						{
							cachedInputManagerEnableModeMethod = type2.GetMethod("EnableMode", BindingFlags.Static | BindingFlags.Public);
						}
						if (cachedInputManagerDisableModeMethod == null)
						{
							cachedInputManagerDisableModeMethod = type2.GetMethod("DisableMode", BindingFlags.Static | BindingFlags.Public);
						}
					}
				}
				if (cachedInputModePausedValue == null)
				{
					Type type3 = assembly.GetType("InputMode");
					if (type3 != null && type3.IsEnum)
					{
						try
						{
							cachedInputModePausedValue = Enum.Parse(type3, "Paused");
						}
						catch
						{
						}
					}
				}
				if (cachedCursorSetForceUnlockedMethod != null && cachedInputManagerEnableModeMethod != null && cachedInputManagerDisableModeMethod != null && cachedInputModePausedValue != null)
				{
					break;
				}
			}
		}
		catch
		{
		}
	}

	private void ApplyCursorUnlockForSettings(bool unlock)
	{
		if (!settingsInputReflectionInitialized)
		{
			InitializeSettingsInputReflection();
		}
		if (cachedCursorSetForceUnlockedMethod == null)
		{
			return;
		}
		try
		{
			cachedCursorSetForceUnlockedMethod.Invoke(null, new object[1] { unlock });
		}
		catch
		{
		}
	}

	private void ApplyGameInputSuppressionForSettings(bool suppress)
	{
		if (!settingsInputReflectionInitialized)
		{
			InitializeSettingsInputReflection();
		}
		if (cachedInputModePausedValue == null)
		{
			return;
		}
		try
		{
			if (suppress)
			{
				if (cachedInputManagerEnableModeMethod != null)
				{
					cachedInputManagerEnableModeMethod.Invoke(null, new object[1] { cachedInputModePausedValue });
				}
			}
			else if (cachedInputManagerDisableModeMethod != null)
			{
				cachedInputManagerDisableModeMethod.Invoke(null, new object[1] { cachedInputModePausedValue });
			}
		}
		catch
		{
		}
	}

	private void CreateSettingsPanelUi(Transform parent)
	{
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Expected O, but got Unknown
		//IL_0047: Unknown result type (might be due to invalid IL or missing references)
		//IL_005c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0071: Unknown result type (might be due to invalid IL or missing references)
		//IL_0085: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
		//IL_010f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0124: Unknown result type (might be due to invalid IL or missing references)
		//IL_012f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0143: Unknown result type (might be due to invalid IL or missing references)
		//IL_0175: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
		//IL_01bb: 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)
		//IL_01e5: 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_021c: Unknown result type (might be due to invalid IL or missing references)
		//IL_024e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0263: Unknown result type (might be due to invalid IL or missing references)
		//IL_0278: Unknown result type (might be due to invalid IL or missing references)
		//IL_0282: Unknown result type (might be due to invalid IL or missing references)
		//IL_02af: 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_02d9: Unknown result type (might be due to invalid IL or missing references)
		//IL_02ee: Unknown result type (might be due to invalid IL or missing references)
		//IL_02f8: Unknown result type (might be due to invalid IL or missing references)
		//IL_031c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0348: Unknown result type (might be due to invalid IL or missing references)
		//IL_035d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0372: Unknown result type (might be due to invalid IL or missing references)
		//IL_0387: Unknown result type (might be due to invalid IL or missing references)
		//IL_039b: Unknown result type (might be due to invalid IL or missing references)
		//IL_03be: Unknown result type (might be due to invalid IL or missing references)
		//IL_03e0: Unknown result type (might be due to invalid IL or missing references)
		//IL_03eb: Unknown result type (might be due to invalid IL or missing references)
		//IL_0400: Unknown result type (might be due to invalid IL or missing references)
		//IL_040a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0437: Unknown result type (might be due to invalid IL or missing references)
		//IL_0464: Unknown result type (might be due to invalid IL or missing references)
		//IL_046f: Unknown result type (might be due to invalid IL or missing references)
		//IL_047a: Unknown result type (might be due to invalid IL or missing references)
		//IL_048e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0594: Unknown result type (might be due to invalid IL or missing references)
		//IL_05a9: Unknown result type (might be due to invalid IL or missing references)
		//IL_05be: Unknown result type (might be due to invalid IL or missing references)
		//IL_05e8: Unknown result type (might be due to invalid IL or missing references)
		//IL_05f9: Unknown result type (might be due to invalid IL or missing references)
		//IL_0619: Unknown result type (might be due to invalid IL or missing references)
		//IL_0623: Expected O, but got Unknown
		//IL_0656: Unknown result type (might be due to invalid IL or missing references)
		//IL_066b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0680: Unknown result type (might be due to invalid IL or missing references)
		//IL_0695: Unknown result type (might be due to invalid IL or missing references)
		//IL_06a9: Unknown result type (might be due to invalid IL or missing references)
		//IL_06df: Unknown result type (might be due to invalid IL or missing references)
		//IL_06f1: Unknown result type (might be due to invalid IL or missing references)
		//IL_06f6: Unknown result type (might be due to invalid IL or missing references)
		//IL_06fa: Unknown result type (might be due to invalid IL or missing references)
		//IL_071a: Unknown result type (might be due to invalid IL or missing references)
		//IL_073a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0751: Unknown result type (might be due to invalid IL or missing references)
		//IL_076c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0776: Expected O, but got Unknown
		//IL_078f: Unknown result type (might be due to invalid IL or missing references)
		//IL_079a: Unknown result type (might be due to invalid IL or missing references)
		//IL_07a5: Unknown result type (might be due to invalid IL or missing references)
		//IL_07af: Unknown result type (might be due to invalid IL or missing references)
		//IL_07e9: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)settingsPanelObject != (Object)null)
		{
			return;
		}
		settingsPanelObject = new GameObject("BirdieSettingsPanel");
		settingsPanelObject.transform.SetParent(parent, false);
		RectTransform obj = settingsPanelObject.AddComponent<RectTransform>();
		obj.anchorMin = new Vector2(0.5f, 0.5f);
		obj.anchorMax = new Vector2(0.5f, 0.5f);
		obj.pivot = new Vector2(0.5f, 0.5f);
		obj.sizeDelta = new Vector2(640f, 440f);
		settingsPanelObject.AddComponent<CanvasGroup>();
		SetRounded(settingsPanelObject.AddComponent<Image>(), GetRoundedSprite(ref s_roundedLg, 64, 12), new Color(0.1f, 0.1f, 0.13f, 0.96f));
		GameObject val = CreateUiObject("Sidebar", settingsPanelObject.transform);
		RectTransform component = val.GetComponent<RectTransform>();
		component.anchorMin = new Vector2(0f, 0f);
		component.anchorMax = new Vector2(0f, 1f);
		component.pivot = new Vector2(0f, 0.5f);
		component.offsetMin = Vector2.zero;
		component.offsetMax = new Vector2(60f, 0f);
		SetRounded(val.AddComponent<Image>(), GetRoundedSprite(ref s_roundedLg, 64, 12), new Color(0.07f, 0.07f, 0.09f, 1f));
		GameObject obj2 = CreateUiObject("SidebarSep", settingsPanelObject.transform);
		RectTransform component2 = obj2.GetComponent<RectTransform>();
		component2.anchorMin = new Vector2(0f, 0f);
		component2.anchorMax = new Vector2(0f, 1f);
		component2.pivot = new Vector2(0f, 0.5f);
		component2.offsetMin = new Vector2(59f, 4f);
		component2.offsetMax = new Vector2(60f, -4f);
		((Graphic)obj2.AddComponent<Image>()).color = new Color(1f, 1f, 1f, 0.06f);
		GameObject val2 = CreateUiObject("MainArea", settingsPanelObject.transform);
		RectTransform component3 = val2.GetComponent<RectTransform>();
		component3.anchorMin = new Vector2(0f, 0f);
		component3.anchorMax = new Vector2(1f, 1f);
		component3.offsetMin = new Vector2(60f, 0f);
		component3.offsetMax = Vector2.zero;
		GameObject val3 = CreateUiObject("TitleBar", val2.transform);
		RectTransform component4 = val3.GetComponent<RectTransform>();
		component4.anchorMin = new Vector2(0f, 1f);
		component4.anchorMax = new Vector2(1f, 1f);
		component4.pivot = new Vector2(0.5f, 1f);
		component4.offsetMin = new Vector2(0f, -36f);
		component4.offsetMax = Vector2.zero;
		((Graphic)val3.AddComponent<Image>()).color = new Color(0.08f, 0.08f, 0.1f, 1f);
		GameObject obj3 = CreateUiObject("TitleSep", val3.transform);
		RectTransform component5 = obj3.GetComponent<RectTransform>();
		component5.anchorMin = new Vector2(0f, 0f);
		component5.anchorMax = new Vector2(1f, 0f);
		component5.pivot = new Vector2(0.5f, 0f);
		component5.offsetMin = new Vector2(0f, 0f);
		component5.offsetMax = new Vector2(0f, 1f);
		((Graphic)obj3.AddComponent<Image>()).color = new Color(1f, 1f, 1f, 0.06f);
		GameObject obj4 = CreateUiObject("TitleLabel", val3.transform);
		RectTransform component6 = obj4.GetComponent<RectTransform>();
		component6.anchorMin = Vector2.zero;
		component6.anchorMax = Vector2.one;
		component6.offsetMin = new Vector2(10f, 0f);
		component6.offsetMax = Vector2.zero;
		TextMeshProUGUI obj5 = obj4.AddComponent<TextMeshProUGUI>();
		((TMP_Text)obj5).text = "Birdie Settings";
		((TMP_Text)obj5).fontSize = 15f;
		((TMP_Text)obj5).fontStyle = (FontStyles)1;
		((Graphic)obj5).color = Color.white;
		((TMP_Text)obj5).alignment = (TextAlignmentOptions)4097;
		GameObject val4 = CreateUiObject("ContentArea", val2.transform);
		RectTransform component7 = val4.GetComponent<RectTransform>();
		component7.anchorMin = Vector2.zero;
		component7.anchorMax = Vector2.one;
		component7.offsetMin = Vector2.zero;
		component7.offsetMax = new Vector2(0f, -36f);
		settingsV2TabPanels = (GameObject[])(object)new GameObject[5];
		settingsV2TabPanels[0] = BuildFeaturesTab(val4.transform);
		settingsV2TabPanels[1] = BuildKeybindsTab(val4.transform);
		settingsV2TabPanels[2] = BuildHudTab(val4.transform);
		settingsV2TabPanels[3] = BuildCreditsTab(val4.transform);
		settingsV2TabPanels[4] = BuildItemsTab(val4.transform);
		settingsV2NavButtons = (Button[])(object)new Button[5];
		string[] array = new string[5] { "Features", "Keys", "HUD", "$", "Items" };
		for (int i = 0; i < 5; i++)
		{
			int capturedIndex = i;
			RectTransform component8 = CreateSidebarNavButton(val.transform, array[i], i, out settingsV2NavButtons[i]).GetComponent<RectTransform>();
			component8.anchorMin = new Vector2(0f, 1f);
			component8.anchorMax = new Vector2(1f, 1f);
			component8.pivot = new Vector2(0.5f, 1f);
			float num = 0f - (4f + (float)i * 56f);
			component8.offsetMin = new Vector2(2f, num - 52f);
			component8.offsetMax = new Vector2(-2f, num);
			((UnityEvent)settingsV2NavButtons[i].onClick).AddListener((UnityAction)delegate
			{
				SetSettingsV2Tab(capturedIndex);
			});
		}
		GameObject val5 = CreateUiObject("CloseBtn", val.transform);
		RectTransform component9 = val5.GetComponent<RectTransform>();
		component9.anchorMin = new Vector2(0f, 0f);
		component9.anchorMax = new Vector2(1f, 0f);
		component9.pivot = new Vector2(0.5f, 0f);
		component9.offsetMin = new Vector2(2f, 4f);
		component9.offsetMax = new Vector2(-2f, 44f);
		Image val6 = val5.AddComponent<Image>();
		SetRounded(val6, GetRoundedSprite(ref s_roundedMd, 48, 8), new Color(0.55f, 0.12f, 0.12f, 0.9f));
		Button obj6 = val5.AddComponent<Button>();
		ColorBlock colors = ((Selectable)obj6).colors;
		((ColorBlock)(ref colors)).normalColor = Color.white;
		((ColorBlock)(ref colors)).highlightedColor = new Color(1.1f, 0.85f, 0.85f, 1f);
		((ColorBlock)(ref colors)).pressedColor = new Color(0.85f, 0.7f, 0.7f, 1f);
		((ColorBlock)(ref colors)).fadeDuration = 0.08f;
		((Selectable)obj6).colors = colors;
		((Selectable)obj6).targetGraphic = (Graphic)(object)val6;
		((UnityEvent)obj6.onClick).AddListener(new UnityAction(CloseSettingsMenu));
		GameObject obj7 = CreateUiObject("CloseLbl", val5.transform);
		RectTransform component10 = obj7.GetComponent<RectTransform>();
		component10.anchorMin = Vector2.zero;
		component10.anchorMax = Vector2.one;
		component10.offsetMin = Vector2.zero;
		component10.offsetMax = Vector2.zero;
		TextMeshProUGUI obj8 = obj7.AddComponent<TextMeshProUGUI>();
		((TMP_Text)obj8).text = "✕";
		((TMP_Text)obj8).fontSize = 16f;
		((Graphic)obj8).color = new Color(1f, 0.4f, 0.4f, 1f);
		((TMP_Text)obj8).alignment = (TextAlignmentOptions)514;
		settingsPanelObject.SetActive(false);
		SetSettingsV2Tab(settingsTabIndex);
	}

	private GameObject CreateUiObject(string name, Transform parent)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Expected O, but got Unknown
		GameObject val = new GameObject(name);
		val.transform.SetParent(parent, false);
		val.AddComponent<RectTransform>();
		return val;
	}

	private GameObject CreateSidebarNavButton(Transform parent, string labelText, int index, out Button buttonOut)
	{
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_0033: Unknown result type (might be due to invalid IL or missing references)
		//IL_0038: Unknown result type (might be due to invalid IL or missing references)
		//IL_003b: Unknown result type (might be due to invalid IL or missing references)
		//IL_005b: Unknown result type (might be due to invalid IL or missing references)
		//IL_007b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0092: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
		//IL_010a: Unknown result type (might be due to invalid IL or missing references)
		//IL_012e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0156: 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_016c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0176: Unknown result type (might be due to invalid IL or missing references)
		//IL_019f: Unknown result type (might be due to invalid IL or missing references)
		GameObject val = CreateUiObject("NavBtn_" + index, parent);
		Image val2 = val.AddComponent<Image>();
		((Graphic)val2).color = Color.clear;
		Button val3 = val.AddComponent<Button>();
		ColorBlock colors = ((Selectable)val3).colors;
		((ColorBlock)(ref colors)).normalColor = Color.clear;
		((ColorBlock)(ref colors)).highlightedColor = new Color(0.22f, 0.47f, 0.85f, 0.15f);
		((ColorBlock)(ref colors)).pressedColor = new Color(0.22f, 0.47f, 0.85f, 0.3f);
		((ColorBlock)(ref colors)).fadeDuration = 0.08f;
		((Selectable)val3).colors = colors;
		((Selectable)val3).targetGraphic = (Graphic)(object)val2;
		GameObject obj = CreateUiObject("ActiveBar", val.transform);
		RectTransform component = obj.GetComponent<RectTransform>();
		component.anchorMin = new Vector2(0f, 0f);
		component.anchorMax = new Vector2(0f, 1f);
		component.pivot = new Vector2(0f, 0.5f);
		component.offsetMin = Vector2.zero;
		component.offsetMax = new Vector2(4f, 0f);
		((Graphic)obj.AddComponent<Image>()).color = new Color(0.22f, 0.47f, 0.85f, 1f);
		obj.SetActive(false);
		GameObject obj2 = CreateUiObject("NavLbl", val.transform);
		RectTransform component2 = obj2.GetComponent<RectTransform>();
		component2.anchorMin = Vector2.zero;
		component2.anchorMax = Vector2.one;
		component2.offsetMin = Vector2.zero;
		component2.offsetMax = Vector2.zero;
		TextMeshProUGUI obj3 = obj2.AddComponent<TextMeshProUGUI>();
		((TMP_Text)obj3).text = labelText;
		((TMP_Text)obj3).fontSize = 11f;
		((TMP_Text)obj3).fontStyle = (FontStyles)1;
		((Graphic)obj3).color = Color.white;
		((TMP_Text)obj3).alignment = (TextAlignmentOptions)514;
		((TMP_Text)obj3).enableWordWrapping = false;
		buttonOut = val3;
		return val;
	}

	private void SetSettingsV2Tab(int tabIndex)
	{
		settingsTabIndex = tabIndex;
		if (settingsV2TabPanels != null)
		{
			for (int i = 0; i < settingsV2TabPanels.Length; i++)
			{
				if ((Object)(object)settingsV2TabPanels[i] != (Object)null)
				{
					settingsV2TabPanels[i].SetActive(i == tabIndex);
				}
			}
		}
		RefreshSidebarButtonStates();
	}

	private void RefreshSidebarButtonStates()
	{
		//IL_0077: Unknown result type (might be due to invalid IL or missing references)
		//IL_005c: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
		if (settingsV2NavButtons == null)
		{
			return;
		}
		for (int i = 0; i < settingsV2NavButtons.Length; i++)
		{
			if (!((Object)(object)settingsV2NavButtons[i] == (Object)null))
			{
				bool flag = i == settingsTabIndex;
				Image component = ((Component)settingsV2NavButtons[i]).GetComponent<Image>();
				if ((Object)(object)component != (Object)null)
				{
					((Graphic)component).color = (flag ? new Color(0.22f, 0.5f, 0.9f, 0.22f) : new Color(1f, 1f, 1f, 0f));
				}
				Transform val = ((Component)settingsV2NavButtons[i]).transform.Find("ActiveBar");
				if ((Object)(object)val != (Object)null)
				{
					((Component)val).gameObject.SetActive(flag);
				}
				TextMeshProUGUI componentInChildren = ((Component)settingsV2NavButtons[i]).GetComponentInChildren<TextMeshProUGUI>();
				if ((Object)(object)componentInChildren != (Object)null)
				{
					((Graphic)componentInChildren).color = (flag ? new Color(0.55f, 0.8f, 1f, 1f) : new Color(0.75f, 0.75f, 0.8f, 1f));
				}
			}
		}
	}

	private GameObject BuildFeaturesTab(Transform contentParent)
	{
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0034: Unknown result type (might be due to invalid IL or missing references)
		//IL_0075: Unknown result type (might be due to invalid IL or missing references)
		//IL_008a: Unknown result type (might be due to invalid IL or missing references)
		//IL_009f: Unknown result type (might be due to invalid IL or missing references)
		//IL_00be: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
		GameObject val = CreateUiObject("Tab_Features", contentParent);
		RectTransform component = val.GetComponent<RectTransform>();
		component.anchorMin = Vector2.zero;
		component.anchorMax = Vector2.one;
		component.offsetMin = Vector2.zero;
		component.offsetMax = Vector2.zero;
		float num = -10f;
		float num2 = 60f;
		float spacing = 8f;
		GameObject val2 = CreateCard(val.transform, "Feature Toggles");
		RectTransform component2 = val2.GetComponent<RectTransform>();
		component2.anchorMin = new Vector2(0f, 1f);
		component2.anchorMax = new Vector2(1f, 1f);
		component2.pivot = new Vector2(0.5f, 1f);
		component2.offsetMin = new Vector2(10f, num - (num2 * 13f + 50f));
		component2.offsetMax = new Vector2(-10f, num);
		Transform val3 = val2.transform.Find("Content");
		if ((Object)(object)val3 == (Object)null)
		{
			val3 = val2.transform;
		}
		CreatePillToggle(val3, "Ice Immunity", iceImmunityEnabled, delegate
		{
			ToggleIceImmunity();
		}, out var _, () => iceImmunityEnabled);
		PositionPillRow(val3, 0, num2, spacing);
		AddPillRowSubtitle(val3, "Slide on ice like normal [I]");
		CreatePillToggle(val3, "Shot Tracer", tracersEnabled, delegate
		{
			tracersEnabled = !tracersEnabled;
			SaveCurrentConfig();
			MarkTrailVisualSettingsDirty();
			MarkHudDirty();
		}, out var _, () => tracersEnabled);
		PositionPillRow(val3, 1, num2, spacing);
		AddPillRowSubtitle(val3, "Shows ball's actual flight path");
		CreatePillToggle(val3, "Assist", assistEnabled, delegate
		{
			ToggleAssist();
		}, out var _, () => assistEnabled);
		PositionPillRow(val3, 2, num2, spacing);
		AddPillRowSubtitle(val3, "Auto-aims and releases at perfect moment [F]");
		CreatePillToggle(val3, "Impact Preview", impactPreviewEnabled, delegate
		{
			impactPreviewEnabled = !impactPreviewEnabled;
			SaveCurrentConfig();
		}, out var _, () => impactPreviewEnabled);
		PositionPillRow(val3, 3, num2, spacing);
		AddPillRowSubtitle(val3, "Preview where your shot will land");
		CreatePillToggle(val3, "No Wind", noWindEnabled, delegate
		{
			ToggleNoWind();
		}, out var _, () => noWindEnabled);
		PositionPillRow(val3, 4, num2, spacing);
		AddPillRowSubtitle(val3, "Removes wind from your ball [F7]");
		CreatePillToggle(val3, "Perfect Shot", perfectShotEnabled, delegate
		{
			TogglePerfectShot();
		}, out var _, () => perfectShotEnabled);
		PositionPillRow(val3, 5, num2, spacing);
		AddPillRowSubtitle(val3, "Forces swing into perfect zone [F8]");
		CreatePillToggle(val3, "No Air Drag", noAirDragEnabled, delegate
		{
			ToggleNoAirDrag();
		}, out var _, () => noAirDragEnabled);
		PositionPillRow(val3, 6, num2, spacing);
		AddPillRowSubtitle(val3, "Removes air resistance from ball [F9]");
		CreatePillToggle(val3, "Speed Boost", speedMultiplierEnabled, delegate
		{
			ToggleSpeedMultiplier();
		}, out var _, () => speedMultiplierEnabled);
		PositionPillRow(val3, 7, num2, spacing);
		AddPillRowSubtitle(val3, "2x movement speed [F10]");
		CreatePillToggle(val3, "Infinite Item Usage", infiniteAmmoEnabled, delegate
		{
			ToggleInfiniteAmmo();
		}, out var _, () => infiniteAmmoEnabled);
		PositionPillRow(val3, 8, num2, spacing);
		AddPillRowSubtitle(val3, "Weapons never run out of ammo [F11]");
		CreatePillToggle(val3, "No Recoil", noRecoilEnabled, delegate
		{
			ToggleNoRecoil();
		}, out var _, () => noRecoilEnabled);
		PositionPillRow(val3, 9, num2, spacing);
		AddPillRowSubtitle(val3, "Removes screen shake on fire [F12]");
		CreatePillToggle(val3, "No Knockback", noKnockbackEnabled, delegate
		{
			ToggleNoKnockback();
		}, out var _, () => noKnockbackEnabled);
		PositionPillRow(val3, 10, num2, spacing);
		AddPillRowSubtitle(val3, "Prevents force from weapons hitting you [N]");
		CreatePillToggle(val3, "Landmine Immunity", landmineImmunityEnabled, delegate
		{
			ToggleLandmineImmunity();
		}, out var _, () => landmineImmunityEnabled);
		PositionPillRow(val3, 11, num2, spacing);
		AddPillRowSubtitle(val3, "Walk over landmines safely [M]");
		CreatePillToggle(val3, "Lock-On Any Dist.", lockOnAnyDistanceEnabled, delegate
		{
			ToggleLockOnAnyDistance();
		}, out var _, () => lockOnAnyDistanceEnabled);
		PositionPillRow(val3, 12, num2, spacing);
		AddPillRowSubtitle(val3, "Lock-on works at any range [L]");
		return val;
	}

	private void AddPillRowSubtitle(Transform cardContent, string subtitleText)
	{
		//IL_0037: Unknown result type (might be due to invalid IL or missing references)
		//IL_004c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0061: Unknown result type (might be due to invalid IL or missing references)
		//IL_0075: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
		int childCount = cardContent.childCount;
		if (childCount != 0)
		{
			Transform child = cardContent.GetChild(childCount - 1);
			GameObject obj = CreateUiObject("Subtitle", ((Component)child).transform);
			RectTransform component = obj.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0f, 0f);
			component.anchorMax = new Vector2(0.75f, 0.45f);
			component.offsetMin = new Vector2(8f, 0f);
			component.offsetMax = new Vector2(0f, 0f);
			TextMeshProUGUI obj2 = obj.AddComponent<TextMeshProUGUI>();
			((TMP_Text)obj2).text = subtitleText;
			((TMP_Text)obj2).fontSize = 9f;
			((Graphic)obj2).color = new Color(0.6f, 0.6f, 0.68f, 1f);
			((TMP_Text)obj2).alignment = (TextAlignmentOptions)1025;
		}
	}

	private void PositionPillRow(Transform parent, int rowIndex, float rowHeight, float spacing)
	{
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0053: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_007b: Unknown result type (might be due to invalid IL or missing references)
		//IL_008c: Unknown result type (might be due to invalid IL or missing references)
		int childCount = parent.childCount;
		if (childCount != 0)
		{
			RectTransform component = ((Component)parent.GetChild(childCount - 1)).GetComponent<RectTransform>();
			if (!((Object)(object)component == (Object)null))
			{
				float num = 0f - ((float)rowIndex * (rowHeight + spacing) + 32f);
				component.anchorMin = new Vector2(0f, 1f);
				component.anchorMax = new Vector2(1f, 1f);
				component.pivot = new Vector2(0.5f, 1f);
				component.offsetMin = new Vector2(10f, num - rowHeight);
				component.offsetMax = new Vector2(-10f, num);
			}
		}
	}

	private GameObject CreateCard(Transform parent, string title)
	{
		//IL_003a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0066: Unknown result type (might be due to invalid IL or missing references)
		//IL_007b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0090: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
		//IL_0108: Unknown result type (might be due to invalid IL or missing references)
		//IL_011d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0132: Unknown result type (might be due to invalid IL or missing references)
		//IL_0147: Unknown result type (might be due to invalid IL or missing references)
		//IL_015b: Unknown result type (might be due to invalid IL or missing references)
		//IL_019d: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
		//IL_01de: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
		//IL_0207: Unknown result type (might be due to invalid IL or missing references)
		GameObject val = CreateUiObject("Card_" + title, parent);
		SetRounded(val.AddComponent<Image>(), GetRoundedSprite(ref s_roundedMd, 48, 8), new Color(0.17f, 0.17f, 0.21f, 1f));
		GameObject obj = CreateUiObject("CardAccent", val.transform);
		RectTransform component = obj.GetComponent<RectTransform>();
		component.anchorMin = new Vector2(0f, 1f);
		component.anchorMax = new Vector2(1f, 1f);
		component.pivot = new Vector2(0.5f, 1f);
		component.offsetMin = new Vector2(8f, -2f);
		component.offsetMax = new Vector2(-8f, 0f);
		((Graphic)obj.AddComponent<Image>()).color = new Color(0.22f, 0.5f, 0.9f, 0.3f);
		GameObject obj2 = CreateUiObject("CardTitle", val.transform);
		RectTransform component2 = obj2.GetComponent<RectTransform>();
		component2.anchorMin = new Vector2(0f, 1f);
		component2.anchorMax = new Vector2(1f, 1f);
		component2.pivot = new Vector2(0.5f, 1f);
		component2.offsetMin = new Vector2(10f, -28f);
		component2.offsetMax = new Vector2(-10f, 0f);
		TextMeshProUGUI obj3 = obj2.AddComponent<TextMeshProUGUI>();
		((TMP_Text)obj3).text = title.ToUpper();
		((TMP_Text)obj3).fontSize = 10f;
		((TMP_Text)obj3).fontStyle = (FontStyles)1;
		((Graphic)obj3).color = new Color(0.55f, 0.55f, 0.62f, 1f);
		((TMP_Text)obj3).characterSpacing = 1.5f;
		((TMP_Text)obj3).alignment = (TextAlignmentOptions)4097;
		RectTransform component3 = CreateUiObject("Content", val.transform).GetComponent<RectTransform>();
		component3.anchorMin = Vector2.zero;
		component3.anchorMax = Vector2.one;
		component3.offsetMin = new Vector2(0f, 0f);
		component3.offsetMax = new Vector2(0f, -28f);
		return val;
	}

	private void CreatePillToggle(Transform parent, string label, bool initialValue, Action onToggle, out Image pillBgOut, Func<bool> valueGetter)
	{
		//IL_0049: 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_0073: Unknown result type (might be due to invalid IL or missing references)
		//IL_0087: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
		//IL_010a: Unknown result type (might be due to invalid IL or missing references)
		//IL_011f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0133: Unknown result type (might be due to invalid IL or missing references)
		//IL_0185: Unknown result type (might be due to invalid IL or missing references)
		//IL_016a: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ce: 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_01fa: Unknown result type (might be due to invalid IL or missing references)
		//IL_0224: Unknown result type (might be due to invalid IL or missing references)
		//IL_0213: Unknown result type (might be due to invalid IL or missing references)
		//IL_0241: Unknown result type (might be due to invalid IL or missing references)
		//IL_0252: Unknown result type (might be due to invalid IL or missing references)
		//IL_0257: Unknown result type (might be due to invalid IL or missing references)
		//IL_025b: Unknown result type (might be due to invalid IL or missing references)
		//IL_027b: Unknown result type (might be due to invalid IL or missing references)
		//IL_029b: Unknown result type (might be due to invalid IL or missing references)
		//IL_02b2: Unknown result type (might be due to invalid IL or missing references)
		//IL_02eb: Unknown result type (might be due to invalid IL or missing references)
		//IL_02f5: Expected O, but got Unknown
		GameObject val = CreateUiObject("PillRow_" + label, parent);
		val.AddComponent<RectTransform>();
		GameObject obj = CreateUiObject("PillLabel", val.transform);
		RectTransform component = obj.GetComponent<RectTransform>();
		component.anchorMin = new Vector2(0f, 0f);
		component.anchorMax = new Vector2(1f, 1f);
		component.offsetMin = new Vector2(8f, 0f);
		component.offsetMax = new Vector2(-60f, 0f);
		TextMeshProUGUI obj2 = obj.AddComponent<TextMeshProUGUI>();
		((TMP_Text)obj2).text = label;
		((TMP_Text)obj2).fontSize = 13f;
		((Graphic)obj2).color = Color.white;
		((TMP_Text)obj2).alignment = (TextAlignmentOptions)4097;
		GameObject val2 = CreateUiObject("Pill", val.transform);
		RectTransform component2 = val2.GetComponent<RectTransform>();
		component2.anchorMin = new Vector2(1f, 0.5f);
		component2.anchorMax = new Vector2(1f, 0.5f);
		component2.pivot = new Vector2(1f, 0.5f);
		component2.sizeDelta = new Vector2(40f, 22f);
		component2.anchoredPosition = new Vector2(-8f, 0f);
		Image val3 = val2.AddComponent<Image>();
		SetRounded(val3, GetRoundedSprite(ref s_pillSprite, 44, 22), initialValue ? new Color(0.22f, 0.5f, 0.9f, 1f) : new Color(0.28f, 0.28f, 0.33f, 1f));
		pillBgOut = val3;
		GameObject obj3 = CreateUiObject("Knob", val2.transform);
		RectTransform component3 = obj3.GetComponent<RectTransform>();
		component3.anchorMin = new Vector2(0f, 0.5f);
		component3.anchorMax = new Vector2(0f, 0.5f);
		component3.pivot = new Vector2(0.5f, 0.5f);
		component3.sizeDelta = new Vector2(18f, 18f);
		component3.anchoredPosition = (initialValue ? new Vector2(29f, 0f) : new Vector2(11f, 0f));
		SetRounded(obj3.AddComponent<Image>(), GetRoundedSprite(ref s_circleSprite, 36, 18), Color.white);
		Button obj4 = val2.AddComponent<Button>();
		ColorBlock colors = ((Selectable)obj4).colors;
		((ColorBlock)(ref colors)).normalColor = Color.white;
		((ColorBlock)(ref colors)).highlightedColor = new Color(0.9f, 0.9f, 0.9f, 1f);
		((ColorBlock)(ref colors)).pressedColor = new Color(0.8f, 0.8f, 0.8f, 1f);
		((ColorBlock)(ref colors)).fadeDuration = 0.08f;
		((Selectable)obj4).colors = colors;
		((Selectable)obj4).targetGraphic = (Graphic)(object)val3;
		Image capturedPillBg = val3;
		RectTransform capturedKnobRect = component3;
		Func<bool> capturedGetter = valueGetter;
		Action capturedToggle = onToggle;
		((UnityEvent)obj4.onClick).AddListener((UnityAction)delegate
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			capturedToggle();
			bool num = capturedGetter();
			float targetX = (num ? 29f : 11f);
			Color targetColor = (num ? new Color(0.22f, 0.5f, 0.9f, 1f) : new Color(0.28f, 0.28f, 0.33f, 1f));
			BirdieCoroutine.Start(AnimatePillSlide(capturedKnobRect, capturedPillBg, targetX, targetColor));
		});
	}

	private GameObject BuildKeybindsTab(Transform contentParent)
	{
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0034: Unknown result type (might be due to invalid IL or missing references)
		//IL_0061: Unknown result type (might be due to invalid IL or missing references)
		//IL_0076: Unknown result type (might be due to invalid IL or missing references)
		//IL_008b: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
		//IL_0104: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
		//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
		//IL_022c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0241: Unknown result type (might be due to invalid IL or missing references)
		//IL_0246: Unknown result type (might be due to invalid IL or missing references)
		//IL_025e: Unknown result type (might be due to invalid IL or missing references)
		//IL_027e: Unknown result type (might be due to invalid IL or missing references)
		//IL_029e: Unknown result type (might be due to invalid IL or missing references)
		//IL_02c2: Unknown result type (might be due to invalid IL or missing references)
		//IL_02e1: Unknown result type (might be due to invalid IL or missing references)
		//IL_02eb: Expected O, but got Unknown
		//IL_0319: Unknown result type (might be due to invalid IL or missing references)
		//IL_032e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0343: Unknown result type (might be due to invalid IL or missing references)
		//IL_0357: Unknown result type (might be due to invalid IL or missing references)
		//IL_037a: Unknown result type (might be due to invalid IL or missing references)
		//IL_03b4: Unknown result type (might be due to invalid IL or missing references)
		//IL_03c9: Unknown result type (might be due to invalid IL or missing references)
		//IL_03de: Unknown result type (might be due to invalid IL or missing references)
		//IL_03f3: Unknown result type (might be due to invalid IL or missing references)
		//IL_0407: Unknown result type (might be due to invalid IL or missing references)
		//IL_0439: Unknown result type (might be due to invalid IL or missing references)
		//IL_045c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0467: Unknown result type (might be due to invalid IL or missing references)
		//IL_0472: Unknown result type (might be due to invalid IL or missing references)
		//IL_047c: Unknown result type (might be due to invalid IL or missing references)
		//IL_04ab: Unknown result type (might be due to invalid IL or missing references)
		//IL_0501: Unknown result type (might be due to invalid IL or missing references)
		//IL_0516: Unknown result type (might be due to invalid IL or missing references)
		//IL_052b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0545: Unknown result type (might be due to invalid IL or missing references)
		//IL_0558: Unknown result type (might be due to invalid IL or missing references)
		//IL_057b: Unknown result type (might be due to invalid IL or missing references)
		GameObject val = CreateUiObject("Tab_Keybinds", contentParent);
		RectTransform component = val.GetComponent<RectTransform>();
		component.anchorMin = Vector2.zero;
		component.anchorMax = Vector2.one;
		component.offsetMin = Vector2.zero;
		component.offsetMax = Vector2.zero;
		GameObject val2 = CreateUiObject("RebindStatus", val.transform);
		RectTransform component2 = val2.GetComponent<RectTransform>();
		component2.anchorMin = new Vector2(0f, 1f);
		component2.anchorMax = new Vector2(1f, 1f);
		component2.pivot = new Vector2(0.5f, 1f);
		component2.offsetMin = new Vector2(10f, -32f);
		component2.offsetMax = new Vector2(-10f, -4f);
		settingsKeybindRebindStatusLabel = val2.AddComponent<TextMeshProUGUI>();
		((TMP_Text)settingsKeybindRebindStatusLabel).text = "Click a binding to rebind";
		((TMP_Text)settingsKeybindRebindStatusLabel).fontSize = 12f;
		((Graphic)settingsKeybindRebindStatusLabel).color = new Color(0.65f, 0.65f, 0.72f, 1f);
		((TMP_Text)settingsKeybindRebindStatusLabel).alignment = (TextAlignmentOptions)4097;
		settingsKeybindRowButtons = (Button[])(object)new Button[SettingsKeybindDisplayNames.Length];
		float num = 34f;
		float num2 = 4f;
		for (int i = 0; i < SettingsKeybindDisplayNames.Length; i++)
		{
			int capturedIndex = i;
			string text = SettingsKeybindDisplayNames[i];
			GameObject val3 = CreateUiObject("KeybindRow_" + i, val.transform);
			RectTransform component3 = val3.GetComponent<RectTransform>();
			float num3 = 0f - (36f + (float)i * (num + num2));
			component3.anchorMin = new Vector2(0f, 1f);
			component3.anchorMax = new Vector2(1f, 1f);
			component3.pivot = new Vector2(0.5f, 1f);
			component3.offsetMin = new Vector2(10f, num3 - num);
			component3.offsetMax = new Vector2(-10f, num3);
			Image val4 = val3.AddComponent<Image>();
			SetRounded(val4, GetRoundedSprite(ref s_roundedSm, 32, 6), new Color(0.15f, 0.15f, 0.18f, 1f));
			Button val5 = val3.AddComponent<Button>();
			ColorBlock colors = ((Selectable)val5).colors;
			((ColorBlock)(ref colors)).normalColor = new Color(0.15f, 0.15f, 0.18f, 1f);
			((ColorBlock)(ref colors)).highlightedColor = new Color(0.2f, 0.22f, 0.28f, 1f);
			((ColorBlock)(ref colors)).pressedColor = new Color(0.22f, 0.47f, 0.85f, 0.25f);
			((ColorBlock)(ref colors)).colorMultiplier = 1f;
			((ColorBlock)(ref colors)).fadeDuration = 0.08f;
			((Selectable)val5).colors = colors;
			((Selectable)val5).targetGraphic = (Graphic)(object)val4;
			((UnityEvent)val5.onClick).AddListener((UnityAction)delegate
			{
				StartKeybindRebindForIndex(capturedIndex);
			});
			settingsKeybindRowButtons[i] = val5;
			GameObject obj = CreateUiObject("ActionLabel", val3.transform);
			RectTransform component4 = obj.GetComponent<RectTransform>();
			component4.anchorMin = new Vector2(0f, 0f);
			component4.anchorMax = new Vector2(1f, 1f);
			component4.offsetMin = new Vector2(10f, 0f);
			component4.offsetMax = new Vector2(-90f, 0f);
			TextMeshProUGUI obj2 = obj.AddComponent<TextMeshProUGUI>();
			((TMP_Text)obj2).text = text;
			((TMP_Text)obj2).fontSize = 13f;
			((Graphic)obj2).color = Color.white;
			((TMP_Text)obj2).alignment = (TextAlignmentOptions)4097;
			GameObject val6 = CreateUiObject("KeyBadge", val3.transform);
			RectTransform component5 = val6.GetComponent<RectTransform>();
			component5.anchorMin = new Vector2(1f, 0.5f);
			component5.anchorMax = new Vector2(1f, 0.5f);
			component5.pivot = new Vector2(1f, 0.5f);
			component5.sizeDelta = new Vector2(80f, 24f);
			component5.anchoredPosition = new Vector2(-6f, 0f);
			SetRounded(val6.AddComponent<Image>(), GetRoundedSprite(ref s_roundedSm, 32, 6), new Color(0.22f, 0.47f, 0.85f, 0.85f));
			GameObject obj3 = CreateUiObject("BadgeLabel", val6.transform);
			RectTransform component6 = obj3.GetComponent<RectTransform>();
			component6.anchorMin = Vector2.zero;
			component6.anchorMax = Vector2.one;
			component6.offsetMin = Vector2.zero;
			component6.offsetMax = Vector2.zero;
			TextMeshProUGUI obj4 = obj3.AddComponent<TextMeshProUGUI>();
			((TMP_Text)obj4).text = FormatKeyLabel(GetKeybindNameByIndex(i));
			((TMP_Text)obj4).fontSize = 11f;
			((Graphic)obj4).color = Color.white;
			((TMP_Text)obj4).alignment = (TextAlignmentOptions)514;
			if (i < SettingsKeybindDisplayNames.Length - 1)
			{
				GameObject obj5 = CreateUiObject("RowSep", val.transform);
				RectTransform component7 = obj5.GetComponent<RectTransform>();
				float num4 = 0f - (36f + (float)i * (num + num2));
				component7.anchorMin = new Vector2(0f, 1f);
				component7.anchorMax = new Vector2(1f, 1f);
				component7.pivot = new Vector2(0.5f, 1f);
				component7.offsetMin = new Vector2(10f, num4 - num - 1f);
				component7.offsetMax = new Vector2(-10f, num4 - num);
				((Graphic)obj5.AddComponent<Image>()).color = new Color(1f, 1f, 1f, 0.04f);
			}
		}
		return val;
	}

	private GameObject BuildHudTab(Transform contentParent)
	{
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0034: Unknown result type (might be due to invalid IL or missing references)
		//IL_0061: Unknown result type (might be due to invalid IL or missing references)
		//IL_0076: Unknown result type (might be due to invalid IL or missing references)
		//IL_008b: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
		GameObject val = CreateUiObject("Tab_HUD", contentParent);
		RectTransform component = val.GetComponent<RectTransform>();
		component.anchorMin = Vector2.zero;
		component.anchorMax = Vector2.one;
		component.offsetMin = Vector2.zero;
		component.offsetMax = Vector2.zero;
		GameObject val2 = CreateCard(val.transform, "HUD Visibility");
		RectTransform component2 = val2.GetComponent<RectTransform>();
		component2.anchorMin = new Vector2(0f, 1f);
		component2.anchorMax = new Vector2(1f, 1f);
		component2.pivot = new Vector2(0.5f, 1f);
		component2.offsetMin = new Vector2(10f, -358f);
		component2.offsetMax = new Vector2(-10f, -10f);
		Transform val3 = val2.transform.Find("Content");
		if ((Object)(object)val3 == (Object)null)
		{
			val3 = val2.transform;
		}
		settingsHudTogglePillBgs = (Image[])(object)new Image[6];
		float rowHeight = 44f;
		float spacing = 4f;
		string[] array = new string[6] { "Bottom keybind bar", "Ball distance to hole", "Ice immunity indicator", "Center title", "Player info (left)", "Shot tracers" };
		Func<bool>[] array2 = new Func<bool>[6]
		{
			() => hudShowBottomBar,
			() => hudShowBallDistance,
			() => hudShowIceIndicator,
			() => hudShowCenterTitle,
			() => hudShowPlayerInfo,
			() => tracersEnabled
		};
		Action[] array3 = new Action[6]
		{
			delegate
			{
				hudShowBottomBar = !hudShowBottomBar;
				SaveCurrentConfig();
				MarkHudDirty();
			},
			delegate
			{
				hudShowBallDistance = !hudShowBallDistance;
				SaveCurrentConfig();
				MarkHudDirty();
			},
			delegate
			{
				hudShowIceIndicator = !hudShowIceIndicator;
				SaveCurrentConfig();
				MarkHudDirty();
			},
			delegate
			{
				hudShowCenterTitle = !hudShowCenterTitle;
				SaveCurrentConfig();
				MarkHudDirty();
			},
			delegate
			{
				hudShowPlayerInfo = !hudShowPlayerInfo;
				SaveCurrentConfig();
				MarkHudDirty();
			},
			delegate
			{
				tracersEnabled = !tracersEnabled;
				SaveCurrentConfig();
				MarkTrailVisualSettingsDirty();
				MarkHudDirty();
			}
		};
		bool[] array4 = new bool[6] { hudShowBottomBar, hudShowBallDistance, hudShowIceIndicator, hudShowCenterTitle, hudShowPlayerInfo, tracersEnabled };
		for (int i = 0; i < 6; i++)
		{
			CreatePillToggle(val3, array[i], array4[i], array3[i], out var pillBgOut, array2[i]);
			settingsHudTogglePillBgs[i] = pillBgOut;
			PositionPillRow(val3, i, rowHeight, spacing);
		}
		return val;
	}

	private GameObject BuildCreditsTab(Transform contentParent)
	{
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0034: Unknown result type (might be due to invalid IL or missing references)
		//IL_0060: Unknown result type (might be due to invalid IL or missing references)
		//IL_0075: Unknown result type (might be due to invalid IL or missing references)
		//IL_008a: Unknown result type (might be due to invalid IL or missing references)
		//IL_009f: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
		//IL_012a: Unknown result type (might be due to invalid IL or missing references)
		//IL_013f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0154: 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_017d: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
		//IL_01da: 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_0204: Unknown result type (might be due to invalid IL or missing references)
		//IL_0219: Unknown result type (might be due to invalid IL or missing references)
		//IL_022d: Unknown result type (might be due to invalid IL or missing references)
		//IL_025e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0281: Unknown result type (might be due to invalid IL or missing references)
		//IL_028c: Unknown result type (might be due to invalid IL or missing references)
		//IL_02a1: Unknown result type (might be due to invalid IL or missing references)
		//IL_02b5: Unknown result type (might be due to invalid IL or missing references)
		//IL_02db: Unknown result type (might be due to invalid IL or missing references)
		//IL_02e7: Unknown result type (might be due to invalid IL or missing references)
		//IL_02f3: Unknown result type (might be due to invalid IL or missing references)
		//IL_02ff: Unknown result type (might be due to invalid IL or missing references)
		//IL_0321: Unknown result type (might be due to invalid IL or missing references)
		//IL_032c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0337: Unknown result type (might be due to invalid IL or missing references)
		//IL_0341: Unknown result type (might be due to invalid IL or missing references)
		//IL_0360: Unknown result type (might be due to invalid IL or missing references)
		//IL_03ef: Unknown result type (might be due to invalid IL or missing references)
		//IL_0404: Unknown result type (might be due to invalid IL or missing references)
		//IL_0419: Unknown result type (might be due to invalid IL or missing references)
		//IL_042e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0442: Unknown result type (might be due to invalid IL or missing references)
		//IL_0478: Unknown result type (might be due to invalid IL or missing references)
		//IL_048a: Unknown result type (might be due to invalid IL or missing references)
		//IL_048f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0493: Unknown result type (might be due to invalid IL or missing references)
		//IL_04b3: Unknown result type (might be due to invalid IL or missing references)
		//IL_04d3: Unknown result type (might be due to invalid IL or missing references)
		//IL_04ea: Unknown result type (might be due to invalid IL or missing references)
		//IL_0505: Unknown result type (might be due to invalid IL or missing references)
		//IL_050f: Expected O, but got Unknown
		//IL_0528: Unknown result type (might be due to invalid IL or missing references)
		//IL_0533: Unknown result type (might be due to invalid IL or missing references)
		//IL_053e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0548: Unknown result type (might be due to invalid IL or missing references)
		//IL_056e: Unknown result type (might be due to invalid IL or missing references)
		//IL_05a7: Unknown result type (might be due to invalid IL or missing references)
		//IL_05bc: Unknown result type (might be due to invalid IL or missing references)
		//IL_05d1: Unknown result type (might be due to invalid IL or missing references)
		//IL_05e6: Unknown result type (might be due to invalid IL or missing references)
		//IL_05fa: Unknown result type (might be due to invalid IL or missing references)
		//IL_0623: Unknown result type (might be due to invalid IL or missing references)
		//IL_0635: Unknown result type (might be due to invalid IL or missing references)
		//IL_063a: Unknown result type (might be due to invalid IL or missing references)
		//IL_063e: Unknown result type (might be due to invalid IL or missing references)
		//IL_065e: Unknown result type (might be due to invalid IL or missing references)
		//IL_067e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0695: Unknown result type (might be due to invalid IL or missing references)
		//IL_06f0: Unknown result type (might be due to invalid IL or missing references)
		//IL_06fb: Unknown result type (might be due to invalid IL or missing references)
		//IL_0706: Unknown result type (might be due to invalid IL or missing references)
		//IL_0710: Unknown result type (might be due to invalid IL or missing references)
		//IL_0738: Unknown result type (might be due to invalid IL or missing references)
		//IL_06bd: Unknown result type (might be due to invalid IL or missing references)
		//IL_06c2: Unknown result type (might be due to invalid IL or missing references)
		//IL_06c8: Expected O, but got Unknown
		GameObject val2 = CreateUiObject("Tab_Credits", contentParent);
		RectTransform component = val2.GetComponent<RectTransform>();
		component.anchorMin = Vector2.zero;
		component.anchorMax = Vector2.one;
		component.offsetMin = Vector2.zero;
		component.offsetMax = Vector2.zero;
		GameObject obj = CreateUiObject("InfoLabel", val2.transform);
		RectTransform component2 = obj.GetComponent<RectTransform>();
		component2.anchorMin = new Vector2(0f, 1f);
		component2.anchorMax = new Vector2(1f, 1f);
		component2.pivot = new Vector2(0.5f, 1f);
		component2.offsetMin = new Vector2(10f, -60f);
		component2.offsetMax = new Vector2(-10f, -10f);
		TextMeshProUGUI obj2 = obj.AddComponent<TextMeshProUGUI>();
		((TMP_Text)obj2).text = "Grant credits to yourself (client-local, no server sync)";
		((TMP_Text)obj2).fontSize = 13f;
		((Graphic)obj2).color = new Color(0.65f, 0.65f, 0.72f, 1f);
		((TMP_Text)obj2).alignment = (TextAlignmentOptions)4097;
		((TMP_Text)obj2).textWrappingMode = (TextWrappingModes)1;
		GameObject obj3 = CreateUiObject("AmountLabel", val2.transform);
		RectTransform component3 = obj3.GetComponent<RectTransform>();
		component3.anchorMin = new Vector2(0f, 1f);
		component3.anchorMax = new Vector2(0f, 1f);
		component3.pivot = new Vector2(0f, 1f);
		component3.offsetMin = new Vector2(10f, -100f);
		component3.offsetMax = new Vector2(110f, -70f);
		TextMeshProUGUI obj4 = obj3.AddComponent<TextMeshProUGUI>();
		((TMP_Text)obj4).text = "Amount:";
		((TMP_Text)obj4).fontSize = 13f;
		((Graphic)obj4).color = Color.white;
		((TMP_Text)obj4).alignment = (TextAlignmentOptions)4097;
		GameObject val3 = CreateUiObject("InputContainer", val2.transform);
		RectTransform component4 = val3.GetComponent<RectTransform>();
		component4.anchorMin = new Vector2(0f, 1f);
		component4.anchorMax = new Vector2(0f, 1f);
		component4.pivot = new Vector2(0f, 1f);
		component4.offsetMin = new Vector2(110f, -105f);
		component4.offsetMax = new Vector2(260f, -72f);
		SetRounded(val3.AddComponent<Image>(), GetRoundedSprite(ref s_roundedSm, 32, 6), new Color(0.12f, 0.12f, 0.16f, 1f));
		GameObject val4 = CreateUiObject("CreditsInput", val3.transform);
		RectTransform component5 = val4.GetComponent<RectTransform>();
		component5.anchorMin = Vector2.zero;
		component5.anchorMax = Vector2.one;
		component5.offsetMin = new Vector2(4f, 2f);
		component5.offsetMax = new Vector2(-4f, -2f);
		GameObject val5 = CreateUiObject("Text Area", val4.transform);
		RectTransform component6 = val5.GetComponent<RectTransform>();
		component6.anchorMin = Vector2.zero;
		component6.anchorMax = Vector2.one;
		component6.offsetMin = Vector2.zero;
		component6.offsetMax = Vector2.zero;
		GameObject obj5 = CreateUiObject("Text", val5.transform);
		RectTransform component7 = obj5.GetComponent<RectTransform>();
		component7.anchorMin = Vector2.zero;
		component7.anchorMax = Vector2.one;
		component7.offsetMin = Vector2.zero;
		component7.offsetMax = Vector2.zero;
		TextMeshProUGUI val6 = obj5.AddComponent<TextMeshProUGUI>();
		((TMP_Text)val6).fontSize = 13f;
		((Graphic)val6).color = Color.white;
		((TMP_Text)val6).alignment = (TextAlignmentOptions)4097;
		TMP_InputField val7 = val4.AddComponent<TMP_InputField>();
		val7.textComponent = (TMP_Text)(object)val6;
		val7.textViewport = component6;
		val7.contentType = (ContentType)2;
		val7.text = creditsGrantAmount.ToString();
		settingsCreditsInputField = val7;
		((UnityEvent<string>)(object)val7.onValueChanged).AddListener((UnityAction<string>)delegate(string val)
		{
			if (int.TryParse(val, out var result))
			{
				creditsGrantAmount = Mathf.Max(0, result);
				SaveCurrentConfig();
			}
		});
		GameObject val8 = CreateUiObject("GrantBtn", val2.transform);
		RectTransform component8 = val8.GetComponent<RectTransform>();
		component8.anchorMin = new Vector2(0f, 1f);
		component8.anchorMax = new Vector2(0f, 1f);
		component8.pivot = new Vector2(0f, 1f);
		component8.offsetMin = new Vector2(10f, -148f);
		component8.offsetMax = new Vector2(150f, -115f);
		Image val9 = val8.AddComponent<Image>();
		SetRounded(val9, GetRoundedSprite(ref s_roundedMd, 48, 8), new Color(0.22f, 0.5f, 0.9f, 1f));
		Button obj6 = val8.AddComponent<Button>();
		ColorBlock colors = ((Selectable)obj6).colors;
		((ColorBlock)(ref colors)).normalColor = Color.white;
		((ColorBlock)(ref colors)).highlightedColor = new Color(0.9f, 0.95f, 1f, 1f);
		((ColorBlock)(ref colors)).pressedColor = new Color(0.75f, 0.85f, 1f, 1f);
		((ColorBlock)(ref colors)).fadeDuration = 0.08f;
		((Selectable)obj6).colors = colors;
		((Selectable)obj6).targetGraphic = (Graphic)(object)val9;
		((UnityEvent)obj6.onClick).AddListener((UnityAction)delegate
		{
			GrantCredits(creditsGrantAmount);
		});
		GameObject obj7 = CreateUiObject("GrantLabel", val8.transform);
		RectTransform component9 = obj7.GetComponent<RectTransform>();
		component9.anchorMin = Vector2.zero;
		component9.anchorMax = Vector2.one;
		component9.offsetMin = Vector2.zero;
		component9.offsetMax = Vector2.zero;
		TextMeshProUGUI obj8 = obj7.AddComponent<TextMeshProUGUI>();
		((TMP_Text)obj8).text = "Grant Credits";
		((TMP_Text)obj8).fontSize = 13f;
		((Graphic)obj8).color = Color.white;
		((TMP_Text)obj8).alignment = (TextAlignmentOptions)514;
		GameObject val10 = CreateUiObject("DiscordBtn", val2.transform);
		RectTransform component10 = val10.GetComponent<RectTransform>();
		component10.anchorMin = new Vector2(0.1f, 0f);
		component10.anchorMax = new Vector2(0.9f, 0f);
		component10.pivot = new Vector2(0.5f, 0f);
		component10.offsetMin = new Vector2(0f, 12f);
		component10.offsetMax = new Vector2(0f, 52f);
		Image val11 = val10.AddComponent<Image>();
		((Graphic)val11).color = new Color(0.34f, 0.4f, 0.87f, 1f);
		Button obj9 = val10.AddComponent<Button>();
		ColorBlock colors2 = ((Selectable)obj9).colors;
		((ColorBlock)(ref colors2)).normalColor = Color.white;
		((ColorBlock)(ref colors2)).highlightedColor = new Color(0.9f, 0.9f, 1f, 1f);
		((ColorBlock)(ref colors2)).pressedColor = new Color(0.75f, 0.78f, 1f, 1f);
		((ColorBlock)(ref colors2)).fadeDuration = 0.08f;
		((Selectable)obj9).colors = colors2;
		((Selectable)obj9).targetGraphic = (Graphic)(object)val11;
		ButtonClickedEvent onClick = obj9.onClick;
		object obj10 = <>c.<>9__633_2;
		if (obj10 == null)
		{
			UnityAction val12 = delegate
			{
				Application.OpenURL("https://discord.gg/EaCRS6TBH9");
			};
			<>c.<>9__633_2 = val12;
			obj10 = (object)val12;
		}
		((UnityEvent)onClick).AddListener((UnityAction)obj10);
		TextMeshProUGUI obj11 = CreateUiObject("DiscordLabel", val10.transform).AddComponent<TextMeshProUGUI>();
		RectTransform component11 = ((Component)obj11).gameObject.GetComponent<RectTransform>();
		component11.anchorMin = Vector2.zero;
		component11.anchorMax = Vector2.one;
		component11.offsetMin = Vector2.zero;
		component11.offsetMax = Vector2.zero;
		((TMP_Text)obj11).text = "Join our Discord";
		((TMP_Text)obj11).fontSize = 13f;
		((TMP_Text)obj11).fontStyle = (FontStyles)1;
		((Graphic)obj11).color = Color.white;
		((TMP_Text)obj11).alignment = (TextAlignmentOptions)514;
		return val2;
	}

	private GameObject BuildItemsTab(Transform contentParent)
	{
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0034: Unknown result type (might be due to invalid IL or missing references)
		//IL_0061: Unknown result type (might be due to invalid IL or missing references)
		//IL_0076: Unknown result type (might be due to invalid IL or missing references)
		//IL_008b: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
		//IL_0127: 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_015b: Unknown result type (might be due to invalid IL or missing references)
		//IL_017a: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
		//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
		//IL_02ff: Unknown result type (might be due to invalid IL or missing references)
		//IL_0311: Unknown result type (might be due to invalid IL or missing references)
		//IL_0326: Unknown result type (might be due to invalid IL or missing references)
		//IL_033b: Unknown result type (might be due to invalid IL or missing references)
		//IL_034c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0375: Unknown result type (might be due to invalid IL or missing references)
		//IL_0387: Unknown result type (might be due to invalid IL or missing references)
		//IL_038c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0390: Unknown result type (might be due to invalid IL or missing references)
		//IL_03b0: Unknown result type (might be due to invalid IL or missing references)
		//IL_03d0: Unknown result type (might be due to invalid IL or missing references)
		//IL_03e7: Unknown result type (might be due to invalid IL or missing references)
		//IL_0403: Unknown result type (might be due to invalid IL or missing references)
		//IL_040d: Expected O, but got Unknown
		//IL_0430: Unknown result type (might be due to invalid IL or missing references)
		//IL_043b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0450: Unknown result type (might be due to invalid IL or missing references)
		//IL_0464: Unknown result type (might be due to invalid IL or missing references)
		//IL_0484: Unknown result type (might be due to invalid IL or missing references)
		GameObject val = CreateUiObject("Tab_Items", contentParent);
		RectTransform component = val.GetComponent<RectTransform>();
		component.anchorMin = Vector2.zero;
		component.anchorMax = Vector2.one;
		component.offsetMin = Vector2.zero;
		component.offsetMax = Vector2.zero;
		GameObject val2 = CreateUiObject("HostStatus", val.transform);
		RectTransform component2 = val2.GetComponent<RectTransform>();
		component2.anchorMin = new Vector2(0f, 1f);
		component2.anchorMax = new Vector2(1f, 1f);
		component2.pivot = new Vector2(0.5f, 1f);
		component2.offsetMin = new Vector2(10f, -42f);
		component2.offsetMax = new Vector2(-10f, -8f);
		Image obj = val2.AddComponent<Image>();
		bool flag = BirdieGrantBridge.IsReady();
		((Graphic)obj).color = (flag ? new Color(0.1f, 0.38f, 0.18f, 0.9f) : new Color(0.35f, 0.2f, 0.08f, 0.9f));
		TextMeshProUGUI obj2 = CreateUiObject("HostStatusText", val2.transform).AddComponent<TextMeshProUGUI>();
		((Component)obj2).gameObject.GetComponent<RectTransform>().anchorMin = Vector2.zero;
		((Component)obj2).gameObject.GetComponent<RectTransform>().anchorMax = Vector2.one;
		((Component)obj2).gameObject.GetComponent<RectTransform>().offsetMin = new Vector2(8f, 0f);
		((Component)obj2).gameObject.GetComponent<RectTransform>().offsetMax = new Vector2(-8f, 0f);
		((TMP_Text)obj2).text = (flag ? "Host has BirdieMod  — items can be granted" : "Host does not have BirdieMod — items may be limited");
		((TMP_Text)obj2).fontSize = 11f;
		((Graphic)obj2).color = (flag ? new Color(0.5f, 1f, 0.6f, 1f) : new Color(1f, 0.75f, 0.4f, 1f));
		((TMP_Text)obj2).alignment = (TextAlignmentOptions)4097;
		string[] array = new string[12]
		{
			"Coffee", "Dueling Pistol", "Elephant Gun", "Airhorn", "Spring Boots", "Golf Cart", "Rocket Launcher", "Landmine", "Electromagnet", "Orbital Laser",
			"Rocket Driver", "Freeze Bomb"
		};
		float num = -54f;
		float num2 = 44f;
		float num3 = 6f;
		int num4 = 2;
		for (int i = 0; i < array.Length && i < SpawnableItemTypeInts.Length; i++)
		{
			int num5 = i % num4;
			int num6 = i / num4;
			int capturedTypeInt = SpawnableItemTypeInts[i];
			GameObject val3 = CreateUiObject("ItemBtn_" + array[i], val.transform);
			RectTransform component3 = val3.GetComponent<RectTransform>();
			float num7 = ((num5 == 0) ? 0.02f : 0.52f);
			float num8 = ((num5 == 0) ? 0.48f : 0.98f);
			float num9 = num - (float)num6 * (num2 + num3);
			component3.anchorMin = new Vector2(num7, 1f);
			component3.anchorMax = new Vector2(num8, 1f);
			component3.pivot = new Vector2(0.5f, 1f);
			component3.offsetMin = new Vector2(0f, num9 - num2);
			component3.offsetMax = new Vector2(0f, num9);
			Image val4 = val3.AddComponent<Image>();
			((Graphic)val4).color = new Color(0.2f, 0.22f, 0.27f, 1f);
			Button obj3 = val3.AddComponent<Button>();
			ColorBlock colors = ((Selectable)obj3).colors;
			((ColorBlock)(ref colors)).normalColor = Color.white;
			((ColorBlock)(ref colors)).highlightedColor = new Color(0.85f, 0.92f, 1f, 1f);
			((ColorBlock)(ref colors)).pressedColor = new Color(0.7f, 0.8f, 1f, 1f);
			((ColorBlock)(ref colors)).fadeDuration = 0.08f;
			((Selectable)obj3).colors = colors;
			((Selectable)obj3).targetGraphic = (Graphic)(object)val4;
			((UnityEvent)obj3.onClick).AddListener((UnityAction)delegate
			{
				SpawnItemClientSide(capturedTypeInt);
			});
			TextMeshProUGUI obj4 = CreateUiObject("BtnLabel", val3.transform).AddComponent<TextMeshProUGUI>();
			RectTransform component4 = ((Component)obj4).gameObject.GetComponent<RectTransform>();
			component4.anchorMin = Vector2.zero;
			component4.anchorMax = Vector2.one;
			component4.offsetMin = new Vector2(6f, 0f);
			component4.offsetMax = new Vector2(-6f, 0f);
			((TMP_Text)obj4).text = array[i];
			((TMP_Text)obj4).fontSize = 12f;
			((Graphic)obj4).color = Color.white;
			((TMP_Text)obj4).alignment = (TextAlignmentOptions)4097;
			((TMP_Text)obj4).fontStyle = (FontStyles)1;
		}
		return val;
	}

	private void StartKeybindRebindForIndex(int index)
	{
		//IL_005d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0062: Unknown result type (might be due to invalid IL or missing references)
		//IL_0098: Unknown result type (might be due to invalid IL or missing references)
		//IL_007d: Unknown result type (might be due to invalid IL or missing references)
		//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
		keybindRebindMode = true;
		keybindRebindIndex = index;
		if ((Object)(object)settingsKeybindRebindStatusLabel != (Object)null)
		{
			((TMP_Text)settingsKeybindRebindStatusLabel).text = "Press any key to set: " + SettingsKeybindDisplayNames[index];
		}
		if (settingsKeybindRowButtons == null)
		{
			return;
		}
		for (int i = 0; i < settingsKeybindRowButtons.Length; i++)
		{
			if (!((Object)(object)settingsKeybindRowButtons[i] == (Object)null))
			{
				ColorBlock colors = ((Selectable)settingsKeybindRowButtons[i]).colors;
				((ColorBlock)(ref colors)).normalColor = ((i == index) ? new Color(0.22f, 0.47f, 0.85f, 0.3f) : new Color(0.15f, 0.15f, 0.18f, 1f));
				((Selectable)settingsKeybindRowButtons[i]).colors = colors;
			}
		}
	}

	private void RefreshKeybindRowLabels()
	{
		if (settingsKeybindRowButtons == null)
		{
			return;
		}
		for (int i = 0; i < settingsKeybindRowButtons.Length; i++)
		{
			if ((Object)(object)settingsKeybindRowButtons[i] == (Object)null)
			{
				continue;
			}
			Transform val = ((Component)settingsKeybindRowButtons[i]).transform.Find("KeyBadge/BadgeLabel");
			if ((Object)(object)val != (Object)null)
			{
				TextMeshProUGUI component = ((Component)val).GetComponent<TextMeshProUGUI>();
				if ((Object)(object)component != (Object)null)
				{
					((TMP_Text)component).text = FormatKeyLabel(GetKeybindNameByIndex(i));
				}
			}
		}
	}

	private void RefreshKeybindRowColors()
	{
		//IL_0025: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: 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_0053: Unknown result type (might be due to invalid IL or missing references)
		if (settingsKeybindRowButtons == null)
		{
			return;
		}
		for (int i = 0; i < settingsKeybindRowButtons.Length; i++)
		{
			if (!((Object)(object)settingsKeybindRowButtons[i] == (Object)null))
			{
				ColorBlock colors = ((Selectable)settingsKeybindRowButtons[i]).colors;
				((ColorBlock)(ref colors)).normalColor = new Color(0.15f, 0.15f, 0.18f, 1f);
				((Selectable)settingsKeybindRowButtons[i]).colors = colors;
			}
		}
	}

	private void HandleSettingsPanelInput()
	{
		//IL_006f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0074: Unknown result type (might be due to invalid IL or missing references)
		//IL_0075: Unknown result type (might be due to invalid IL or missing references)
		//IL_0079: Unknown result type (might be due to invalid IL or missing references)
		Keyboard current = Keyboard.current;
		if (current == null)
		{
			return;
		}
		if (current[(Key)60] != null && ((ButtonControl)current[(Key)60]).wasPressedThisFrame)
		{
			if (keybindRebindMode)
			{
				keybindRebindMode = false;
				keybindRebindIndex = -1;
				if ((Object)(object)settingsKeybindRebindStatusLabel != (Object)null)
				{
					((TMP_Text)settingsKeybindRebindStatusLabel).text = "Click a binding to rebind";
				}
				RefreshKeybindRowColors();
			}
			else
			{
				CloseRosettaSettings();
			}
		}
		else if (keybindRebindMode)
		{
			Key val = DetectAnyKeyPressed(current);
			if ((int)val != 0)
			{
				FinishKeybindRebind(val);
			}
		}
	}

	private void UpdateSettingsPanelVisibility()
	{
		if ((Object)(object)settingsPanelObject != (Object)null)
		{
			settingsPanelObject.SetActive(settingsPanelOpen);
		}
	}

	private void RefreshSettingsPanelText()
	{
	}

	private Key DetectAnyKeyPressed(Keyboard keyboard)
	{
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0020: Unknown result type (might be due to invalid IL or missing references)
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_0027: Invalid comparison between Unknown and I4
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: Invalid comparison between Unknown and I4
		//IL_002e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Invalid comparison between Unknown and I4
		//IL_0033: Unknown result type (might be due to invalid IL or missing references)
		//IL_0036: Invalid comparison between Unknown and I4
		//IL_0038: Unknown result type (might be due to invalid IL or missing references)
		//IL_003b: Invalid comparison between Unknown and I4
		//IL_003d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0040: Invalid comparison between Unknown and I4
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		//IL_0045: Invalid comparison between Unknown and I4
		//IL_0047: Unknown result type (might be due to invalid IL or missing references)
		//IL_004a: Invalid comparison between Unknown and I4
		//IL_004e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0060: Unknown result type (might be due to invalid IL or missing references)
		//IL_0061: Unknown result type (might be due to invalid IL or missing references)
		//IL_0079: Unknown result type (might be due to invalid IL or missing references)
		Array values = Enum.GetValues(typeof(Key));
		for (int i = 0; i < values.Length; i++)
		{
			Key val = (Key)values.GetValue(i);
			if ((int)val == 0 || (int)val == 51 || (int)val == 52 || (int)val == 55 || (int)val == 56 || (int)val == 53 || (int)val == 54 || (int)val == 57 || (int)val == 58)
			{
				continue;
			}
			try
			{
				KeyControl val2 = keyboard[val];
				if (val2 != null && ((ButtonControl)val2).wasPressedThisFrame)
				{
					return val;
				}
			}
			catch
			{
			}
		}
		return (Key)0;
	}

	private void FinishKeybindRebind(Key newKey)
	{
		int num = keybindRebindIndex;
		keybindRebindMode = false;
		keybindRebindIndex = -1;
		if (num < 0 || num >= SettingsKeybindDisplayNames.Length)
		{
			RefreshKeybindRowLabels();
			RefreshKeybindRowColors();
			if ((Object)(object)settingsKeybindRebindStatusLabel != (Object)null)
			{
				((TMP_Text)settingsKeybindRebindStatusLabel).text = "Click a binding to rebind";
			}
			return;
		}
		string keyName = ((object)(Key)(ref newKey)).ToString();
		SetKeybindNameByIndex(num, keyName);
		UpdateConfigLabels();
		SaveCurrentConfig();
		RefreshItemMenuText();
		MarkHudDirty();
		RefreshKeybindRowLabels();
		RefreshKeybindRowColors();
		if ((Object)(object)settingsKeybindRebindStatusLabel != (Object)null)
		{
			((TMP_Text)settingsKeybindRebindStatusLabel).text = "Click a binding to rebind";
		}
	}

	private string GetKeybindNameByIndex(int index)
	{
		return index switch
		{
			0 => assistToggleKeyName, 
			1 => coffeeBoostKeyName, 
			2 => nearestBallModeKeyName, 
			3 => unlockAllCosmeticsKeyName, 
			4 => itemSpawnerKeyName, 
			5 => hudToggleKeyName, 
			6 => randomItemKeyName, 
			7 => iceToggleKeyName, 
			8 => settingsKeyName, 
			9 => landmineImmunityKeyName, 
			10 => lockOnAnyDistanceKeyName, 
			11 => noWindKeyName, 
			12 => perfectShotKeyName, 
			13 => noAirDragKeyName, 
			14 => speedMultiplierKeyName, 
			15 => infiniteAmmoKeyName, 
			16 => noRecoilKeyName, 
			17 => noKnockbackKeyName, 
			18 => expandedSlotsKeyName, 
			_ => "?", 
		};
	}

	private void SetKeybindNameByIndex(int index, string keyName)
	{
		switch (index)
		{
		case 0:
			assistToggleKeyName = keyName;
			break;
		case 1:
			coffeeBoostKeyName = keyName;
			break;
		case 2:
			nearestBallModeKeyName = keyName;
			break;
		case 3:
			unlockAllCosmeticsKeyName = keyName;
			break;
		case 4:
			itemSpawnerKeyName = keyName;
			break;
		case 5:
			hudToggleKeyName = keyName;
			break;
		case 6:
			randomItemKeyName = keyName;
			break;
		case 7:
			iceToggleKeyName = keyName;
			break;
		case 8:
			settingsKeyName = keyName;
			break;
		case 9:
			landmineImmunityKeyName = keyName;
			break;
		case 10:
			lockOnAnyDistanceKeyName = keyName;
			break;
		case 11:
			noWindKeyName = keyName;
			break;
		case 12:
			perfectShotKeyName = keyName;
			break;
		case 13:
			noAirDragKeyName = keyName;
			break;
		case 14:
			speedMultiplierKeyName = keyName;
			break;
		case 15:
			infiniteAmmoKeyName = keyName;
			break;
		case 16:
			noRecoilKeyName = keyName;
			break;
		case 17:
			noKnockbackKeyName = keyName;
			break;
		case 18:
			expandedSlotsKeyName = keyName;
			break;
		}
	}

	private void InitializeIceReflection()
	{
		if (iceReflectionInitialized)
		{
			return;
		}
		iceReflectionInitialized = true;
		try
		{
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			foreach (Assembly assembly in assemblies)
			{
				if (cachedHorizontalDragField == null)
				{
					Type type = assembly.GetType("PlayerMovement");
					if (type != null)
					{
						cachedHorizontalDragField = type.GetField("horizontalDrag", BindingFlags.Instance | BindingFlags.NonPublic);
					}
				}
				if (cachedPlayerMovementSettingsProperty == null)
				{
					Type type2 = assembly.GetType("GameManager");
					if (type2 != null)
					{
						cachedPlayerMovementSettingsProperty = type2.GetProperty("PlayerMovementSettings", BindingFlags.Static | BindingFlags.Public);
					}
				}
				if (cachedHorizontalDragField != null && cachedPlayerMovementSettingsProperty != null)
				{
					break;
				}
			}
		}
		catch
		{
		}
	}

	private void ToggleIceImmunity()
	{
		if (!IsFeatureAllowed(0))
		{
			return;
		}
		iceImmunityEnabled = !iceImmunityEnabled;
		if (iceImmunityEnabled)
		{
			if (!iceReflectionInitialized)
			{
				InitializeIceReflection();
			}
			TryCacheNormalDrag();
			BirdieIcePatchBridge.HorizontalDragField = cachedHorizontalDragField;
			BirdieIcePatchBridge.NormalDragValue = normalHorizontalDragValue;
			BirdieIcePatchBridge.EnsurePatchApplied();
			BirdieIcePatchBridge.IsActive = true;
			BirdieLog.Msg($"[Birdie] Ice immunity ON  (normal drag = {normalHorizontalDragValue:F3})");
		}
		else
		{
			BirdieIcePatchBridge.IsActive = false;
			BirdieLog.Msg("[Birdie] Ice immunity OFF");
		}
		MarkHudDirty();
	}

	private void TryCacheNormalDrag()
	{
		try
		{
			if (cachedPlayerMovementSettingsProperty == null)
			{
				return;
			}
			object value = cachedPlayerMovementSettingsProperty.GetValue(null, null);
			if (value != null)
			{
				PropertyInfo property = value.GetType().GetProperty("GroundedHorizontalDrag", BindingFlags.Instance | BindingFlags.Public);
				if (property != null)
				{
					normalHorizontalDragValue = (float)property.GetValue(value, null);
				}
			}
		}
		catch
		{
		}
	}

	private void InitializeCreditsReflection()
	{
		if (creditsReflectionInitialized)
		{
			return;
		}
		creditsReflectionInitialized = true;
		try
		{
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			for (int i = 0; i < assemblies.Length; i++)
			{
				Type type = assemblies[i].GetType("CosmeticsUnlocksManager");
				if (type != null)
				{
					cachedRewardCreditsMethod = type.GetMethod("RewardCredits", BindingFlags.Static | BindingFlags.Public);
					if (cachedRewardCreditsMethod != null)
					{
						break;
					}
				}
			}
		}
		catch
		{
		}
	}

	private void GrantCredits(int amount)
	{
		if (!creditsReflectionInitialized)
		{
			InitializeCreditsReflection();
		}
		if (cachedRewardCreditsMethod == null)
		{
			BirdieLog.Warning("[Birdie] Credits: RewardCredits not found — game version may differ.");
			return;
		}
		if (amount <= 0)
		{
			BirdieLog.Warning("[Birdie] Credits: amount must be greater than zero.");
			return;
		}
		try
		{
			cachedRewardCreditsMethod.Invoke(null, new object[2] { amount, false });
			BirdieLog.Msg("[Birdie] Credits: granted " + amount + " credits.");
		}
		catch (Exception ex)
		{
			BirdieLog.Warning("[Birdie] Credits grant: " + ex.Message);
		}
	}

	private bool TryGetSwingChargeSettings(out float riseDuration, out float fullChargeTime, out float coyoteTime, out float maxNormalizedPower, out float minReleasePower)
	{
		riseDuration = 1f;
		fullChargeTime = 1f;
		coyoteTime = 0f;
		maxNormalizedPower = 2f;
		minReleasePower = 0f;
		object golfSettingsObject = GetGolfSettingsObject();
		if (golfSettingsObject == null)
		{
			return false;
		}
		riseDuration = ModReflectionHelper.GetFloatMemberValue(golfSettingsObject, "SwingChargeRiseDuration", 1f);
		fullChargeTime = ModReflectionHelper.GetFloatMemberValue(golfSettingsObject, "ChargeTimeForRegularFullCharge", riseDuration);
		coyoteTime = ModReflectionHelper.GetFloatMemberValue(golfSettingsObject, "SwingRegularFullChargeCoyoteTime", 0f);
		maxNormalizedPower = 1f + ModReflectionHelper.GetFloatMemberValue(golfSettingsObject, "MaxSwingOvercharge", 0f);
		minReleasePower = ModReflectionHelper.GetFloatMemberValue(golfSettingsObject, "MinSwingReleaseNormalizedPower", 0f);
		return true;
	}

	private float EvaluateEaseIn(float value)
	{
		float num = Mathf.Clamp01(value);
		InitializeSwingMathReflection();
		try
		{
			if (cachedBMathEaseInMethod != null)
			{
				cachedEaseInArgs[0] = num;
				object obj = cachedBMathEaseInMethod.Invoke(null, cachedEaseInArgs);
				if (obj is float result)
				{
					return result;
				}
				if (obj is double)
				{
					return (float)(double)obj;
				}
			}
		}
		catch
		{
		}
		return num * num;
	}

	private float EvaluateSwingPowerFromChargeAge(float chargeAge, float riseDuration, float fullChargeTime, float coyoteTime, float maxNormalizedPower, float minReleasePower)
	{
		float num = ((chargeAge < fullChargeTime) ? chargeAge : ((!(chargeAge < fullChargeTime + coyoteTime)) ? (chargeAge - coyoteTime) : fullChargeTime));
		float value = ((riseDuration > Mathf.Epsilon) ? Mathf.Clamp01(num / riseDuration) : 1f);
		return Mathf.Max(Mathf.LerpUnclamped(0f, maxNormalizedPower, EvaluateEaseIn(value)), minReleasePower);
	}

	private bool TryCalculateChargeTimestampForPower(float targetPower, out double targetTimestamp, out float resolvedPower)
	{
		targetTimestamp = Time.timeAsDouble;
		resolvedPower = targetPower;
		if (!TryGetSwingChargeSettings(out var riseDuration, out var fullChargeTime, out var coyoteTime, out var maxNormalizedPower, out var minReleasePower))
		{
			return false;
		}
		float num = Mathf.Clamp(targetPower, minReleasePower, maxNormalizedPower);
		float num2 = ((num > 1f) ? (fullChargeTime + coyoteTime) : 0f);
		float num3 = ((num > 1f) ? Mathf.Max(num2, riseDuration + coyoteTime) : Mathf.Max(0.0001f, fullChargeTime));
		for (int i = 0; i < 32; i++)
		{
			float num4 = (num2 + num3) * 0.5f;
			if (EvaluateSwingPowerFromChargeAge(num4, riseDuration, fullChargeTime, coyoteTime, maxNormalizedPower, minReleasePower) < num)
			{
				num2 = num4;
			}
			else
			{
				num3 = num4;
			}
		}
		float num5 = num3;
		resolvedPower = EvaluateSwingPowerFromChargeAge(num5, riseDuration, fullChargeTime, coyoteTime, maxNormalizedPower, minReleasePower);
		targetTimestamp = Time.timeAsDouble - (double)num5;
		return true;
	}

	private bool TrySetChargingSwingState(bool isCharging, out bool stateApplied)
	{
		stateApplied = false;
		if ((Object)(object)playerGolfer == (Object)null)
		{
			return false;
		}
		try
		{
			if (cachedSetIsChargingSwingMethod == null)
			{
				cachedSetIsChargingSwingMethod = ((object)playerGolfer).GetType().GetMethod("SetIsChargingSwing", BindingFlags.Instance | BindingFlags.NonPublic);
			}
			if (cachedSetIsChargingSwingMethod == null)
			{
				return false;
			}
			cachedChargingStateArgs[0] = isCharging;
			cachedSetIsChargingSwingMethod.Invoke(playerGolfer, cachedChargingStateArgs);
			stateApplied = true;
			return true;
		}
		catch
		{
			return false;
		}
	}

	private bool TryStartChargingSwingForAutoRelease(out bool startedCharging)
	{
		startedCharging = false;
		if ((Object)(object)playerGolfer == (Object)null)
		{
			return false;
		}
		try
		{
			if (cachedTryStartChargingSwingMethod == null)
			{
				cachedTryStartChargingSwingMethod = ((object)playerGolfer).GetType().GetMethod("TryStartChargingSwing", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			}
			if (cachedTryStartChargingSwingMethod == null)
			{
				return false;
			}
			object obj = cachedTryStartChargingSwingMethod.Invoke(playerGolfer, null);
			startedCharging = !(obj is bool) || (bool)obj;
			return true;
		}
		catch
		{
			return false;
		}
	}

	private bool TrySetSwingPower(float targetPower, out float appliedPower)
	{
		appliedPower = 0f;
		if ((Object)(object)playerGolfer == (Object)null)
		{
			return false;
		}
		TrySetChargingSwingState(isCharging: true, out var _);
		float riseDuration;
		float fullChargeTime;
		float coyoteTime;
		float maxNormalizedPower;
		float minReleasePower;
		bool flag = TryGetSwingChargeSettings(out riseDuration, out fullChargeTime, out coyoteTime, out maxNormalizedPower, out minReleasePower);
		float num = Mathf.Clamp(targetPower, flag ? minReleasePower : 0.05f, flag ? maxNormalizedPower : 2f);
		if (TryCalculateChargeTimestampForPower(num, out var targetTimestamp, out var resolvedPower))
		{
			num = resolvedPower;
		}
		else
		{
			targetTimestamp = Time.timeAsDouble;
		}
		bool flag2 = false;
		bool flag3 = false;
		bool flag4 = false;
		try
		{
			if (playerGolferFields.TryGetValue("swingPowerTimestamp", out var value) && value != null && value.FieldType == typeof(double))
			{
				value.SetValue(playerGolfer, targetTimestamp);
				flag2 = true;
			}
		}
		catch
		{
		}
		try
		{
			if (swingNormalizedPowerBackingField == null)
			{
				swingNormalizedPowerBackingField = ((object)playerGolfer).GetType().GetField("<SwingNormalizedPower>k__BackingField", BindingFlags.Instance | BindingFlags.NonPublic);
			}
			if (swingNormalizedPowerBackingField != null && swingNormalizedPowerBackingField.FieldType == typeof(float))
			{
				swingNormalizedPowerBackingField.SetValue(playerGolfer, num);
				flag3 = true;
			}
		}
		catch
		{
		}
		try
		{
			if (cachedUpdateSwingNormalizedPowerMethod == null)
			{
				cachedUpdateSwingNormalizedPowerMethod = ((object)playerGolfer).GetType().GetMethod("UpdateSwingNormalizedPower", BindingFlags.Instance | BindingFlags.NonPublic);
			}
			if (cachedUpdateSwingNormalizedPowerMethod != null)
			{
				cachedUpdateSwingNormalizedPowerMethod.Invoke(playerGolfer, cachedUpdateSwingPowerArgs);
				flag4 = true;
			}
		}
		catch
		{
		}
		if (!flag2 && !flag3 && !flag4)
		{
			return false;
		}
		appliedPower = num;
		try
		{
			if (TryGetCurrentSwingValues(out var swingPower, out var _, out var _, out var _))
			{
				appliedPower = swingPower;
			}
		}
		catch
		{
		}
		lastObservedSwingPower = appliedPower;
		return true;
	}

	private bool ReleaseSwing()
	{
		if ((Object)(object)playerGolfer == (Object)null)
		{
			return false;
		}
		try
		{
			if (cachedReleaseSwingChargeMethod == null)
			{
				cachedReleaseSwingChargeMethod = ((object)playerGolfer).GetType().GetMethod("ReleaseSwingCharge", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			}
			if (cachedReleaseSwingChargeMethod == null)
			{
				return false;
			}
			cachedReleaseSwingChargeMethod.Invoke(playerGolfer, null);
			return true;
		}
		catch
		{
		}
		isLeftMousePressed = false;
		return false;
	}

	private void AutoSwingRelease()
	{
		if (!assistEnabled || !isLeftMousePressed || (Object)(object)playerGolfer == (Object)null || Time.frameCount == lastAutoSwingReleaseFrame)
		{
			return;
		}
		lastAutoSwingReleaseFrame = Time.frameCount;
		if (autoReleaseTriggeredThisCharge)
		{
			return;
		}
		try
		{
			if (!TryGetCurrentSwingValues(out var swingPower, out var swingPitch, out var isChargingSwing, out var isSwinging))
			{
				return;
			}
			bool flag = false;
			if (playerGolferProperties.TryGetValue("IsAimingSwing", out var value))
			{
				try
				{
					flag = (bool)value.GetValue(playerGolfer, null);
				}
				catch
				{
				}
			}
			if (!autoChargeSequenceStarted && !isChargingSwing && flag && !isSwinging && Time.time >= nextTryStartChargingTime)
			{
				nextTryStartChargingTime = Time.time + tryStartChargingInterval;
				TryStartChargingSwingForAutoRelease(out var startedCharging);
				if (startedCharging)
				{
					autoChargeSequenceStarted = true;
				}
				TryGetCurrentSwingValues(out swingPower, out swingPitch, out isChargingSwing, out isSwinging);
			}
			if (autoChargeSequenceStarted && !isChargingSwing && !isSwinging && Time.time >= nextTryStartChargingTime)
			{
				nextTryStartChargingTime = Time.time + tryStartChargingInterval;
				TryStartChargingSwingForAutoRelease(out var _);
				TryGetCurrentSwingValues(out swingPower, out swingPitch, out isChargingSwing, out isSwinging);
			}
			if (!isLeftMousePressed || (!isChargingSwing && (!autoChargeSequenceStarted || !(swingPower > 0.005f))))
			{
				lastObservedSwingPower = 0f;
				return;
			}
			CalculateIdealSwingParameters(forceHoleRefresh: false);
			float targetPower = ((idealSwingPower > 0.0001f) ? Mathf.Clamp(idealSwingPower, 0.05f, 2f) : 1f);
			if (TrySetSwingPower(targetPower, out var appliedPower) && (!TryGetCurrentSwingValues(out var swingPower2, out var _, out var isChargingSwing2, out var isSwinging2) || isChargingSwing2 || isSwinging2 || !(swingPower2 <= 0.001f)))
			{
				if (ReleaseSwing())
				{
					autoReleaseTriggeredThisCharge = true;
					autoChargeSequenceStarted = false;
					FreezePredictedTrajectorySnapshot(appliedPower, swingPitch);
				}
				lastObservedSwingPower = appliedPower;
			}
		}
		catch
		{
		}
	}

	private void UpdateTrails()
	{
		if (!tracersEnabled)
		{
			if ((Object)(object)shotPathLine != (Object)null && shotPathLine.positionCount != 0)
			{
				shotPathLine.positionCount = 0;
			}
			ClearPredictedTrails(hideFrozenSnapshot: true);
		}
		else
		{
			UpdateActualTrail();
			bool ballMoving = IsBallMovingForPrediction();
			UpdatePredictedTrail(ballMoving);
		}
	}

	private void UpdateActualTrail()
	{
		//IL_0051: Unknown result type (might be due to invalid IL or missing references)
		//IL_0056: Unknown result type (might be due to invalid IL or missing references)
		//IL_0061: Unknown result type (might be due to invalid IL or missing references)
		//IL_0066: Unknown result type (might be due to invalid IL or missing references)
		//IL_006b: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0072: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
		//IL_007f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0080: Unknown result type (might be due to invalid IL or missing references)
		//IL_01de: Unknown result type (might be due to invalid IL or missing references)
		//IL_01df: Unknown result type (might be due to invalid IL or missing references)
		//IL_0165: Unknown result type (might be due to invalid IL or missing references)
		//IL_0149: Unknown result type (might be due to invalid IL or missing references)
		//IL_014e: 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_0154: 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_0103: Unknown result type (might be due to invalid IL or missing references)
		//IL_0108: Unknown result type (might be due to invalid IL or missing references)
		//IL_010d: Unknown result type (might be due to invalid IL or missing references)
		//IL_00de: Unknown result type (might be due to invalid IL or missing references)
		//IL_011f: Unknown result type (might be due to invalid IL or missing references)
		EnsureTrailRenderers();
		if (!actualTrailEnabled)
		{
			if ((Object)(object)shotPathLine != (Object)null)
			{
				shotPathLine.positionCount = 0;
			}
			return;
		}
		if ((Object)(object)shotPathLine == (Object)null || (Object)(object)golfBall == (Object)null)
		{
			return;
		}
		Vector3 val = golfBall.transform.position + Vector3.up * shotPathHeightOffset;
		if (lastShotPathBallPosition == Vector3.zero)
		{
			lastShotPathBallPosition = val;
		}
		float num = shotPathMoveThreshold * shotPathMoveThreshold;
		float num2 = shotPathPointSpacing * shotPathPointSpacing;
		Vector3 val2 = val - lastShotPathBallPosition;
		if (((Vector3)(ref val2)).sqrMagnitude >= num)
		{
			if (!isRecordingShotPath)
			{
				isRecordingShotPath = true;
				if (shotPathPoints.Count == 0)
				{
					shotPathPoints.Add(lastShotPathBallPosition);
				}
				else
				{
					val2 = shotPathPoints[shotPathPoints.Count - 1] - lastShotPathBallPosition;
					if (((Vector3)(ref val2)).sqrMagnitude >= num2)
					{
						shotPathPoints.Add(lastShotPathBallPosition);
					}
				}
			}
			if (shotPathPoints.Count != 0)
			{
				val2 = shotPathPoints[shotPathPoints.Count - 1] - val;
				if (!(((Vector3)(ref val2)).sqrMagnitude >= num2))
				{
					goto IL_01ad;
				}
			}
			shotPathPoints.Add(val);
			if (shotPathPoints.Count > shotPathMaxPoints)
			{
				int count = shotPathPoints.Count - shotPathMaxPoints;
				shotPathPoints.RemoveRange(0, count);
				actualTrailLineDirty = true;
			}
			ApplyActualTrailToLine();
			goto IL_01ad;
		}
		if (isRecordingShotPath && Time.time - lastShotPathMoveTime > shotPathStationaryDelay)
		{
			isRecordingShotPath = false;
		}
		goto IL_01dd;
		IL_01dd:
		lastShotPathBallPosition = val;
		return;
		IL_01ad:
		lastShotPathMoveTime = Time.time;
		goto IL_01dd;
	}

	private void UpdatePredictedTrail(bool ballMoving)
	{
		//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00be: Unknown result type (might be due to invalid IL or missing references)
		//IL_011d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0122: Unknown result type (might be due to invalid IL or missing references)
		//IL_012d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0132: Unknown result type (might be due to invalid IL or missing references)
		//IL_0137: Unknown result type (might be due to invalid IL or missing references)
		//IL_0139: Unknown result type (might be due to invalid IL or missing references)
		//IL_0153: Unknown result type (might be due to invalid IL or missing references)
		EnsureTrailRenderers();
		if ((Object)(object)predictedPathLine == (Object)null || (Object)(object)frozenPredictedPathLine == (Object)null)
		{
			return;
		}
		if (ballMoving)
		{
			observedBallMotionSinceLastShot = true;
			ClearPredictedTrails(hideFrozenSnapshot: false);
			return;
		}
		if (lockLivePredictedPath)
		{
			bool flag = predictedTrajectoryHideStartTime > 0f && Time.time - predictedTrajectoryHideStartTime >= predictedTrajectoryUnlockFallbackDelay;
			if (!(observedBallMotionSinceLastShot || flag))
			{
				ClearPredictedTrails(hideFrozenSnapshot: false);
				return;
			}
			lockLivePredictedPath = false;
			observedBallMotionSinceLastShot = false;
			predictedTrajectoryHideStartTime = 0f;
		}
		if (!assistEnabled || (Object)(object)playerGolfer == (Object)null || (Object)(object)golfBall == (Object)null || currentAimTargetPosition == Vector3.zero)
		{
			ClearPredictedTrails(hideFrozenSnapshot: true);
			return;
		}
		float time = Time.time;
		if (predictedPathPoints.Count > 0 && time < nextPredictedPathRefreshTime)
		{
			return;
		}
		nextPredictedPathRefreshTime = time + predictedPathRefreshInterval;
		if (!TryResolvePredictedSwingParameters(out var shotPower, out var swingPitch))
		{
			ClearPredictedTrails(hideFrozenSnapshot: true);
			return;
		}
		Vector3 shotOrigin = golfBall.transform.position + Vector3.up * shotPathHeightOffset;
		if (ShouldRebuildPredictedTrajectory(shotOrigin, shotPower, swingPitch))
		{
			BuildPredictedTrajectoryPoints(shotPower, swingPitch, predictedPathPoints);
			CachePredictedTrajectoryInputs(shotOrigin, shotPower, swingPitch);
			ApplyPredictedTrailToLine();
		}
	}

	private bool ShouldRebuildPredictedTrajectory(Vector3 shotOrigin, float shotPower, float swingPitch)
	{
		//IL_0034: Unknown result type (might be due to invalid IL or missing references)
		//IL_0039: Unknown result type (might be due to invalid IL or missing references)
		//IL_003a: Unknown result type (might be due to invalid IL or missing references)
		//IL_003f: Unknown result type (might be due to invalid IL or missing references)
		//IL_004d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0053: Unknown result type (might be due to invalid IL or missing references)
		//IL_0058: Unknown result type (might be due to invalid IL or missing references)
		//IL_005d: Unknown result type (might be due to invalid IL or missing references)
		if (!predictedPathCacheValid || predictedPathPoints.Count == 0 || cachedPredictedPathBall != golfBall)
		{
			return true;
		}
		float num = predictedPathRebuildDistanceEpsilon * predictedPathRebuildDistanceEpsilon;
		Vector3 val = cachedPredictedShotOrigin - shotOrigin;
		if (((Vector3)(ref val)).sqrMagnitude > num)
		{
			return true;
		}
		val = cachedPredictedAimTargetPosition - currentAimTargetPosition;
		if (((Vector3)(ref val)).sqrMagnitude > num)
		{
			return true;
		}
		if (Mathf.Abs(cachedPredictedSwingPower - shotPower) > predictedPathRebuildPowerEpsilon)
		{
			return true;
		}
		return Mathf.Abs(cachedPredictedSwingPitch - swingPitch) > predictedPathRebuildPitchEpsilon;
	}

	private void CachePredictedTrajectoryInputs(Vector3 shotOrigin, float shotPower, float swingPitch)
	{
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		//IL_001c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		predictedPathCacheValid = true;
		cachedPredictedPathBall = golfBall;
		cachedPredictedShotOrigin = shotOrigin;
		cachedPredictedAimTargetPosition = currentAimTargetPosition;
		cachedPredictedSwingPower = shotPower;
		cachedPredictedSwingPitch = swingPitch;
	}

	private bool TryResolvePredictedSwingParameters(out float shotPower, out float swingPitch)
	{
		shotPower = Mathf.Clamp((idealSwingPower > 0.0001f) ? idealSwingPower : 0.05f, 0.05f, 2f);
		swingPitch = idealSwingPitch;
		if ((Object)(object)playerGolfer == (Object)null)
		{
			return false;
		}
		if (TryGetCurrentSwingValues(out var _, out swingPitch, out var _, out var _) && (float.IsNaN(swingPitch) || float.IsInfinity(swingPitch)))
		{
			swingPitch = idealSwingPitch;
		}
		if (TryCalculateChargeTimestampForPower(shotPower, out var _, out var resolvedPower))
		{
			shotPower = Mathf.Clamp(resolvedPower, 0.05f, 2f);
		}
		if (float.IsNaN(swingPitch) || float.IsInfinity(swingPitch))
		{
			swingPitch = idealSwingPitch;
		}
		if (!float.IsNaN(shotPower))
		{
			return !float.IsInfinity(shotPower);
		}
		return false;
	}

	private bool IsBallMovingForPrediction()
	{
		if (TryGetGolfBallVelocity(out var velocity) && ((Vector3)(ref velocity)).magnitude > predictedUnlockSpeedThreshold)
		{
			return true;
		}
		if (isRecordingShotPath)
		{
			return true;
		}
		if (lastShotPathMoveTime > 0f)
		{
			return Time.time - lastShotPathMoveTime <= shotPathStationaryDelay;
		}
		return false;
	}

	private Vector3 BuildPredictedShotDirection(Vector3 shotOrigin, float swingPitch)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		//IL_001c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00de: Unknown result type (might be due to invalid IL or missing references)
		//IL_0069: Unknown result type (might be due to invalid IL or missing references)
		//IL_0057: Unknown result type (might be due to invalid IL or missing references)
		//IL_010f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0116: Unknown result type (might be due to invalid IL or missing references)
		//IL_011b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0126: 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_0130: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f8: 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_006e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0072: Unknown result type (might be due to invalid IL or missing references)
		//IL_007e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0149: 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_0098: Unknown result type (might be due to invalid IL or missing references)
		//IL_009d: Unknown result type (might be due to invalid IL or missing references)
		Vector3 val2 = default(Vector3);
		if (currentAimTargetPosition != Vector3.zero)
		{
			Vector3 val = currentAimTargetPosition - shotOrigin;
			val.y = 0f;
			if (((Vector3)(ref val)).sqrMagnitude > 0.0001f)
			{
				val2 = ((Vector3)(ref val)).normalized;
			}
			else
			{
				Vector3 val3 = (((Object)(object)playerGolfer != (Object)null) ? playerGolfer.transform.forward : Vector3.forward);
				((Vector3)(ref val2))..ctor(val3.x, 0f, val3.z);
				if (((Vector3)(ref val2)).sqrMagnitude < 0.0001f)
				{
					val2 = Vector3.forward;
				}
				else
				{
					((Vector3)(ref val2)).Normalize();
				}
			}
		}
		else
		{
			Vector3 val4 = (((Object)(object)playerGolfer != (Object)null) ? playerGolfer.transform.forward : Vector3.forward);
			((Vector3)(ref val2))..ctor(val4.x, 0f, val4.z);
			if (((Vector3)(ref val2)).sqrMagnitude < 0.0001f)
			{
				val2 = Vector3.forward;
			}
			else
			{
				((Vector3)(ref val2)).Normalize();
			}
		}
		float num = swingPitch * ((float)Math.PI / 180f);
		Vector3 val5 = val2 * Mathf.Cos(num) + Vector3.up * Mathf.Sin(num);
		if (!(((Vector3)(ref val5)).sqrMagnitude < 0.0001f))
		{
			return ((Vector3)(ref val5)).normalized;
		}
		return GetSwingDirection(swingPitch);
	}

	private void BuildPredictedTrajectoryPoints(float shotPower, float swingPitch, List<Vector3> outputPoints)
	{
		//IL_003b: 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_0058: Unknown result type (might be due to invalid IL or missing references)
		//IL_005d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0072: Unknown result type (might be due to invalid IL or missing references)
		//IL_0074: Unknown result type (might be due to invalid IL or missing references)
		//IL_0076: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00da: Unknown result type (might be due to invalid IL or missing references)
		//IL_00df: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
		//IL_0100: Unknown result type (might be due to invalid IL or missing references)
		//IL_0103: Unknown result type (might be due to invalid IL or missing references)
		//IL_0108: Unknown result type (might be due to invalid IL or missing references)
		//IL_0265: Unknown result type (might be due to invalid IL or missing references)
		//IL_0267: Unknown result type (might be due to invalid IL or missing references)
		//IL_0112: Unknown result type (might be due to invalid IL or missing references)
		//IL_0114: Unknown result type (might be due to invalid IL or missing references)
		//IL_0116: Unknown result type (might be due to invalid IL or missing references)
		//IL_0118: 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_011f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0124: 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_0198: 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_01a5: Unknown result type (might be due to invalid IL or missing references)
		//IL_0134: Unknown result type (might be due to invalid IL or missing references)
		//IL_0136: Unknown result type (might be due to invalid IL or missing references)
		//IL_0138: 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)
		//IL_013f: 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_0143: Unknown result type (might be due to invalid IL or missing references)
		//IL_0148: 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_0152: Unknown result type (might be due to invalid IL or missing references)
		//IL_0157: 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_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_016b: Unknown result type (might be due to invalid IL or missing references)
		//IL_016d: Unknown result type (might be due to invalid IL or missing references)
		//IL_016f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0174: Unknown result type (might be due to invalid IL or missing references)
		//IL_017f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0181: Unknown result type (might be due to invalid IL or missing references)
		//IL_018a: Unknown result type (might be due to invalid IL or missing references)
		//IL_018f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0194: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f4: 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_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_0215: Unknown result type (might be due to invalid IL or missing references)
		//IL_020e: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c2: 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_01c9: Unknown result type (might be due to invalid IL or missing references)
		//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
		//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d2: 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)
		outputPoints.Clear();
		ResetImpactPreviewCache(outputPoints == predictedPathPoints, outputPoints == frozenPredictedPathPoints);
		if ((Object)(object)playerGolfer == (Object)null || (Object)(object)golfBall == (Object)null || currentAimTargetPosition == Vector3.zero)
		{
			return;
		}
		Vector3 val = golfBall.transform.position + Vector3.up * shotPathHeightOffset;
		Vector3 val2 = BuildPredictedShotDirection(val, swingPitch);
		float num = Mathf.Max(0.1f, EstimateLaunchSpeedFromPower(shotPower, swingPitch));
		float num2 = Mathf.Clamp(Time.fixedDeltaTime, 0.005f, 0.04f);
		Vector3 gravity = Physics.gravity;
		float runtimeLinearAirDragFactor = GetRuntimeLinearAirDragFactor();
		float num3 = predictedPathPointSpacing * predictedPathPointSpacing;
		outputPoints.Add(val);
		Vector3 val3 = val;
		Vector3 val4 = val2 * num;
		float num4 = 0f;
		Vector3 currentWind = GetCurrentWind();
		bool flag = outputPoints == predictedPathPoints || outputPoints == frozenPredictedPathPoints;
		bool flag2 = false;
		Vector3 impactPoint = Vector3.zero;
		Vector3 approachDirection = GetFallbackPreviewDirection();
		for (int i = 0; i < predictedPathMaxSteps; i++)
		{
			if (!(num4 <= predictedPathMaxTime))
			{
				break;
			}
			Vector3 val5 = val3;
			val4 += gravity * num2;
			if (((Vector3)(ref val4)).sqrMagnitude > 0.0001f)
			{
				Vector3 val6 = Vector3.Project(currentWind, val4);
				Vector3 val7 = currentWind - val6;
				Vector3 val8 = val6 * windFactor + val7 * crossWindFactor;
				Vector3 val9 = val4 - val8;
				float sqrMagnitude = ((Vector3)(ref val9)).sqrMagnitude;
				val4 -= val9 * (runtimeLinearAirDragFactor * sqrMagnitude * num2);
			}
			val3 += val4 * num2;
			if (flag && !flag2 && TryFindWorldImpactAlongSegment(val5, val3, out var resolvedHit))
			{
				flag2 = true;
				impactPoint = ((RaycastHit)(ref resolvedHit)).point;
				Vector3 val10 = val3 - val5;
				if (((Vector3)(ref val10)).sqrMagnitude >= 0.0001f)
				{
					approachDirection = ((Vector3)(ref val10)).normalized;
				}
			}
			Vector3 val11 = outputPoints[outputPoints.Count - 1] - val3;
			if (((Vector3)(ref val11)).sqrMagnitude >= num3)
			{
				outputPoints.Add(val3);
			}
			if (val3.y < -200f || (num4 > 1f && ((Vector3)(ref val4)).sqrMagnitude < 0.001f))
			{
				break;
			}
			num4 += num2;
		}
		if (flag)
		{
			StoreImpactPreviewData(outputPoints, flag2, impactPoint, approachDirection);
		}
	}

	private void FreezePredictedTrajectorySnapshot(float shotPower, float swingPitch)
	{
		if (!frozenTrailEnabled)
		{
			frozenPredictedPathPoints.Clear();
			predictedPathCacheValid = false;
			frozenTrailLineDirty = false;
			if ((Object)(object)frozenPredictedPathLine != (Object)null)
			{
				frozenPredictedPathLine.positionCount = 0;
			}
			return;
		}
		EnsureTrailRenderers();
		if (!((Object)(object)frozenPredictedPathLine == (Object)null))
		{
			BuildPredictedTrajectoryPoints(Mathf.Clamp(shotPower, 0.05f, 2f), swingPitch, frozenPredictedPathPoints);
			ApplyFrozenTrailToLine();
			lockLivePredictedPath = true;
			observedBallMotionSinceLastShot = false;
			predictedTrajectoryHideStartTime = Time.time;
			predictedPathPoints.Clear();
			predictedPathCacheValid = false;
			predictedTrailLineDirty = false;
			if ((Object)(object)predictedPathLine != (Object)null)
			{
				predictedPathLine.positionCount = 0;
			}
		}
	}

	private Vector3 GetAimTargetPosition(Vector3 playerPosition)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		//IL_0020: Unknown result type (might be due to invalid IL or missing references)
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_0022: Unknown result type (might be due to invalid IL or missing references)
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		//IL_0044: Unknown result type (might be due to invalid IL or missing references)
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0061: Unknown result type (might be due to invalid IL or missing references)
		//IL_0062: Unknown result type (might be due to invalid IL or missing references)
		//IL_0063: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_0056: Unknown result type (might be due to invalid IL or missing references)
		//IL_0127: Unknown result type (might be due to invalid IL or missing references)
		//IL_0129: Unknown result type (might be due to invalid IL or missing references)
		//IL_012e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0133: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00eb: 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_00f1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
		//IL_0102: Unknown result type (might be due to invalid IL or missing references)
		//IL_0107: Unknown result type (might be due to invalid IL or missing references)
		//IL_010c: Unknown result type (might be due to invalid IL or missing references)
		//IL_010d: Unknown result type (might be due to invalid IL or missing references)
		//IL_010e: 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_011f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0124: 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_00a1: Unknown result type (might be due to invalid IL or missing references)
		//IL_0134: Unknown result type (might be due to invalid IL or missing references)
		Vector3 val = ((holePosition != Vector3.zero) ? holePosition : flagPosition);
		if (val == Vector3.zero)
		{
			return Vector3.zero;
		}
		float num = puttDistanceThreshold * puttDistanceThreshold;
		Vector3 val2 = playerPosition - val;
		if (((Vector3)(ref val2)).sqrMagnitude <= num)
		{
			val.y = playerPosition.y;
		}
		Vector3 val3 = val - playerPosition;
		val3.y = 0f;
		if (((Vector3)(ref val3)).sqrMagnitude < 0.0001f && (Object)(object)playerGolfer != (Object)null)
		{
			val3 = playerGolfer.transform.forward;
			val3.y = 0f;
		}
		if (((Vector3)(ref val3)).sqrMagnitude >= 0.0001f)
		{
			((Vector3)(ref val3)).Normalize();
			val2 = Vector3.Cross(Vector3.up, val3);
			Vector3 normalized = ((Vector3)(ref val2)).normalized;
			val += normalized * aimTargetOffsetLocal.x;
			val += Vector3.up * aimTargetOffsetLocal.y;
			return val + val3 * aimTargetOffsetLocal.z;
		}
		return val + aimTargetOffsetLocal;
	}

	private Vector3 GetSwingOriginPosition()
	{
		//IL_004e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		//IL_0048: Unknown result type (might be due to invalid IL or missing references)
		Transform val = (((Object)(object)playerGolfer != (Object)null) ? playerGolfer.transform : (((Object)(object)playerMovement != (Object)null) ? playerMovement.transform : null));
		if (!((Object)(object)val == (Object)null))
		{
			return val.TransformPoint(swingOriginLocalOffset);
		}
		return Vector3.zero;
	}

	private Vector3 GetSwingDirection(float pitch)
	{
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0038: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		//IL_0047: Unknown result type (might be due to invalid IL or missing references)
		//IL_004c: Unknown result type (might be due to invalid IL or missing references)
		//IL_000e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0061: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0078: Unknown result type (might be due to invalid IL or missing references)
		//IL_007d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0082: Unknown result type (might be due to invalid IL or missing references)
		//IL_0085: Unknown result type (might be due to invalid IL or missing references)
		//IL_005b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0060: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)playerGolfer == (Object)null)
		{
			return Vector3.forward;
		}
		Vector3 forward = playerGolfer.transform.forward;
		float num = pitch * ((float)Math.PI / 180f);
		Vector3 val = new Vector3(forward.x, 0f, forward.z);
		Vector3 val2 = ((Vector3)(ref val)).normalized;
		if (((Vector3)(ref val2)).sqrMagnitude < 0.0001f)
		{
			val2 = Vector3.forward;
		}
		Vector3 val3 = val2 * Mathf.Cos(num) + Vector3.up * Mathf.Sin(num);
		return ((Vector3)(ref val3)).normalized;
	}

	private float EstimateLaunchSpeedFromPower(float power, float swingPitch)
	{
		InitializeSwingHittableReflection();
		float num = Mathf.Clamp(power, 0.05f, 2f);
		if (!TryGetServerSwingPowerMultiplier(out var swingPowerMultiplier))
		{
			swingPowerMultiplier = 1f;
		}
		float num2 = ((Mathf.Abs(swingPitch) < 0.5f) ? cachedMaxPowerPuttHitSpeed : cachedMaxPowerSwingHitSpeed);
		return num * num2 * Mathf.Max(0.01f, swingPowerMultiplier);
	}

	private float EstimatePowerFromLaunchSpeed(float speed)
	{
		if (!TryGetServerSwingPowerMultiplier(out var swingPowerMultiplier))
		{
			swingPowerMultiplier = 1f;
		}
		float x = Mathf.Max(0.1f, speed) / Mathf.Max(0.01f, swingPowerMultiplier / Mathf.Max(0.01f, launchModelReferenceSrvMul));
		return Mathf.Clamp(EvaluatePiecewiseLinear(x, launchModelSpeeds, launchModelPowers), 0.05f, 2f);
	}

	private float EvaluatePiecewiseLinear(float x, float[] xs, float[] ys)
	{
		if (xs == null || ys == null || xs.Length < 2 || ys.Length < 2 || xs.Length != ys.Length)
		{
			return x;
		}
		int num = xs.Length - 1;
		if (x <= xs[0])
		{
			float num2 = (x - xs[0]) / Mathf.Max(0.0001f, xs[1] - xs[0]);
			return ys[0] + num2 * (ys[1] - ys[0]);
		}
		for (int i = 0; i < num; i++)
		{
			if (x <= xs[i + 1])
			{
				float num3 = (x - xs[i]) / Mathf.Max(0.0001f, xs[i + 1] - xs[i]);
				return ys[i] + num3 * (ys[i + 1] - ys[i]);
			}
		}
		float num4 = (x - xs[num - 1]) / Mathf.Max(0.0001f, xs[num] - xs[num - 1]);
		return ys[num - 1] + num4 * (ys[num] - ys[num - 1]);
	}

	private bool TryGetGolfBallVelocity(out Vector3 velocity)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_0084: Unknown result type (might be due to invalid IL or missing references)
		//IL_0089: Unknown result type (might be due to invalid IL or missing references)
		velocity = Vector3.zero;
		if (!TryGetGolfBallRigidbody(out var ballRigidbody) || (Object)(object)ballRigidbody == (Object)null)
		{
			return false;
		}
		if (!rigidbodyVelocityReflectionInitialized)
		{
			rigidbodyVelocityReflectionInitialized = true;
			BindingFlags bindingAttr = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
			Type type = ((object)ballRigidbody).GetType();
			cachedRigidbodyLinearVelocityProperty = type.GetProperty("linearVelocity", bindingAttr);
		}
		try
		{
			if (cachedRigidbodyLinearVelocityProperty != null && cachedRigidbodyLinearVelocityProperty.PropertyType == typeof(Vector3))
			{
				velocity = (Vector3)cachedRigidbodyLinearVelocityProperty.GetValue(ballRigidbody, null);
				return true;
			}
		}
		catch
		{
		}
		return false;
	}

	private bool TryGetGolfBallRigidbody(out Rigidbody ballRigidbody)
	{
		ballRigidbody = null;
		if ((Object)(object)golfBall == (Object)null && (!EnsureLocalGolfBallReference(force: false) || (Object)(object)golfBall == (Object)null))
		{
			return false;
		}
		Type type = ((object)golfBall).GetType();
		if (!golfBallVelocityReflectionInitialized || cachedGolfBallTypeForVelocity != type)
		{
			golfBallVelocityReflectionInitialized = true;
			cachedGolfBallTypeForVelocity = type;
			rigidbodyVelocityReflectionInitialized = false;
			BindingFlags bindingAttr = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
			cachedGolfBallRigidbodyProperty = type.GetProperty("Rigidbody", bindingAttr);
		}
		try
		{
			if (cachedGolfBallRigidbodyProperty != null)
			{
				object? value = cachedGolfBallRigidbodyProperty.GetValue(golfBall, null);
				ballRigidbody = (Rigidbody)((value is Rigidbody) ? value : null);
				if ((Object)(object)ballRigidbody != (Object)null)
				{
					return true;
				}
			}
		}
		catch
		{
		}
		return false;
	}

	private void InitializeSwingMathReflection()
	{
		if (swingMathReflectionInitialized)
		{
			return;
		}
		swingMathReflectionInitialized = true;
		try
		{
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			foreach (Assembly assembly in assemblies)
			{
				if (cachedGolfSettingsProperty == null)
				{
					Type type = assembly.GetType("GameManager");
					if (type != null)
					{
						cachedGolfSettingsProperty = type.GetProperty("GolfSettings", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
						cachedGolfBallSettingsProperty = type.GetProperty("GolfBallSettings", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
					}
				}
				if (cachedBMathEaseInMethod == null)
				{
					Type type2 = assembly.GetType("BMath");
					if (type2 != null)
					{
						cachedBMathEaseInMethod = type2.GetMethod("EaseIn", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(float) }, null);
					}
				}
			}
		}
		catch
		{
		}
	}

	private object GetGolfSettingsObject()
	{
		if (cachedGolfSettingsObject != null)
		{
			return cachedGolfSettingsObject;
		}
		InitializeSwingMathReflection();
		try
		{
			if (cachedGolfSettingsProperty != null)
			{
				cachedGolfSettingsObject = cachedGolfSettingsProperty.GetValue(null, null);
			}
		}
		catch
		{
		}
		return cachedGolfSettingsObject;
	}

	private object GetGolfBallSettingsObject()
	{
		if (cachedGolfBallSettingsObject != null)
		{
			return cachedGolfBallSettingsObject;
		}
		InitializeSwingMathReflection();
		try
		{
			if (cachedGolfBallSettingsProperty != null)
			{
				cachedGolfBallSettingsObject = cachedGolfBallSettingsProperty.GetValue(null, null);
			}
		}
		catch
		{
		}
		return cachedGolfBallSettingsObject;
	}

	private void InitializeMatchSetupRulesReflection()
	{
		if (matchSetupRulesReflectionInitialized)
		{
			return;
		}
		matchSetupRulesReflectionInitialized = true;
		try
		{
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			for (int i = 0; i < assemblies.Length; i++)
			{
				Type type = assemblies[i].GetType("MatchSetupRules");
				if (type == null)
				{
					continue;
				}
				cachedMatchSetupRuleEnumType = type.GetNestedType("Rule", BindingFlags.Public | BindingFlags.NonPublic);
				MethodInfo[] methods = type.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
				foreach (MethodInfo methodInfo in methods)
				{
					if (!(methodInfo.Name != "GetValue"))
					{
						ParameterInfo[] parameters = methodInfo.GetParameters();
						if (parameters.Length == 1 && (cachedMatchSetupRuleEnumType == null || parameters[0].ParameterType == cachedMatchSetupRuleEnumType))
						{
							cachedMatchSetupGetValueMethod = methodInfo;
							break;
						}
					}
				}
				if (cachedMatchSetupRuleEnumType != null)
				{
					try
					{
						cachedMatchSetupSwingPowerRuleValue = Enum.Parse(cachedMatchSetupRuleEnumType, "SwingPower", ignoreCase: true);
					}
					catch
					{
						cachedMatchSetupSwingPowerRuleValue = null;
					}
				}
				if (cachedMatchSetupGetValueMethod != null && cachedMatchSetupSwingPowerRuleValue != null)
				{
					break;
				}
			}
		}
		catch
		{
		}
	}

	private bool TryGetServerSwingPowerMultiplier(out float swingPowerMultiplier)
	{
		swingPowerMultiplier = 1f;
		InitializeMatchSetupRulesReflection();
		if (cachedMatchSetupGetValueMethod == null || cachedMatchSetupSwingPowerRuleValue == null)
		{
			return false;
		}
		try
		{
			cachedMatchSetupGetValueArgs[0] = cachedMatchSetupSwingPowerRuleValue;
			object obj = cachedMatchSetupGetValueMethod.Invoke(null, cachedMatchSetupGetValueArgs);
			if (obj == null)
			{
				return false;
			}
			float num = Convert.ToSingle(obj);
			if (float.IsNaN(num) || float.IsInfinity(num) || num <= 0f)
			{
				return false;
			}
			swingPowerMultiplier = num;
			return true;
		}
		catch
		{
			return false;
		}
	}

	private float GetRuntimeLinearAirDragFactor()
	{
		float floatMemberValue = ModReflectionHelper.GetFloatMemberValue(GetGolfBallSettingsObject(), "LinearAirDragFactor", 0.0003f);
		if (!float.IsNaN(floatMemberValue) && !float.IsInfinity(floatMemberValue) && !(floatMemberValue <= 0f))
		{
			return floatMemberValue;
		}
		return 0.0003f;
	}

	private void InitializeSwingHittableReflection()
	{
		if (swingHittableReflectionInitialized && cachedGolfBallForHittable == golfBall)
		{
			return;
		}
		swingHittableReflectionInitialized = true;
		cachedGolfBallForHittable = golfBall;
		if ((Object)(object)golfBall == (Object)null)
		{
			return;
		}
		try
		{
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			Type type = null;
			for (int i = 0; i < assemblies.Length; i++)
			{
				type = assemblies[i].GetType("Hittable");
				if (type != null)
				{
					break;
				}
			}
			if (type == null)
			{
				return;
			}
			Component component = golfBall.GetComponent(type);
			if ((Object)(object)component == (Object)null)
			{
				return;
			}
			object memberValue = ModReflectionHelper.GetMemberValue(component, "SwingSettings");
			if (memberValue != null)
			{
				float floatMemberValue = ModReflectionHelper.GetFloatMemberValue(memberValue, "MaxPowerSwingHitSpeed", 85f);
				if (!float.IsNaN(floatMemberValue) && !float.IsInfinity(floatMemberValue) && floatMemberValue > 0.1f)
				{
					cachedMaxPowerSwingHitSpeed = floatMemberValue;
				}
				float floatMemberValue2 = ModReflectionHelper.GetFloatMemberValue(memberValue, "MaxPowerPuttHitSpeed", 15f);
				if (!float.IsNaN(floatMemberValue2) && !float.IsInfinity(floatMemberValue2) && floatMemberValue2 > 0.1f)
				{
					cachedMaxPowerPuttHitSpeed = floatMemberValue2;
				}
			}
			object memberValue2 = ModReflectionHelper.GetMemberValue(component, "settings");
			if (memberValue2 == null)
			{
				return;
			}
			object memberValue3 = ModReflectionHelper.GetMemberValue(memberValue2, "Wind");
			if (memberValue3 != null)
			{
				float floatMemberValue3 = ModReflectionHelper.GetFloatMemberValue(memberValue3, "WindFactor", 1f);
				float floatMemberValue4 = ModReflectionHelper.GetFloatMemberValue(memberValue3, "CrossWindFactor", 1f);
				if (!float.IsNaN(floatMemberValue3) && !float.IsInfinity(floatMemberValue3) && floatMemberValue3 >= 0f)
				{
					windFactor = floatMemberValue3;
				}
				if (!float.IsNaN(floatMemberValue4) && !float.IsInfinity(floatMemberValue4) && floatMemberValue4 >= 0f)
				{
					crossWindFactor = floatMemberValue4;
				}
			}
		}
		catch
		{
		}
	}

	private void InitializeWindReflection()
	{
		if (windReflectionInitialized)
		{
			return;
		}
		windReflectionInitialized = true;
		try
		{
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			for (int i = 0; i < assemblies.Length; i++)
			{
				Type type = assemblies[i].GetType("WindManager");
				if (!(type == null))
				{
					cachedWindManagerWindProperty = type.GetProperty("Wind", BindingFlags.Static | BindingFlags.Public);
					if (cachedWindManagerWindProperty != null)
					{
						break;
					}
				}
			}
		}
		catch
		{
		}
	}

	private Vector3 GetCurrentWind()
	{
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_003f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		//IL_0037: Unknown result type (might be due to invalid IL or missing references)
		//IL_0045: Unknown result type (might be due to invalid IL or missing references)
		InitializeWindReflection();
		if (cachedWindManagerWindProperty == null)
		{
			return Vector3.zero;
		}
		try
		{
			object value = cachedWindManagerWindProperty.GetValue(null, null);
			if (value is Vector3)
			{
				return (Vector3)value;
			}
		}
		catch
		{
		}
		return Vector3.zero;
	}

	private Vector3 SimulateLandingPosition(Vector3 shotOrigin, float shotPower, float swingPitch, Vector3 aimTarget, Vector3 wind)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0003: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: 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)
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_0085: Unknown result type (might be due to invalid IL or missing references)
		//IL_008a: Unknown result type (might be due to invalid IL or missing references)
		//IL_004f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0069: Unknown result type (might be due to invalid IL or missing references)
		//IL_0073: Unknown result type (might be due to invalid IL or missing references)
		//IL_0078: Unknown result type (might be due to invalid IL or missing references)
		//IL_007c: Unknown result type (might be due to invalid IL or missing references)
		//IL_003d: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00be: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
		//IL_0100: Unknown result type (might be due to invalid IL or missing references)
		//IL_010a: Unknown result type (might be due to invalid IL or missing references)
		//IL_010b: Unknown result type (might be due to invalid IL or missing references)
		//IL_010f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0114: Unknown result type (might be due to invalid IL or missing references)
		//IL_0099: Unknown result type (might be due to invalid IL or missing references)
		//IL_009e: Unknown result type (might be due to invalid IL or missing references)
		//IL_025f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0128: Unknown result type (might be due to invalid IL or missing references)
		//IL_012a: Unknown result type (might be due to invalid IL or missing references)
		//IL_012c: Unknown result type (might be due to invalid IL or missing references)
		//IL_012e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0132: Unknown result type (might be due to invalid IL or missing references)
		//IL_0137: 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_01af: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b1: 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_014c: Unknown result type (might be due to invalid IL or missing references)
		//IL_014e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0150: 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_0157: Unknown result type (might be due to invalid IL or missing references)
		//IL_0159: Unknown result type (might be due to invalid IL or missing references)
		//IL_015b: 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_0162: Unknown result type (might be due to invalid IL or missing references)
		//IL_016a: Unknown result type (might be due to invalid IL or missing references)
		//IL_016f: 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_017c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0181: 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_0185: 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_018c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0197: Unknown result type (might be due to invalid IL or missing references)
		//IL_0199: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a3: 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_01ad: Unknown result type (might be due to invalid IL or missing references)
		//IL_022d: 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_01dd: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e6: 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_01f8: Unknown result type (might be due to invalid IL or missing references)
		//IL_022a: Unknown result type (might be due to invalid IL or missing references)
		//IL_021e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0220: Unknown result type (might be due to invalid IL or missing references)
		//IL_0224: Unknown result type (might be due to invalid IL or missing references)
		Vector3 val = aimTarget - shotOrigin;
		Vector3 val2 = default(Vector3);
		((Vector3)(ref val2))..ctor(val.x, 0f, val.z);
		Vector3 val3;
		Vector3 val4;
		if (!(((Vector3)(ref val2)).sqrMagnitude > 0.0001f))
		{
			if (!((Object)(object)playerGolfer != (Object)null))
			{
				val3 = Vector3.forward;
			}
			else
			{
				val4 = new Vector3(playerGolfer.transform.forward.x, 0f, playerGolfer.transform.forward.z);
				val3 = ((Vector3)(ref val4)).normalized;
			}
		}
		else
		{
			val3 = ((Vector3)(ref val2)).normalized;
		}
		Vector3 val5 = val3;
		if (((Vector3)(ref val5)).sqrMagnitude < 0.0001f)
		{
			val5 = Vector3.forward;
		}
		float num = swingPitch * ((float)Math.PI / 180f);
		val4 = val5 * Mathf.Cos(num) + Vector3.up * Mathf.Sin(num);
		Vector3 normalized = ((Vector3)(ref val4)).normalized;
		float num2 = Mathf.Max(0.1f, EstimateLaunchSpeedFromPower(shotPower, swingPitch));
		float num3 = Mathf.Clamp(Time.fixedDeltaTime, 0.005f, 0.04f);
		Vector3 gravity = Physics.gravity;
		float runtimeLinearAirDragFactor = GetRuntimeLinearAirDragFactor();
		Vector3 val6 = shotOrigin;
		Vector3 val7 = normalized * num2;
		float num4 = 0f;
		bool flag = true;
		for (int i = 0; i < predictedPathMaxSteps; i++)
		{
			if (!(num4 <= predictedPathMaxTime))
			{
				break;
			}
			Vector3 val8 = val6;
			val7 += gravity * num3;
			if (((Vector3)(ref val7)).sqrMagnitude > 0.0001f)
			{
				Vector3 val9 = Vector3.Project(wind, val7);
				Vector3 val10 = wind - val9;
				Vector3 val11 = val9 * windFactor + val10 * crossWindFactor;
				Vector3 val12 = val7 - val11;
				float sqrMagnitude = ((Vector3)(ref val12)).sqrMagnitude;
				val7 -= val12 * (runtimeLinearAirDragFactor * sqrMagnitude * num3);
			}
			val6 += val7 * num3;
			if (val7.y < 0f)
			{
				flag = false;
			}
			if (!flag && val6.y <= aimTarget.y)
			{
				float y = val8.y;
				float y2 = val6.y;
				float y3 = aimTarget.y;
				if (!Mathf.Approximately(y2, y))
				{
					float num5 = Mathf.Clamp01((y3 - y) / (y2 - y));
					return Vector3.Lerp(val8, val6, num5);
				}
				return val6;
			}
			if (val6.y < -200f)
			{
				break;
			}
			num4 += num3;
		}
		return val6;
	}

	private float EvaluateVerticalAtHorizontalDistanceWithDrag(float launchSpeed, float pitchRad, float targetDistance, float airDragFactor, float deltaTime, float gravityY, float windAlongShot, float windVertical)
	{
		float num = launchSpeed * Mathf.Cos(pitchRad);
		float num2 = launchSpeed * Mathf.Sin(pitchRad);
		if (num <= 0.0001f)
		{
			return float.NaN;
		}
		float num3 = 0f;
		float num4 = 0f;
		float num5 = 0f;
		float num6 = 0f;
		for (int i = 0; i < 600; i++)
		{
			num5 = num3;
			num6 = num4;
			num2 += gravityY * deltaTime;
			float num7 = num * num + num2 * num2;
			if (num7 > 0.0001f)
			{
				float num8 = 1f / num7;
				float num9 = windAlongShot * num + windVertical * num2;
				float num10 = num9 * num8 * num;
				float num11 = num9 * num8 * num2;
				float num12 = windAlongShot - num10;
				float num13 = windVertical - num11;
				float num14 = num10 * windFactor + num12 * crossWindFactor;
				float num15 = num11 * windFactor + num13 * crossWindFactor;
				float num16 = num - num14;
				float num17 = num2 - num15;
				float num18 = num16 * num16 + num17 * num17;
				num -= num16 * (airDragFactor * num18 * deltaTime);
				num2 -= num17 * (airDragFactor * num18 * deltaTime);
			}
			num3 += num * deltaTime;
			num4 += num2 * deltaTime;
			if (num3 >= targetDistance)
			{
				float num19 = num3 - num5;
				if (num19 <= 1E-05f)
				{
					return num4;
				}
				float num20 = Mathf.Clamp01((targetDistance - num5) / num19);
				return Mathf.Lerp(num6, num4, num20);
			}
			if (Mathf.Abs(num) < 0.0001f)
			{
				break;
			}
		}
		return float.NaN;
	}

	private bool TrySolveRequiredSpeedWithDrag(float horizontalDistance, float heightDifference, float swingPitch, float windAlongShot, float windVertical, out float solvedSpeed)
	{
		//IL_004d: Unknown result type (might be due to invalid IL or missing references)
		solvedSpeed = 0f;
		if (horizontalDistance < 0.01f)
		{
			solvedSpeed = 0.1f;
			return true;
		}
		float num = swingPitch * ((float)Math.PI / 180f);
		if (Mathf.Cos(num) <= 0.0001f)
		{
			return false;
		}
		float runtimeLinearAirDragFactor = GetRuntimeLinearAirDragFactor();
		float deltaTime = Mathf.Clamp(Time.fixedDeltaTime, 0.005f, 0.04f);
		float y = Physics.gravity.y;
		float gravityY = ((y < -0.1f) ? y : (-9.81f));
		float num2 = 0f;
		float num3 = float.MaxValue;
		bool flag = false;
		float num4 = 0f;
		float num5 = 0f;
		bool flag2 = false;
		float num6 = 0f;
		float num7 = 0f;
		float num8 = 0f;
		for (float num9 = 2f; num9 <= 240f; num9 += 2f)
		{
			float num10 = EvaluateVerticalAtHorizontalDistanceWithDrag(num9, num, horizontalDistance, runtimeLinearAirDragFactor, deltaTime, gravityY, windAlongShot, windVertical);
			if (!float.IsNaN(num10) && !float.IsInfinity(num10))
			{
				float num11 = num10 - heightDifference;
				float num12 = Mathf.Abs(num11);
				if (num12 < num3)
				{
					num3 = num12;
					num2 = num9;
				}
				if (flag && Mathf.Sign(num11) != Mathf.Sign(num5))
				{
					flag2 = true;
					num6 = num4;
					num7 = num9;
					num8 = num5;
					break;
				}
				flag = true;
				num4 = num9;
				num5 = num11;
			}
		}
		if (flag2)
		{
			for (int i = 0; i < 16; i++)
			{
				float num13 = (num6 + num7) * 0.5f;
				float num14 = EvaluateVerticalAtHorizontalDistanceWithDrag(num13, num, horizontalDistance, runtimeLinearAirDragFactor, deltaTime, gravityY, windAlongShot, windVertical);
				if (float.IsNaN(num14) || float.IsInfinity(num14))
				{
					break;
				}
				float num15 = num14 - heightDifference;
				float num16 = Mathf.Abs(num15);
				if (num16 < num3)
				{
					num3 = num16;
					num2 = num13;
				}
				if (Mathf.Sign(num15) == Mathf.Sign(num8))
				{
					num6 = num13;
					num8 = num15;
				}
				else
				{
					num7 = num13;
				}
			}
		}
		if (num2 <= 0.0001f || float.IsNaN(num2) || float.IsInfinity(num2))
		{
			return false;
		}
		solvedSpeed = num2;
		return true;
	}

	private float CalculatePuttPower(float horizontalDistance)
	{
		InitializeSwingHittableReflection();
		if (!TryGetServerSwingPowerMultiplier(out var swingPowerMultiplier))
		{
			swingPowerMultiplier = 1f;
		}
		float num = Mathf.Max(0.1f, cachedMaxPowerPuttHitSpeed * Mathf.Max(0.01f, swingPowerMultiplier));
		return Mathf.Clamp(Mathf.Sqrt(8f * Mathf.Max(0.01f, horizontalDistance)) / num, 0.05f, 2f);
	}

	private float CalculateRequiredPowerForPitch(float horizontalDistance, float heightDifference, float swingPitch, float windAlongShot, float windVertical)
	{
		if (horizontalDistance < 0.01f)
		{
			return 0.05f;
		}
		if (Mathf.Abs(swingPitch) < 0.5f)
		{
			return CalculatePuttPower(horizontalDistance);
		}
		if (TrySolveRequiredSpeedWithDrag(horizontalDistance, heightDifference, swingPitch, windAlongShot, windVertical, out var solvedSpeed))
		{
			return Mathf.Clamp(EstimatePowerFromLaunchSpeed(solvedSpeed), 0.05f, 2f);
		}
		float num = swingPitch * ((float)Math.PI / 180f);
		float num2 = Mathf.Cos(num);
		float num3 = 2f * num2 * num2 * (horizontalDistance * Mathf.Tan(num) - heightDifference);
		if (num3 <= 0.001f)
		{
			return Mathf.Clamp(CalculateIdealPower(horizontalDistance, heightDifference), 0.05f, 2f);
		}
		float num4 = trajectoryGravity * horizontalDistance * horizontalDistance / num3;
		if (num4 <= 0.001f || float.IsNaN(num4) || float.IsInfinity(num4))
		{
			return Mathf.Clamp(CalculateIdealPower(horizontalDistance, heightDifference), 0.05f, 2f);
		}
		float speed = Mathf.Sqrt(num4);
		return Mathf.Clamp(EstimatePowerFromLaunchSpeed(speed), 0.05f, 2f);
	}

	private float CalculateIdealPower(float distance, float heightDifference)
	{
		float num = Mathf.Max(0.01f, distance);
		float num2 = 45f * ((float)Math.PI / 180f);
		float num3 = Mathf.Cos(num2);
		float num4 = 2f * num3 * num3 * (num * Mathf.Tan(num2) - heightDifference);
		float num6;
		if (num4 > 0.001f)
		{
			float num5 = trajectoryGravity * num * num / num4;
			num6 = ((num5 <= 0.001f || float.IsNaN(num5) || float.IsInfinity(num5)) ? Mathf.Sqrt(num * trajectoryGravity) : Mathf.Sqrt(num5));
		}
		else
		{
			num6 = Mathf.Sqrt(num * trajectoryGravity);
		}
		return Mathf.Clamp(EstimatePowerFromLaunchSpeed(Mathf.Max(0.1f, num6)), 0.05f, 2f);
	}

	private void CalculateIdealSwingParameters(bool forceHoleRefresh)
	{
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0020: Unknown result type (might be due to invalid IL or missing references)
		//IL_003d: Unknown result type (might be due to invalid IL or missing references)
		//IL_002f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		//IL_0053: Unknown result type (might be due to invalid IL or missing references)
		//IL_0054: Unknown result type (might be due to invalid IL or missing references)
		//IL_0059: Unknown result type (might be due to invalid IL or missing references)
		//IL_0060: Unknown result type (might be due to invalid IL or missing references)
		//IL_0065: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
		//IL_0079: Unknown result type (might be due to invalid IL or missing references)
		//IL_007e: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a7: 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_00ad: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
		//IL_008e: Unknown result type (might be due to invalid IL or missing references)
		//IL_008a: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_0108: Unknown result type (might be due to invalid IL or missing references)
		//IL_010d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0116: Unknown result type (might be due to invalid IL or missing references)
		//IL_0143: Unknown result type (might be due to invalid IL or missing references)
		//IL_0148: 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_014c: 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_015c: 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_0165: Unknown result type (might be due to invalid IL or missing references)
		//IL_016a: Unknown result type (might be due to invalid IL or missing references)
		//IL_016c: 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_019b: Unknown result type (might be due to invalid IL or missing references)
		//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_01ac: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
		//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d7: 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_01e5: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
		//IL_01fc: 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_0207: Unknown result type (might be due to invalid IL or missing references)
		//IL_0208: Unknown result type (might be due to invalid IL or missing references)
		//IL_020d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0210: Unknown result type (might be due to invalid IL or missing references)
		//IL_021b: Unknown result type (might be due to invalid IL or missing references)
		//IL_022f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0247: Unknown result type (might be due to invalid IL or missing references)
		//IL_024c: Unknown result type (might be due to invalid IL or missing references)
		//IL_024e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0250: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)playerGolfer == (Object)null)
		{
			return;
		}
		try
		{
			Vector3 position = playerGolfer.transform.position;
			Vector3 playerPosition = (((Object)(object)golfBall != (Object)null) ? golfBall.transform.position : position);
			if (!FindHoleOnly(forceHoleRefresh))
			{
				return;
			}
			currentAimTargetPosition = GetAimTargetPosition(playerPosition);
			currentSwingOriginPosition = GetSwingOriginPosition();
			Vector3 val = (((Object)(object)golfBall != (Object)null) ? golfBall.transform.position : ((currentSwingOriginPosition != Vector3.zero) ? currentSwingOriginPosition : position));
			Vector3 val2 = currentAimTargetPosition - val;
			Vector3 val3 = default(Vector3);
			((Vector3)(ref val3))..ctor(val2.x, 0f, val2.z);
			float magnitude = ((Vector3)(ref val3)).magnitude;
			float y = val2.y;
			if (!TryGetCurrentSwingValues(out var _, out var swingPitch, out var _, out var _))
			{
				swingPitch = idealSwingPitch;
			}
			idealSwingPitch = swingPitch;
			windAimOffset = Vector3.zero;
			Vector3 currentWind = GetCurrentWind();
			float windAlongShot = 0f;
			float y2 = currentWind.y;
			if (((Vector3)(ref currentWind)).sqrMagnitude > 0.01f && ((Vector3)(ref val3)).sqrMagnitude > 0.0001f)
			{
				Vector3 normalized = ((Vector3)(ref val3)).normalized;
				windAlongShot = Vector3.Dot(currentWind, normalized);
				Vector3 val4 = Vector3.Cross(Vector3.up, normalized);
				Vector3 normalized2 = ((Vector3)(ref val4)).normalized;
				if (Mathf.Abs(Vector3.Dot(currentWind, normalized2)) > 0.5f)
				{
					float shotPower = CalculateRequiredPowerForPitch(magnitude, y, idealSwingPitch, windAlongShot, y2);
					float num = Vector3.Dot(SimulateLandingPosition(val, shotPower, idealSwingPitch, currentAimTargetPosition, currentWind) - holePosition, normalized2);
					if (Mathf.Abs(num) > 0.1f)
					{
						windAimOffset = -(normalized2 * num);
						currentAimTargetPosition += windAimOffset;
						val2 = currentAimTargetPosition - val;
						((Vector3)(ref val3))..ctor(val2.x, 0f, val2.z);
						magnitude = ((Vector3)(ref val3)).magnitude;
						y = val2.y;
						if (((Vector3)(ref val3)).sqrMagnitude > 0.0001f)
						{
							normalized = ((Vector3)(ref val3)).normalized;
							windAlongShot = Vector3.Dot(currentWind, normalized);
						}
					}
				}
			}
			float num2 = CalculateRequiredPowerForPitch(magnitude, y, idealSwingPitch, windAlongShot, y2);
			idealSwingPower = num2;
		}
		catch
		{
		}
	}

	private bool FindHoleOnly(bool force)
	{
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		//IL_0047: Unknown result type (might be due to invalid IL or missing references)
		//IL_004d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_0058: Unknown result type (might be due to invalid IL or missing references)
		//IL_005d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)playerGolfer == (Object)null)
		{
			return false;
		}
		float time = Time.time;
		if (!force && time < nextHoleSearchTime)
		{
			return holePosition != Vector3.zero;
		}
		nextHoleSearchTime = time + holeSearchInterval;
		try
		{
			holePosition = Vector3.zero;
			flagPosition = Vector3.zero;
			currentAimTargetPosition = Vector3.zero;
			return FindGolfHoleComponent();
		}
		catch
		{
			return false;
		}
	}

	private bool FindGolfHoleComponent()
	{
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_0048: Unknown result type (might be due to invalid IL or missing references)
		//IL_0094: Unknown result type (might be due to invalid IL or missing references)
		//IL_009f: Unknown result type (might be due to invalid IL or missing references)
		//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ee: 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)
		if ((Object)(object)playerGolfer == (Object)null)
		{
			return false;
		}
		try
		{
			Component[] array = FindAllComponents();
			Vector3 val = (((Object)(object)golfBall != (Object)null) ? golfBall.transform.position : playerGolfer.transform.position);
			float num = float.MaxValue;
			bool result = false;
			Vector3 val3 = default(Vector3);
			foreach (Component val2 in array)
			{
				if (!((Object)(object)val2 == (Object)null) && !(((object)val2).GetType().Name != "GolfHole") && TryResolveHoleCandidate(val2, out var resolvedHolePosition, out var resolvedFlagPosition))
				{
					((Vector3)(ref val3))..ctor(val.x, 0f, val.z);
					Vector3 val4 = new Vector3(resolvedHolePosition.x, 0f, resolvedHolePosition.z) - val3;
					float sqrMagnitude = ((Vector3)(ref val4)).sqrMagnitude;
					if (!(sqrMagnitude <= 0.0025f) && !(sqrMagnitude >= num))
					{
						num = sqrMagnitude;
						holePosition = resolvedHolePosition;
						flagPosition = resolvedFlagPosition;
						result = true;
					}
				}
			}
			return result;
		}
		catch
		{
			return false;
		}
	}

	private bool TryResolveHoleCandidate(Component golfHoleComponent, out Vector3 resolvedHolePosition, out Vector3 resolvedFlagPosition)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: 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_00a1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a8: 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)
		//IL_0142: Unknown result type (might be due to invalid IL or missing references)
		//IL_0149: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
		//IL_018c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0191: Unknown result type (might be due to invalid IL or missing references)
		//IL_0164: Unknown result type (might be due to invalid IL or missing references)
		//IL_0170: Unknown result type (might be due to invalid IL or missing references)
		//IL_015b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0175: Unknown result type (might be due to invalid IL or missing references)
		//IL_017c: Unknown result type (might be due to invalid IL or missing references)
		resolvedHolePosition = Vector3.zero;
		resolvedFlagPosition = Vector3.zero;
		if ((Object)(object)golfHoleComponent == (Object)null)
		{
			return false;
		}
		Vector3 position = golfHoleComponent.transform.position;
		bool flag = false;
		bool flag2 = false;
		Transform val = TryResolveTransformMember(golfHoleComponent, "hole", "Hole", "cup", "Cup", "holeTransform", "HoleTransform", "cupTransform", "CupTransform", "target", "Target");
		if ((Object)(object)val != (Object)null)
		{
			resolvedHolePosition = val.position;
			flag = IsFiniteVector3(resolvedHolePosition);
		}
		if (!flag && TryResolveVector3Member(golfHoleComponent, out var resolvedValue, "holePosition", "HolePosition", "cupPosition", "CupPosition", "targetPosition", "TargetPosition"))
		{
			resolvedHolePosition = resolvedValue;
			flag = true;
		}
		Transform val2 = TryResolveTransformMember(golfHoleComponent, "flag", "Flag", "flagTransform", "FlagTransform");
		if ((Object)(object)val2 != (Object)null)
		{
			resolvedFlagPosition = val2.position;
			flag2 = IsFiniteVector3(resolvedFlagPosition);
		}
		if (!flag)
		{
			resolvedHolePosition = (Vector3)(flag2 ? new Vector3(resolvedFlagPosition.x, position.y, resolvedFlagPosition.z) : position);
			flag = IsFiniteVector3(resolvedHolePosition);
		}
		if (!flag2)
		{
			resolvedFlagPosition = resolvedHolePosition;
			flag2 = flag;
		}
		return flag && flag2;
	}

	private Transform TryResolveTransformMember(object instance, params string[] memberNames)
	{
		//IL_0017: Unknown result type (might be due to invalid IL or missing references)
		//IL_001d: Expected O, but got Unknown
		//IL_0026: Unknown result type (might be due to invalid IL or missing references)
		//IL_003a: Unknown result type (might be due to invalid IL or missing references)
		for (int i = 0; i < memberNames.Length; i++)
		{
			object memberValue = ModReflectionHelper.GetMemberValue(instance, memberNames[i]);
			if (memberValue is Transform)
			{
				return (Transform)memberValue;
			}
			if (memberValue is Component)
			{
				return ((Component)memberValue).transform;
			}
			if (memberValue is GameObject)
			{
				return ((GameObject)memberValue).transform;
			}
		}
		return null;
	}

	private bool TryResolveVector3Member(object instance, out Vector3 resolvedValue, params string[] memberNames)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		//IL_002f: Unknown result type (might be due to invalid IL or missing references)
		resolvedValue = Vector3.zero;
		for (int i = 0; i < memberNames.Length; i++)
		{
			object memberValue = ModReflectionHelper.GetMemberValue(instance, memberNames[i]);
			if (memberValue is Vector3)
			{
				resolvedValue = (Vector3)memberValue;
				return IsFiniteVector3(resolvedValue);
			}
		}
		return false;
	}

	private bool IsFiniteVector3(Vector3 value)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		//IL_0034: 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)
		if (!float.IsNaN(value.x) && !float.IsInfinity(value.x) && !float.IsNaN(value.y) && !float.IsInfinity(value.y) && !float.IsNaN(value.z))
		{
			return !float.IsInfinity(value.z);
		}
		return false;
	}

	private void MarkHudDirty()
	{
		hudDirty = true;
		nextHudRefreshTime = 0f;
	}

	private void MarkTrailVisualSettingsDirty()
	{
		trailVisualSettingsDirty = true;
		actualTrailLineDirty = true;
		predictedTrailLineDirty = true;
		frozenTrailLineDirty = true;
	}

	private void SetHudText(TextMeshProUGUI textComponent, string nextValue, ref string cachedValue)
	{
		if (!((Object)(object)textComponent == (Object)null) && !string.Equals(cachedValue, nextValue, StringComparison.Ordinal))
		{
			cachedValue = nextValue;
			((TMP_Text)textComponent).text = nextValue;
		}
	}

	private void CreateHud()
	{
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Expected O, but got Unknown
		//IL_0057: Unknown result type (might be due to invalid IL or missing references)
		//IL_0094: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f3: 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_0111: Unknown result type (might be due to invalid IL or missing references)
		//IL_0120: 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_0161: Unknown result type (might be due to invalid IL or missing references)
		//IL_0170: Unknown result type (might be due to invalid IL or missing references)
		//IL_017f: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c0: 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_01de: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)hudCanvas != (Object)null))
		{
			hudCanvas = new GameObject("BirdieHudCanvas");
			Canvas obj = hudCanvas.AddComponent<Canvas>();
			obj.renderMode = (RenderMode)0;
			obj.sortingOrder = 10000;
			CanvasScaler obj2 = hudCanvas.AddComponent<CanvasScaler>();
			obj2.uiScaleMode = (ScaleMode)1;
			obj2.referenceResolution = new Vector2(1920f, 1080f);
			hudCanvas.AddComponent<GraphicRaycaster>();
			Object.DontDestroyOnLoad((Object)(object)hudCanvas);
			leftHudText = CreateHudText(hudCanvas.transform, "BirdieHudLeft", new Vector2(0f, 0.86f), new Vector2(0.28f, 1f), new Vector2(14f, -12f), new Vector2(-14f, -14f), 18, (TextAlignmentOptions)257);
			centerHudText = CreateHudText(hudCanvas.transform, "BirdieHudCenter", new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(-64f, -34f), new Vector2(64f, -10f), 12, (TextAlignmentOptions)514);
			rightHudText = CreateHudText(hudCanvas.transform, "BirdieHudRight", new Vector2(0.72f, 0.86f), new Vector2(1f, 1f), new Vector2(14f, -12f), new Vector2(-14f, -14f), 18, (TextAlignmentOptions)260);
			bottomHudText = CreateHudText(hudCanvas.transform, "BirdieHudBottom", new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), new Vector2(-520f, 28f), new Vector2(520f, 84f), 18, (TextAlignmentOptions)1026);
			CreateImpactPreviewHud(hudCanvas.transform);
			CreateItemMenuPanel(hudCanvas.transform);
			EnsureEventSystemExists();
			MarkHudDirty();
			UpdateHud(force: true);
		}
	}

	private TextMeshProUGUI CreateHudText(Transform parent, string name, Vector2 anchorMin, Vector2 anchorMax, Vector2 offsetMin, Vector2 offsetMax, int fontSize, TextAlignmentOptions alignment)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_0030: Unknown result type (might be due to invalid IL or missing references)
		//IL_0046: Unknown result type (might be due to invalid IL or missing references)
		//IL_0070: Unknown result type (might be due to invalid IL or missing references)
		//IL_0075: Unknown result type (might be due to invalid IL or missing references)
		//IL_008b: Unknown result type (might be due to invalid IL or missing references)
		GameObject val = new GameObject(name);
		val.transform.SetParent(parent, false);
		RectTransform obj = val.AddComponent<RectTransform>();
		obj.anchorMin = anchorMin;
		obj.anchorMax = anchorMax;
		obj.offsetMin = offsetMin;
		obj.offsetMax = offsetMax;
		TextMeshProUGUI obj2 = val.AddComponent<TextMeshProUGUI>();
		((TMP_Text)obj2).fontSize = fontSize;
		((TMP_Text)obj2).alignment = alignment;
		((TMP_Text)obj2).richText = true;
		((TMP_Text)obj2).textWrappingMode = (TextWrappingModes)0;
		((TMP_Text)obj2).outlineColor = Color32.op_Implicit(new Color(0f, 0f, 0f, 0.8f));
		((TMP_Text)obj2).outlineWidth = 0.2f;
		((Graphic)obj2).color = Color.white;
		return obj2;
	}

	private void UpdateHud(bool force = false)
	{
		if (!((Object)(object)leftHudText == (Object)null) && !((Object)(object)centerHudText == (Object)null) && !((Object)(object)rightHudText == (Object)null) && !((Object)(object)bottomHudText == (Object)null))
		{
			float unscaledTime = Time.unscaledTime;
			if (force || hudDirty || !(unscaledTime < nextHudRefreshTime))
			{
				nextHudRefreshTime = unscaledTime + hudRefreshInterval;
				hudDirty = false;
				SetHudText(leftHudText, BuildLeftHudText(), ref cachedLeftHudText);
				SetHudText(centerHudText, BuildCenterHudText(), ref cachedCenterHudText);
				SetHudText(rightHudText, BuildRightHudText(), ref cachedRightHudText);
				SetHudText(bottomHudText, BuildBottomHudText(), ref cachedBottomHudText);
			}
		}
	}

	private string BuildLeftHudText()
	{
		//IL_0082: Unknown result type (might be due to invalid IL or missing references)
		//IL_0087: Unknown result type (might be due to invalid IL or missing references)
		//IL_009e: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
		StringBuilder stringBuilder = new StringBuilder(128);
		if (hudShowPlayerInfo)
		{
			stringBuilder.Append("<b><color=#8ED9FF>Player</color></b>\n");
			string localPlayerDisplayName = GetLocalPlayerDisplayName();
			if (playerFound && (Object)(object)playerMovement != (Object)null)
			{
				stringBuilder.Append("<color=#FFFFFF>").Append(ModTextHelper.EscapeRichText(localPlayerDisplayName)).Append("</color>");
			}
			else
			{
				stringBuilder.Append("<color=#A8A8A8>Searching...</color>");
			}
		}
		if (hudShowBallDistance && (Object)(object)golfBall != (Object)null && holePosition != Vector3.zero)
		{
			float num = Vector3.Distance(golfBall.transform.position, holePosition);
			if (hudShowPlayerInfo)
			{
				stringBuilder.Append("\n");
			}
			stringBuilder.Append("<color=#A8A8A8>hole </color><color=#FFD06A>").Append(num.ToString("F1")).Append("m</color>");
		}
		return stringBuilder.ToString();
	}

	private string BuildCenterHudText()
	{
		if (pendingCrateTeleport)
		{
			return "<b><color=#FF8C00>Press <color=#FFFFFF>[" + ModTextHelper.EscapeRichText(randomItemKeyLabel) + "]</color> again to teleport to crate</color></b>\n<color=#FF8C00><size=10>Server pickup not guaranteed.</size></color>";
		}
		if (!hudShowCenterTitle)
		{
			return "";
		}
		return "<b><color=#FFB255>Birdie</color></b>";
	}

	private string BuildRightHudText()
	{
		StringBuilder stringBuilder = new StringBuilder(128);
		string value = (assistEnabled ? "#39FF8F" : "#FF5E5E");
		stringBuilder.Append("<b><color=").Append(value).Append(">Assist [")
			.Append(ModTextHelper.EscapeRichText(assistToggleKeyLabel))
			.Append("]</color></b>");
		if (hudShowIceIndicator && iceImmunityEnabled)
		{
			stringBuilder.Append("\n<b><color=#7FE8FF>Ice Immunity [").Append(ModTextHelper.EscapeRichText(iceToggleKeyLabel)).Append("] ON</color></b>");
		}
		if (noWindEnabled)
		{
			stringBuilder.Append("\n<b><color=#A8E8FF>No Wind [").Append(ModTextHelper.EscapeRichText(noWindKeyLabel)).Append("] ON</color></b>");
		}
		if (perfectShotEnabled)
		{
			stringBuilder.Append("\n<b><color=#FFE55C>Perfect Shot [").Append(ModTextHelper.EscapeRichText(perfectShotKeyLabel)).Append("] ON</color></b>");
		}
		if (noAirDragEnabled)
		{
			stringBuilder.Append("\n<b><color=#B8FFB8>No Air Drag [").Append(ModTextHelper.EscapeRichText(noAirDragKeyLabel)).Append("] ON</color></b>");
		}
		if (speedMultiplierEnabled)
		{
			stringBuilder.Append("\n<b><color=#FFB255>Speed x").Append(speedMultiplierFactor.ToString("F1")).Append(" [")
				.Append(ModTextHelper.EscapeRichText(speedMultiplierKeyLabel))
				.Append("] ON</color></b>");
		}
		if (infiniteAmmoEnabled)
		{
			stringBuilder.Append("\n<b><color=#FF8CE8>Inf Item Usage [").Append(ModTextHelper.EscapeRichText(infiniteAmmoKeyLabel)).Append("] ON</color></b>");
		}
		if (noRecoilEnabled)
		{
			stringBuilder.Append("\n<b><color=#FFA0A0>No Recoil [").Append(ModTextHelper.EscapeRichText(noRecoilKeyLabel)).Append("] ON</color></b>");
		}
		if (noKnockbackEnabled)
		{
			stringBuilder.Append("\n<b><color=#C8A0FF>No Knockback [").Append(ModTextHelper.EscapeRichText(noKnockbackKeyLabel)).Append("] ON</color></b>");
		}
		if (landmineImmunityEnabled)
		{
			stringBuilder.Append("\n<b><color=#FFAA44>Landmine Imm [").Append(ModTextHelper.EscapeRichText(landmineImmunityKeyLabel)).Append("] ON</color></b>");
		}
		if (lockOnAnyDistanceEnabled)
		{
			stringBuilder.Append("\n<b><color=#AAE8FF>Lock-On Any [").Append(ModTextHelper.EscapeRichText(lockOnAnyDistanceKeyLabel)).Append("] ON</color></b>");
		}
		if (nearestAnyBallModeEnabled)
		{
			stringBuilder.Append("\n<b><color=#39FF8F>Nearest Ball [").Append(ModTextHelper.EscapeRichText(nearestBallModeKeyLabel)).Append("] ON</color></b>");
		}
		return stringBuilder.ToString();
	}

	private string BuildBottomHudText()
	{
		if (!hudShowBottomBar)
		{
			return "";
		}
		string text = (assistEnabled ? "<color=#8ED9FF>Hold RMB to aim camera</color>" : ("<color=#A8A8A8>Press " + ModTextHelper.EscapeRichText(assistToggleKeyLabel) + " to enable assist</color>"));
		string text2 = (nearestAnyBallModeEnabled ? "#39FF8F" : "#A8A8A8");
		string text3 = (hudVisible ? "#FFD06A" : "#FF5E5E");
		string text4 = (iceImmunityEnabled ? "#7FE8FF" : "#A8A8A8");
		return text + "  <color=#FFD06A>|</color>  <color=#FFD06A>" + ModTextHelper.EscapeRichText(coffeeBoostKeyLabel) + " - speed</color>  <color=#FFD06A>|</color>  <color=" + text2 + ">" + ModTextHelper.EscapeRichText(nearestBallModeKeyLabel) + " - nearest ball</color>  <color=#FFD06A>|</color>  <color=#FFD06A>" + ModTextHelper.EscapeRichText(unlockAllCosmeticsKeyLabel) + " - cosmetics</color>  <color=#FFD06A>|</color>  <color=#FFD06A>" + ModTextHelper.EscapeRichText(randomItemKeyLabel) + " - crate</color>  <color=#FFD06A>|</color>  <color=" + text4 + ">" + ModTextHelper.EscapeRichText(iceToggleKeyLabel) + " - ice</color>  <color=#FFD06A>|</color>  <color=#FFD06A>" + ModTextHelper.EscapeRichText(settingsKeyLabel) + " - settings</color>  <color=#FFD06A>|</color>  <color=" + text3 + ">" + ModTextHelper.EscapeRichText(hudToggleKeyLabel) + " - hud</color>";
	}

	private void EnsureTrailRenderers()
	{
		bool flag = false;
		if ((Object)(object)shotPathLine == (Object)null)
		{
			CreateActualTrailRenderer();
			flag = true;
		}
		if ((Object)(object)predictedPathLine == (Object)null)
		{
			CreatePredictedTrailRenderer();
			flag = true;
		}
		if ((Object)(object)frozenPredictedPathLine == (Object)null)
		{
			CreateFrozenTrailRenderer();
			flag = true;
		}
		if (flag || trailVisualSettingsDirty)
		{
			ApplyTrailVisualSettings();
			trailVisualSettingsDirty = false;
		}
	}

	private void CreateActualTrailRenderer()
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: Expected O, but got Unknown
		//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d5: Expected O, but got Unknown
		//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
		shotPathObject = new GameObject("BirdieShotTrail");
		Object.DontDestroyOnLoad((Object)(object)shotPathObject);
		shotPathLine = shotPathObject.AddComponent<LineRenderer>();
		shotPathLine.positionCount = 0;
		shotPathLine.startWidth = 0.06f;
		shotPathLine.endWidth = 0.04f;
		shotPathLine.useWorldSpace = true;
		shotPathLine.numCapVertices = 10;
		shotPathLine.numCornerVertices = 10;
		shotPathLine.alignment = (LineAlignment)0;
		shotPathLine.textureMode = (LineTextureMode)0;
		((Renderer)shotPathLine).shadowCastingMode = (ShadowCastingMode)0;
		((Renderer)shotPathLine).receiveShadows = false;
		((Renderer)shotPathLine).sortingOrder = 32760;
		Shader val = Shader.Find("Sprites/Default");
		shotPathMaterial = new Material(val);
		shotPathMaterial.color = new Color(1f, 0.58f, 0.2f, 1f);
		shotPathMaterial.renderQueue = 5000;
		if (shotPathMaterial.HasProperty("_ZWrite"))
		{
			shotPathMaterial.SetInt("_ZWrite", 0);
		}
		if (shotPathMaterial.HasProperty("_ZTest"))
		{
			shotPathMaterial.SetInt("_ZTest", 8);
		}
		((Renderer)shotPathLine).material = shotPathMaterial;
	}

	private void CreatePredictedTrailRenderer()
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: Expected O, but got Unknown
		//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d3: Expected O, but got Unknown
		//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
		predictedPathObject = new GameObject("BirdiePredictedTrail");
		Object.DontDestroyOnLoad((Object)(object)predictedPathObject);
		predictedPathLine = predictedPathObject.AddComponent<LineRenderer>();
		predictedPathLine.positionCount = 0;
		predictedPathLine.startWidth = 0.03f;
		predictedPathLine.endWidth = 0.02f;
		predictedPathLine.useWorldSpace = true;
		predictedPathLine.numCapVertices = 8;
		predictedPathLine.numCornerVertices = 8;
		predictedPathLine.alignment = (LineAlignment)0;
		predictedPathLine.textureMode = (LineTextureMode)0;
		((Renderer)predictedPathLine).shadowCastingMode = (ShadowCastingMode)0;
		((Renderer)predictedPathLine).receiveShadows = false;
		((Renderer)predictedPathLine).sortingOrder = 32759;
		Shader val = Shader.Find("Sprites/Default");
		predictedPathMaterial = new Material(val);
		predictedPathMaterial.color = new Color(0.36f, 0.95f, 0.46f, 0.95f);
		predictedPathMaterial.renderQueue = 4999;
		if (predictedPathMaterial.HasProperty("_ZWrite"))
		{
			predictedPathMaterial.SetInt("_ZWrite", 0);
		}
		if (predictedPathMaterial.HasProperty("_ZTest"))
		{
			predictedPathMaterial.SetInt("_ZTest", 8);
		}
		((Renderer)predictedPathLine).material = predictedPathMaterial;
	}

	private void CreateFrozenTrailRenderer()
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: Expected O, but got Unknown
		//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d3: Expected O, but got Unknown
		//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
		frozenPredictedPathObject = new GameObject("BirdieFrozenTrail");
		Object.DontDestroyOnLoad((Object)(object)frozenPredictedPathObject);
		frozenPredictedPathLine = frozenPredictedPathObject.AddComponent<LineRenderer>();
		frozenPredictedPathLine.positionCount = 0;
		frozenPredictedPathLine.startWidth = 0.034f;
		frozenPredictedPathLine.endWidth = 0.024f;
		frozenPredictedPathLine.useWorldSpace = true;
		frozenPredictedPathLine.numCapVertices = 8;
		frozenPredictedPathLine.numCornerVertices = 8;
		frozenPredictedPathLine.alignment = (LineAlignment)0;
		frozenPredictedPathLine.textureMode = (LineTextureMode)0;
		((Renderer)frozenPredictedPathLine).shadowCastingMode = (ShadowCastingMode)0;
		((Renderer)frozenPredictedPathLine).receiveShadows = false;
		((Renderer)frozenPredictedPathLine).sortingOrder = 32758;
		Shader val = Shader.Find("Sprites/Default");
		frozenPredictedPathMaterial = new Material(val);
		frozenPredictedPathMaterial.color = new Color(0.36f, 0.74f, 1f, 0.92f);
		frozenPredictedPathMaterial.renderQueue = 4998;
		if (frozenPredictedPathMaterial.HasProperty("_ZWrite"))
		{
			frozenPredictedPathMaterial.SetInt("_ZWrite", 0);
		}
		if (frozenPredictedPathMaterial.HasProperty("_ZTest"))
		{
			frozenPredictedPathMaterial.SetInt("_ZTest", 8);
		}
		((Renderer)frozenPredictedPathLine).material = frozenPredictedPathMaterial;
	}

	private void ResetTrailState()
	{
		//IL_0074: Unknown result type (might be due to invalid IL or missing references)
		//IL_0079: Unknown result type (might be due to invalid IL or missing references)
		//IL_0084: Unknown result type (might be due to invalid IL or missing references)
		//IL_0089: Unknown result type (might be due to invalid IL or missing references)
		//IL_0062: Unknown result type (might be due to invalid IL or missing references)
		//IL_008e: Unknown result type (might be due to invalid IL or missing references)
		shotPathPoints.Clear();
		predictedPathPoints.Clear();
		frozenPredictedPathPoints.Clear();
		isRecordingShotPath = false;
		observedBallMotionSinceLastShot = false;
		lockLivePredictedPath = false;
		predictedPathCacheValid = false;
		predictedTrajectoryHideStartTime = 0f;
		lastShotPathMoveTime = 0f;
		lastShotPathBallPosition = (((Object)(object)golfBall != (Object)null) ? (golfBall.transform.position + Vector3.up * shotPathHeightOffset) : Vector3.zero);
		actualTrailLineDirty = false;
		predictedTrailLineDirty = false;
		frozenTrailLineDirty = false;
		if ((Object)(object)shotPathLine != (Object)null)
		{
			shotPathLine.positionCount = 0;
		}
		if ((Object)(object)predictedPathLine != (Object)null)
		{
			predictedPathLine.positionCount = 0;
		}
		if ((Object)(object)frozenPredictedPathLine != (Object)null)
		{
			frozenPredictedPathLine.positionCount = 0;
		}
		ResetImpactPreviewCache(resetPredicted: true, resetFrozen: true);
	}

	private void SyncLineRendererPoints(LineRenderer lineRenderer, List<Vector3> points, ref bool lineDirty, bool allowIncrementalAppend)
	{
		//IL_004c: Unknown result type (might be due to invalid IL or missing references)
		//IL_006f: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)lineRenderer == (Object)null)
		{
			return;
		}
		int count = points.Count;
		if (count <= 0)
		{
			if (lineRenderer.positionCount != 0)
			{
				lineRenderer.positionCount = 0;
			}
			lineDirty = false;
			return;
		}
		if (!lineDirty && allowIncrementalAppend && lineRenderer.positionCount == count - 1)
		{
			lineRenderer.positionCount = count;
			lineRenderer.SetPosition(count - 1, points[count - 1]);
			return;
		}
		if (lineRenderer.positionCount != count)
		{
			lineRenderer.positionCount = count;
		}
		for (int i = 0; i < count; i++)
		{
			lineRenderer.SetPosition(i, points[i]);
		}
		lineDirty = false;
	}

	private void ApplyActualTrailToLine()
	{
		if ((Object)(object)shotPathLine == (Object)null || !actualTrailEnabled)
		{
			if ((Object)(object)shotPathLine != (Object)null)
			{
				shotPathLine.positionCount = 0;
			}
		}
		else
		{
			SyncLineRendererPoints(shotPathLine, shotPathPoints, ref actualTrailLineDirty, allowIncrementalAppend: true);
		}
	}

	private void ApplyPredictedTrailToLine()
	{
		if ((Object)(object)predictedPathLine == (Object)null || !predictedTrailEnabled)
		{
			if ((Object)(object)predictedPathLine != (Object)null)
			{
				predictedPathLine.positionCount = 0;
			}
		}
		else
		{
			SyncLineRendererPoints(predictedPathLine, predictedPathPoints, ref predictedTrailLineDirty, allowIncrementalAppend: false);
		}
	}

	private void ApplyFrozenTrailToLine()
	{
		if ((Object)(object)frozenPredictedPathLine == (Object)null || !frozenTrailEnabled)
		{
			if ((Object)(object)frozenPredictedPathLine != (Object)null)
			{
				frozenPredictedPathLine.positionCount = 0;
			}
		}
		else
		{
			SyncLineRendererPoints(frozenPredictedPathLine, frozenPredictedPathPoints, ref frozenTrailLineDirty, allowIncrementalAppend: false);
		}
	}

	private void ClearPredictedTrails(bool hideFrozenSnapshot)
	{
		predictedPathPoints.Clear();
		predictedPathCacheValid = false;
		predictedTrailLineDirty = false;
		if ((Object)(object)predictedPathLine != (Object)null)
		{
			predictedPathLine.positionCount = 0;
		}
		ResetImpactPreviewCache(resetPredicted: true, resetFrozen: false);
		if (hideFrozenSnapshot)
		{
			frozenPredictedPathPoints.Clear();
			frozenTrailLineDirty = false;
			if ((Object)(object)frozenPredictedPathLine != (Object)null)
			{
				frozenPredictedPathLine.positionCount = 0;
			}
			ResetImpactPreviewCache(resetPredicted: false, resetFrozen: true);
		}
	}

	private void CreateItemMenuPanel(Transform parent)
	{
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Expected O, but got Unknown
		//IL_0047: Unknown result type (might be due to invalid IL or missing references)
		//IL_005c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0071: Unknown result type (might be due to invalid IL or missing references)
		//IL_0086: Unknown result type (might be due to invalid IL or missing references)
		//IL_009a: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d8: Expected O, but got Unknown
		//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
		//IL_0101: Unknown result type (might be due to invalid IL or missing references)
		//IL_0116: Unknown result type (might be due to invalid IL or missing references)
		//IL_012a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0192: Unknown result type (might be due to invalid IL or missing references)
		//IL_0197: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)itemMenuPanelObject != (Object)null))
		{
			itemMenuPanelObject = new GameObject("BirdieItemMenuPanel");
			itemMenuPanelObject.transform.SetParent(parent, false);
			RectTransform obj = itemMenuPanelObject.AddComponent<RectTransform>();
			obj.anchorMin = new Vector2(0.5f, 0.5f);
			obj.anchorMax = new Vector2(0.5f, 0.5f);
			obj.pivot = new Vector2(0.5f, 0.5f);
			obj.offsetMin = new Vector2(-200f, -130f);
			obj.offsetMax = new Vector2(200f, 130f);
			((Graphic)itemMenuPanelObject.AddComponent<Image>()).color = new Color(0.03f, 0.05f, 0.08f, 0.92f);
			GameObject val = new GameObject("BirdieItemMenuText");
			val.transform.SetParent(itemMenuPanelObject.transform, false);
			RectTransform obj2 = val.AddComponent<RectTransform>();
			obj2.anchorMin = Vector2.zero;
			obj2.anchorMax = Vector2.one;
			obj2.offsetMin = new Vector2(14f, 10f);
			obj2.offsetMax = new Vector2(-14f, -10f);
			itemMenuText = val.AddComponent<TextMeshProUGUI>();
			((TMP_Text)itemMenuText).fontSize = 16f;
			((TMP_Text)itemMenuText).alignment = (TextAlignmentOptions)257;
			((TMP_Text)itemMenuText).richText = true;
			((TMP_Text)itemMenuText).textWrappingMode = (TextWrappingModes)0;
			((TMP_Text)itemMenuText).outlineColor = Color32.op_Implicit(new Color(0f, 0f, 0f, 0.8f));
			((TMP_Text)itemMenuText).outlineWidth = 0.2f;
			((Graphic)itemMenuText).color = Color.white;
			itemMenuPanelObject.SetActive(false);
			RefreshItemMenuText();
		}
	}

	private void RefreshItemMenuText()
	{
		if ((Object)(object)itemMenuText == (Object)null)
		{
			return;
		}
		StringBuilder stringBuilder = new StringBuilder(512);
		stringBuilder.AppendLine("<b><color=#FFB255>Item Spawner</color></b>  <color=#A8A8A8>press key to spawn  |  " + ModTextHelper.EscapeRichText(itemSpawnerKeyLabel) + " or Esc to close</color>");
		stringBuilder.AppendLine();
		for (int i = 0; i < SpawnableItemTypeInts.Length; i++)
		{
			stringBuilder.Append("  <color=#FFD06A><b>").Append(ModTextHelper.EscapeRichText(SpawnableItemKeyLabels[i])).Append("</b></color>  ")
				.Append(ModTextHelper.EscapeRichText(SpawnableItemNames[i]));
			if (SpawnableItemTypeInts[i] != 1)
			{
				stringBuilder.Append("  <color=#666666>[HOST]</color>");
			}
			stringBuilder.AppendLine();
		}
		((TMP_Text)itemMenuText).text = stringBuilder.ToString();
	}

	private void UpdateItemMenuVisibility()
	{
		if (!((Object)(object)itemMenuPanelObject == (Object)null))
		{
			itemMenuPanelObject.SetActive(itemMenuOpen);
		}
	}

	private void EnsureEventSystemExists()
	{
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		//IL_0017: Unknown result type (might be due to invalid IL or missing references)
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: Expected O, but got Unknown
		try
		{
			if ((Object)(object)EventSystem.current == (Object)null)
			{
				GameObject val = new GameObject("BirdieEventSystem");
				val.AddComponent<EventSystem>();
				val.AddComponent<StandaloneInputModule>();
				Object.DontDestroyOnLoad((Object)val);
			}
		}
		catch
		{
		}
	}

	private void ApplyHudVisibility()
	{
		bool active = hudVisible && (hudShowPlayerInfo || hudShowBallDistance);
		if ((Object)(object)leftHudText != (Object)null)
		{
			((Component)leftHudText).gameObject.SetActive(active);
		}
		if ((Object)(object)centerHudText != (Object)null)
		{
			((Component)centerHudText).gameObject.SetActive(hudVisible);
		}
		if ((Object)(object)rightHudText != (Object)null)
		{
			((Component)rightHudText).gameObject.SetActive(hudVisible);
		}
		if ((Object)(object)bottomHudText != (Object)null)
		{
			((Component)bottomHudText).gameObject.SetActive(hudVisible && hudShowBottomBar);
		}
	}

	internal void WeatherSystemInit()
	{
		_currentWeatherType = 0;
		_weatherPhysicsApplied = false;
		_originalAirDragCached = false;
		_originalWindForceScaleCached = false;
		_lightningStrikePending = false;
		_tornadoPositionSet = false;
		_gustRunning = false;
		_lightningRunning = false;
		_wAirDragReady = false;
		_currentRainDragMul = 1f;
		_cachedWmObject = null;
		_nextWmCacheRefreshTime = 0f;
		BirdieWeatherBridge.EnsureHandlersRegistered();
		BirdieCoroutine.Start(LoadWeatherSounds());
		SubscribeHoleChangeEvent();
	}

	internal void WeatherSystemUpdate()
	{
		//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
		//IL_00be: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00db: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e8: 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_00f5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
		if (BirdieWeatherBridge.ReceivedNewWeather)
		{
			BirdieWeatherBridge.ReceivedNewWeather = false;
			ApplyWeather(BirdieWeatherBridge.ReceivedWeatherType);
		}
		if (IsNetworkHost() && _currentWeatherType != 0)
		{
			float time = Time.time;
			if (time >= _nextGustTime && !_gustRunning)
			{
				_gustRunning = true;
				BirdieCoroutine.Start(HostGustCoroutine());
			}
			if (_currentWeatherType == 7 && time >= _nextLightningTime && !_lightningRunning)
			{
				_lightningRunning = true;
				BirdieCoroutine.Start(HostLightningCoroutine());
			}
			if (_currentWeatherType == 8)
			{
				_tornadoMoveTimer -= Time.deltaTime;
				if (_tornadoMoveTimer <= 0f)
				{
					_tornadoMoveTimer = 5f;
					Vector2 insideUnitCircle = Random.insideUnitCircle;
					Vector2 normalized = ((Vector2)(ref insideUnitCircle)).normalized;
					float num = Random.Range(4f, 12f);
					_tornadoWorldPosition += new Vector3(normalized.x * num, 0f, normalized.y * num);
				}
			}
		}
		if (_currentWeatherType != 0 && _weatherPhysicsApplied)
		{
			UpdateWindDragBonus();
			TryErraticWindShift();
		}
		WeatherVFXUpdate();
	}

	internal void WeatherSystemLateUpdate()
	{
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0073: Unknown result type (might be due to invalid IL or missing references)
		//IL_0078: Unknown result type (might be due to invalid IL or missing references)
		//IL_007d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0080: Unknown result type (might be due to invalid IL or missing references)
		//IL_0085: 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_0090: Unknown result type (might be due to invalid IL or missing references)
		//IL_0095: Unknown result type (might be due to invalid IL or missing references)
		//IL_009b: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
		if (_currentWeatherType != 8 || !_tornadoPositionSet || (Object)(object)playerMovement == (Object)null || Vector3.Distance(playerMovement.transform.position, _tornadoWorldPosition) >= 12f || Time.time < _tornadoFlingNextTime)
		{
			return;
		}
		_tornadoFlingNextTime = Time.time + 1.2f;
		try
		{
			Vector3 val = playerMovement.transform.position - _tornadoWorldPosition;
			Vector3 normalized = ((Vector3)(ref val)).normalized;
			Vector3 vel = Vector3.up * 18f + normalized * 14f;
			FlingPlayer(playerMovement, vel);
		}
		catch (Exception ex)
		{
			BirdieLog.Warning("[Birdie] Tornado fling: " + ex.Message);
		}
	}

	internal void ApplyWeather(byte weatherType)
	{
		StopWeatherEffects();
		_currentWeatherType = weatherType;
		if (weatherType != 0)
		{
			ApplyWeatherPhysics((WeatherType)weatherType);
			WeatherVFXStart((WeatherType)weatherType);
			if (IsNetworkHost())
			{
				_nextGustTime = Time.time + Random.Range(2f, 6f);
				_nextLightningTime = Time.time + Random.Range(15f, 25f);
				_gustRunning = (_lightningRunning = false);
			}
			WeatherType weatherType2 = (WeatherType)weatherType;
			BirdieLog.Msg("[Birdie] Weather: " + weatherType2);
		}
	}

	private void StopWeatherEffects()
	{
		RestoreWeatherPhysics();
		WeatherVFXStop();
		_gustRunning = (_lightningRunning = (_lightningStrikePending = (_tornadoPositionSet = false)));
	}

	private void ApplyWeatherPhysics(WeatherType t)
	{
		//IL_0142: Unknown result type (might be due to invalid IL or missing references)
		//IL_0147: Unknown result type (might be due to invalid IL or missing references)
		//IL_014b: 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_0156: Unknown result type (might be due to invalid IL or missing references)
		//IL_0163: Unknown result type (might be due to invalid IL or missing references)
		//IL_0168: Unknown result type (might be due to invalid IL or missing references)
		//IL_0173: Unknown result type (might be due to invalid IL or missing references)
		//IL_0179: 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)
		float num = 1f;
		switch (t)
		{
		case WeatherType.RainLight:
			num = 1.25f;
			break;
		case WeatherType.RainMedium:
			num = 1.55f;
			break;
		case WeatherType.RainHeavy:
			num = 2f;
			break;
		case WeatherType.Thunderstorm:
			num = 2.2f;
			break;
		case WeatherType.Tornado:
			num = 2.8f;
			break;
		}
		_currentRainDragMul = num;
		if (num != 1f)
		{
			ApplyDragMultiplier(num);
		}
		_nextWindDragUpdateTime = 0f;
		_nextErraticWindShiftTime = Time.time + Random.Range(3f, 6f);
		float scale = 1f;
		switch (t)
		{
		case WeatherType.RainLight:
			scale = 1.1f;
			break;
		case WeatherType.RainMedium:
			scale = 1.35f;
			break;
		case WeatherType.RainHeavy:
			scale = 1.7f;
			break;
		case WeatherType.WindGustsLight:
			scale = 2.5f;
			break;
		case WeatherType.WindGustsMedium:
			scale = 5f;
			break;
		case WeatherType.WindGustsHeavy:
			scale = 9f;
			break;
		case WeatherType.Thunderstorm:
			scale = 4f;
			break;
		case WeatherType.Tornado:
			scale = 11f;
			break;
		}
		ApplyWindScale(scale);
		if (IsNetworkHost())
		{
			SetBaseWind(t);
		}
		_weatherPhysicsApplied = true;
		if (t == WeatherType.Tornado && (Object)(object)playerMovement != (Object)null)
		{
			float num2 = Random.Range(15f, 22f);
			Vector2 insideUnitCircle = Random.insideUnitCircle;
			Vector2 val = ((Vector2)(ref insideUnitCircle)).normalized * num2;
			_tornadoWorldPosition = playerMovement.transform.position + new Vector3(val.x, 0f, val.y);
			_tornadoPositionSet = true;
			_tornadoMoveTimer = 5f;
			_tornadoFlingNextTime = 0f;
		}
	}

	private void RestoreWeatherPhysics()
	{
		if (_weatherPhysicsApplied)
		{
			_weatherPhysicsApplied = false;
			_currentRainDragMul = 1f;
			if (_originalAirDragCached)
			{
				SetDragValue(_originalLinearAirDrag);
			}
			if (_originalWindForceScaleCached)
			{
				SetWindScaleValue(_originalWindForceScale);
			}
		}
	}

	private void EnsureDragReflection()
	{
		if (_wAirDragReady)
		{
			return;
		}
		try
		{
			object golfBallSettingsObject = GetGolfBallSettingsObject();
			if (golfBallSettingsObject != null)
			{
				Type type = golfBallSettingsObject.GetType();
				_wAirDragField = type.GetField("<LinearAirDragFactor>k__BackingField", BindingFlags.Instance | BindingFlags.NonPublic);
				if (_wAirDragField == null || _wAirDragField.FieldType != typeof(float))
				{
					BirdieLog.Warning("[Birdie] Weather drag: field not found on " + type.Name);
					_wAirDragField = null;
					return;
				}
				_wBallSettings = golfBallSettingsObject;
				_originalLinearAirDrag = (float)_wAirDragField.GetValue(golfBallSettingsObject);
				_originalAirDragCached = true;
				_wAirDragReady = true;
			}
		}
		catch (Exception ex)
		{
			BirdieLog.Warning("[Birdie] Weather drag reflection: " + ex.Message);
		}
	}

	private void ApplyDragMultiplier(float mul)
	{
		EnsureDragReflection();
		if (_originalAirDragCached)
		{
			SetDragValue(_originalLinearAirDrag * mul);
		}
	}

	private void SetDragValue(float v)
	{
		if (_wAirDragField == null || _wBallSettings == null)
		{
			return;
		}
		try
		{
			_wAirDragField.SetValue(_wBallSettings, v);
		}
		catch (Exception ex)
		{
			BirdieLog.Warning("[Birdie] Weather SetDrag: " + ex.Message);
		}
	}

	private void EnsureWindReflection()
	{
		if (_wWindReady)
		{
			return;
		}
		_wWindReady = true;
		try
		{
			Type type = null;
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			for (int i = 0; i < assemblies.Length; i++)
			{
				type = assemblies[i].GetType("WindManager");
				if (type != null)
				{
					break;
				}
			}
			if (type == null)
			{
				BirdieLog.Warning("[Birdie] Weather wind: WindManager not found");
				return;
			}
			Object val = Object.FindObjectOfType(type);
			if (val == (Object)null)
			{
				BirdieLog.Warning("[Birdie] Weather wind: WindManager not in scene");
				return;
			}
			FieldInfo field = type.GetField("windSettings", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (field == null)
			{
				BirdieLog.Warning("[Birdie] Weather wind: windSettings field missing");
				return;
			}
			object value = field.GetValue(val);
			if (value == null)
			{
				BirdieLog.Warning("[Birdie] Weather wind: windSettings null");
				return;
			}
			FieldInfo field2 = value.GetType().GetField("forceScale", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (field2 == null || field2.FieldType != typeof(float))
			{
				BirdieLog.Warning("[Birdie] Weather wind: forceScale not found");
				return;
			}
			_wWindSettings = value;
			_wWindScaleField = field2;
			_originalWindForceScale = (float)field2.GetValue(value);
			_originalWindForceScaleCached = true;
		}
		catch (Exception ex)
		{
			BirdieLog.Warning("[Birdie] Weather wind reflection: " + ex.Message);
		}
	}

	private void ApplyWindScale(float scale)
	{
		EnsureWindReflection();
		SetWindScaleValue(scale);
	}

	private void SetWindScaleValue(float v)
	{
		if (_wWindScaleField == null || _wWindSettings == null)
		{
			return;
		}
		try
		{
			_wWindScaleField.SetValue(_wWindSettings, v);
		}
		catch (Exception ex)
		{
			BirdieLog.Warning("[Birdie] Weather SetWindScale: " + ex.Message);
		}
	}

	private void EnsureWmSyncReflection()
	{
		if (_wWmReady)
		{
			return;
		}
		_wWmReady = true;
		try
		{
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			foreach (Assembly assembly in assemblies)
			{
				_wWmType = assembly.GetType("WindManager");
				if (_wWmType != null)
				{
					break;
				}
			}
			if (_wWmType == null)
			{
				BirdieLog.Warning("[Birdie] Weather WM sync: type not found");
				return;
			}
			_wWmSpeedProp = _wWmType.GetProperty("NetworkcurrentWindSpeed", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			_wWmAngleProp = _wWmType.GetProperty("NetworkcurrentWindAngle", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (_wWmSpeedProp == null)
			{
				BirdieLog.Warning("[Birdie] Weather WM: NetworkcurrentWindSpeed missing");
			}
			if (_wWmAngleProp == null)
			{
				BirdieLog.Warning("[Birdie] Weather WM: NetworkcurrentWindAngle missing");
			}
		}
		catch (Exception ex)
		{
			BirdieLog.Warning("[Birdie] Weather WM sync reflection: " + ex.Message);
		}
	}

	private IEnumerator HostGustCoroutine()
	{
		EnsureWmSyncReflection();
		while (_currentWeatherType != 0)
		{
			yield return (object)new WaitForSeconds(Random.Range(5f, 13f));
			if (_currentWeatherType == 0)
			{
				break;
			}
			float baseI = GustIntensity((WeatherType)_currentWeatherType);
			if (baseI <= 0f)
			{
				break;
			}
			int bursts = Random.Range(1, 4);
			for (int i = 0; i < bursts; i++)
			{
				int num = (int)(baseI * Random.Range(0.7f, 1f));
				int num2 = Random.Range(0, 360);
				try
				{
					if (_wWmType != null && _wWmSpeedProp != null && _wWmAngleProp != null)
					{
						Object val = Object.FindObjectOfType(_wWmType);
						if (val != (Object)null)
						{
							_wWmSpeedProp.SetValue(val, num, null);
							_wWmAngleProp.SetValue(val, num2, null);
						}
					}
				}
				catch (Exception ex)
				{
					BirdieLog.Warning("[Birdie] Gust set: " + ex.Message);
				}
				PlayGustSound();
				if (i < bursts - 1)
				{
					yield return (object)new WaitForSeconds(Random.Range(0.8f, 2.5f));
				}
			}
		}
		_gustRunning = false;
	}

	private IEnumerator HostLightningCoroutine()
	{
		while (_currentWeatherType == 7)
		{
			yield return (object)new WaitForSeconds(Random.Range(25f, 35f));
			if (_currentWeatherType != 7)
			{
				break;
			}
			try
			{
				Type type = null;
				Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
				for (int i = 0; i < assemblies.Length; i++)
				{
					type = assemblies[i].GetType("PlayerMovement");
					if (type != null)
					{
						break;
					}
				}
				if (type == null)
				{
					continue;
				}
				Object[] array = Object.FindObjectsOfType(type);
				if (array != null && array.Length != 0)
				{
					Object obj = array[Random.Range(0, array.Length)];
					Component val = (Component)(object)((obj is Component) ? obj : null);
					if (!((Object)(object)val == (Object)null))
					{
						_pendingLightningStrikePosition = val.transform.position;
						_lightningStrikePending = true;
						Vector3 val2 = Vector3.up * 28f;
						Vector3 insideUnitSphere = Random.insideUnitSphere;
						Vector3 vel = val2 + ((Vector3)(ref insideUnitSphere)).normalized * 16f;
						FlingPlayer(val, vel);
					}
				}
			}
			catch (Exception ex)
			{
				BirdieLog.Warning("[Birdie] Lightning strike: " + ex.Message);
			}
		}
		_lightningRunning = false;
	}

	private float GustIntensity(WeatherType t)
	{
		return t switch
		{
			WeatherType.WindGustsLight => 20f, 
			WeatherType.WindGustsMedium => 45f, 
			WeatherType.WindGustsHeavy => 75f, 
			WeatherType.Thunderstorm => 50f, 
			WeatherType.Tornado => 90f, 
			WeatherType.RainLight => 8f, 
			WeatherType.RainMedium => 12f, 
			WeatherType.RainHeavy => 18f, 
			_ => 0f, 
		};
	}

	private void FlingPlayer(Component target, Vector3 vel)
	{
		//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)target == (Object)null)
		{
			return;
		}
		try
		{
			FieldInfo field = ((object)target).GetType().GetField("rigidbody", BindingFlags.Instance | BindingFlags.NonPublic);
			Rigidbody val = (Rigidbody)((field != null) ? /*isinst with value type is only supported in some contexts*/: null);
			if ((Object)(object)val == (Object)null)
			{
				val = target.GetComponent<Rigidbody>() ?? target.GetComponentInChildren<Rigidbody>() ?? target.GetComponentInParent<Rigidbody>();
			}
			if (!((Object)(object)val == (Object)null))
			{
				val.isKinematic = false;
				PropertyInfo propertyInfo = typeof(Rigidbody).GetProperty("linearVelocity") ?? typeof(Rigidbody).GetProperty("velocity");
				if (propertyInfo != null && propertyInfo.CanWrite)
				{
					propertyInfo.SetValue(val, vel);
				}
			}
		}
		catch (Exception ex)
		{
			BirdieLog.Warning("[Birdie] FlingPlayer: " + ex.Message);
		}
	}

	private object GetCachedWindManager()
	{
		if (!(Time.time >= _nextWmCacheRefreshTime) && _cachedWmObject != null)
		{
			object cachedWmObject = _cachedWmObject;
			Object val = (Object)((cachedWmObject is Object) ? cachedWmObject : null);
			if (val == null || !(val == (Object)null))
			{
				goto IL_006c;
			}
		}
		_nextWmCacheRefreshTime = Time.time + 10f;
		EnsureWmSyncReflection();
		if (_wWmType == null)
		{
			_cachedWmObject = null;
			return null;
		}
		_cachedWmObject = Object.FindObjectOfType(_wWmType);
		goto IL_006c;
		IL_006c:
		return _cachedWmObject;
	}

	private float GetCurrentWindSpeed()
	{
		if (_wWmSpeedProp == null)
		{
			return 0f;
		}
		try
		{
			object cachedWindManager = GetCachedWindManager();
			if (cachedWindManager == null)
			{
				return 0f;
			}
			return Convert.ToSingle(_wWmSpeedProp.GetValue(cachedWindManager, null));
		}
		catch
		{
			return 0f;
		}
	}

	private void UpdateWindDragBonus()
	{
		if (!(Time.time < _nextWindDragUpdateTime))
		{
			_nextWindDragUpdateTime = Time.time + 1f;
			if (_originalAirDragCached && !(_currentRainDragMul <= 0f))
			{
				float currentWindSpeed = GetCurrentWindSpeed();
				float num = Mathf.Clamp(Mathf.Max(0f, currentWindSpeed - 10f) * 0.005f, 0f, 0.4f);
				float dragValue = _originalLinearAirDrag * _currentRainDragMul * (1f + num);
				SetDragValue(dragValue);
			}
		}
	}

	private void TryErraticWindShift()
	{
		WeatherType currentWeatherType = (WeatherType)_currentWeatherType;
		if ((currentWeatherType != WeatherType.RainHeavy && currentWeatherType != WeatherType.Thunderstorm) || Time.time < _nextErraticWindShiftTime)
		{
			return;
		}
		_nextErraticWindShiftTime = Time.time + Random.Range(2.5f, 5.5f);
		if (_wWmAngleProp == null)
		{
			return;
		}
		try
		{
			object cachedWindManager = GetCachedWindManager();
			if (cachedWindManager != null)
			{
				int num = Convert.ToInt32(_wWmAngleProp.GetValue(cachedWindManager, null));
				int num2 = Random.Range(-28, 29);
				int num3 = ((num + num2) % 360 + 360) % 360;
				_wWmAngleProp.SetValue(cachedWindManager, num3, null);
			}
		}
		catch (Exception ex)
		{
			BirdieLog.Warning("[Birdie] Erratic wind: " + ex.Message);
		}
	}

	private void SetBaseWind(WeatherType t)
	{
		int num;
		switch (t)
		{
		default:
			return;
		case WeatherType.RainLight:
			num = 8;
			break;
		case WeatherType.RainMedium:
			num = 14;
			break;
		case WeatherType.RainHeavy:
			num = 20;
			break;
		case WeatherType.WindGustsLight:
			num = 15;
			break;
		case WeatherType.WindGustsMedium:
			num = 30;
			break;
		case WeatherType.WindGustsHeavy:
			num = 50;
			break;
		case WeatherType.Thunderstorm:
			num = 35;
			break;
		case WeatherType.Tornado:
			num = 60;
			break;
		}
		EnsureWmSyncReflection();
		try
		{
			if (!(_wWmType == null) && !(_wWmSpeedProp == null) && !(_wWmAngleProp == null))
			{
				Object val = Object.FindObjectOfType(_wWmType);
				if (!(val == (Object)null))
				{
					_wWmSpeedProp.SetValue(val, num, null);
					_wWmAngleProp.SetValue(val, Random.Range(0, 360), null);
				}
			}
		}
		catch (Exception ex)
		{
			BirdieLog.Warning("[Birdie] SetBaseWind: " + ex.Message);
		}
	}

	private void SubscribeHoleChangeEvent()
	{
		if (_holeEventSubscribed)
		{
			return;
		}
		try
		{
			Type type = null;
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			for (int i = 0; i < assemblies.Length; i++)
			{
				type = assemblies[i].GetType("CourseManager");
				if (type != null)
				{
					break;
				}
			}
			if (type == null)
			{
				return;
			}
			EventInfo @event = type.GetEvent("CurrentHoleGlobalIndexChanged", BindingFlags.Static | BindingFlags.Public);
			if (!(@event == null))
			{
				MethodInfo method = typeof(BirdieMod).GetMethod("OnHoleChanged", BindingFlags.Instance | BindingFlags.NonPublic);
				if (!(method == null))
				{
					Delegate handler = Delegate.CreateDelegate(typeof(Action), this, method);
					@event.AddEventHandler(null, handler);
					_holeEventSubscribed = true;
				}
			}
		}
		catch (Exception ex)
		{
			BirdieLog.Warning("[Birdie] Weather hole-event sub: " + ex.Message);
		}
	}

	private void OnHoleChanged()
	{
		if (autoWeatherEnabled && IsNetworkHost())
		{
			if (_hostWeatherRunning)
			{
				_hostWeatherRunning = false;
				BirdieWeatherBridge.BroadcastWeather(0, weatherAllowed: true);
				ApplyWeather(0);
			}
			if (Random.Range(0, 100) < autoWeatherChance)
			{
				BirdieCoroutine.Start(AutoSpawnWeatherCoroutine());
			}
		}
	}

	private IEnumerator AutoSpawnWeatherCoroutine()
	{
		yield return (object)new WaitForSeconds(Random.Range(3f, 10f));
		int num = 0;
		for (int i = 0; i < autoWeatherChances.Length; i++)
		{
			if (autoWeatherChances[i] > 0)
			{
				num += autoWeatherChances[i];
			}
		}
		if (num == 0)
		{
			yield break;
		}
		int num2 = Random.Range(0, num);
		byte b = 0;
		int num3 = 0;
		for (int j = 0; j < autoWeatherChances.Length; j++)
		{
			if (autoWeatherChances[j] > 0)
			{
				num3 += autoWeatherChances[j];
				if (num2 < num3)
				{
					b = (byte)(j + 1);
					break;
				}
			}
		}
		if (b != 0)
		{
			bool weatherAllowed = (hostAllowedFeatureMask & 0x8000) != 0;
			_hostSelectedWeather = b;
			_hostWeatherRunning = true;
			BirdieWeatherBridge.BroadcastWeather(b, weatherAllowed);
			ApplyWeather(b);
			WeatherType weatherType = (WeatherType)b;
			BirdieLog.Msg("[Birdie] Auto-weather spawned: " + weatherType);
		}
	}

	private Material TrackMat(Material m)
	{
		_weatherMaterials.Add(m);
		return m;
	}

	internal void WeatherVFXStart(WeatherType type)
	{
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0016: Expected O, but got Unknown
		//IL_024d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0252: Unknown result type (might be due to invalid IL or missing references)
		//IL_0255: Unknown result type (might be due to invalid IL or missing references)
		//IL_0227: Unknown result type (might be due to invalid IL or missing references)
		//IL_0236: Unknown result type (might be due to invalid IL or missing references)
		//IL_0240: Unknown result type (might be due to invalid IL or missing references)
		//IL_0245: Unknown result type (might be due to invalid IL or missing references)
		//IL_0216: Unknown result type (might be due to invalid IL or missing references)
		WeatherVFXStop();
		_weatherVfxRoot = new GameObject("BirdieWeatherVFX_Root");
		_weatherAudio = _weatherVfxRoot.AddComponent<AudioSource>();
		_weatherAudio.loop = true;
		_weatherAudio.spatialBlend = 0f;
		_weatherAudio.priority = 0;
		switch (type)
		{
		case WeatherType.RainLight:
			_rainPs = CreateRainParticles(0.25f, 12f, 0.03f);
			ParentToRoot(((Component)_rainPs).gameObject);
			PlayLoop(_weatherAudio, _clipRainLoop, 0.85f);
			break;
		case WeatherType.RainMedium:
			_rainPs = CreateRainParticles(0.55f, 16f, 0.045f);
			ParentToRoot(((Component)_rainPs).gameObject);
			PlayLoop(_weatherAudio, _clipRainLoop, 0.95f);
			break;
		case WeatherType.RainHeavy:
			_rainPs = CreateRainParticles(1f, 22f, 0.06f);
			ParentToRoot(((Component)_rainPs).gameObject);
			PlayLoop(_weatherAudio, _clipRainLoop, 1f);
			break;
		case WeatherType.Thunderstorm:
			_rainPs = CreateRainParticles(1f, 22f, 0.06f);
			ParentToRoot(((Component)_rainPs).gameObject);
			PlayLoop(_weatherAudio, _clipRainLoop, 1f);
			_weatherAudio2 = _weatherVfxRoot.AddComponent<AudioSource>();
			_weatherAudio2.loop = true;
			_weatherAudio2.spatialBlend = 0f;
			_weatherAudio2.priority = 0;
			PlayLoop(_weatherAudio2, _clipWindLoop, 0.95f);
			break;
		case WeatherType.Tornado:
		{
			_rainPs = CreateRainParticles(0.4f, 18f, 0.05f);
			ParentToRoot(((Component)_rainPs).gameObject);
			Vector3 worldPosition = (_tornadoPositionSet ? _tornadoWorldPosition : (((Object)(object)Camera.main != (Object)null) ? (((Component)Camera.main).transform.position + ((Component)Camera.main).transform.forward * 30f) : Vector3.zero));
			_tornadoPs = CreateTornadoParticles(worldPosition);
			ParentToRoot(((Component)_tornadoPs).gameObject);
			PlayLoop(_weatherAudio, _clipTornadoLoop ?? _clipWindLoop, 1f);
			_weatherAudio2 = _weatherVfxRoot.AddComponent<AudioSource>();
			_weatherAudio2.loop = true;
			_weatherAudio2.spatialBlend = 0f;
			_weatherAudio2.priority = 0;
			PlayLoop(_weatherAudio2, _clipWindLoop, 0.95f);
			break;
		}
		case WeatherType.WindGustsLight:
			PlayLoop(_weatherAudio, _clipWindLoop, 0.85f);
			break;
		case WeatherType.WindGustsMedium:
			PlayLoop(_weatherAudio, _clipWindLoop, 0.95f);
			break;
		case WeatherType.WindGustsHeavy:
			PlayLoop(_weatherAudio, _clipWindLoop, 1f);
			break;
		case WeatherType.None:
			break;
		}
	}

	internal void WeatherVFXStop()
	{
		if ((Object)(object)_weatherVfxRoot != (Object)null)
		{
			Object.Destroy((Object)(object)_weatherVfxRoot);
			_weatherVfxRoot = null;
		}
		if ((Object)(object)_lightningLight != (Object)null && (Object)(object)((Component)_lightningLight).gameObject != (Object)null)
		{
			Object.Destroy((Object)(object)((Component)_lightningLight).gameObject);
		}
		foreach (Material weatherMaterial in _weatherMaterials)
		{
			if ((Object)(object)weatherMaterial != (Object)null)
			{
				Object.Destroy((Object)(object)weatherMaterial);
			}
		}
		_weatherMaterials.Clear();
		_rainPs = null;
		_tornadoPs = null;
		_lightningLight = null;
		_weatherAudio = null;
		_weatherAudio2 = null;
		_lightningScreenFlash = false;
		_playerStruckFlash = false;
	}

	internal void WeatherVFXUpdate()
	{
		//IL_003b: 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_004a: Unknown result type (might be due to invalid IL or missing references)
		//IL_004f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0055: 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_0064: Unknown result type (might be due to invalid IL or missing references)
		//IL_007f: Unknown result type (might be due to invalid IL or missing references)
		//IL_008e: 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_00ba: Unknown result type (might be due to invalid IL or missing references)
		float time = Time.time;
		if ((Object)(object)_rainPs != (Object)null && (Object)(object)Camera.main != (Object)null)
		{
			Transform transform = ((Component)Camera.main).transform;
			((Component)_rainPs).transform.position = transform.position + Vector3.up * 14f + transform.forward * 12f;
			((Component)_rainPs).transform.rotation = Quaternion.Euler(12f, transform.eulerAngles.y, 0f);
		}
		if ((Object)(object)_tornadoPs != (Object)null && _tornadoPositionSet)
		{
			((Component)_tornadoPs).transform.position = _tornadoWorldPosition;
		}
		if (_lightningStrikePending)
		{
			_lightningStrikePending = false;
			DoLightningFlash(_pendingLightningStrikePosition);
			PlayThunderSound();
		}
		if ((Object)(object)_lightningLight != (Object)null)
		{
			if (time < _lightningFlashEndTime)
			{
				float num = 1f - (_lightningFlashEndTime - time) / 0.15f;
				_lightningLight.intensity = Mathf.Lerp(8f, 0f, num);
			}
			else
			{
				_lightningLight.intensity = 0f;
				Object.Destroy((Object)(object)((Component)_lightningLight).gameObject);
				_lightningLight = null;
			}
		}
	}

	internal void WeatherOnGUI()
	{
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		//IL_0058: Unknown result type (might be due to invalid IL or missing references)
		//IL_0094: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
		if (_lightningScreenFlash && Time.time < _lightningScreenFlashEnd)
		{
			GUI.color = new Color(1f, 1f, 1f, 0.45f);
			GUI.DrawTexture(new Rect(0f, 0f, (float)Screen.width, (float)Screen.height), (Texture)(object)Texture2D.whiteTexture);
			GUI.color = Color.white;
		}
		else
		{
			_lightningScreenFlash = false;
		}
		if (_playerStruckFlash && Time.time < _playerStruckFlashEnd)
		{
			GUI.color = new Color(1f, 0.08f, 0.08f, 0.55f);
			GUI.DrawTexture(new Rect(0f, 0f, (float)Screen.width, (float)Screen.height), (Texture)(object)Texture2D.whiteTexture);
			GUI.color = Color.white;
		}
		else
		{
			_playerStruckFlash = false;
		}
	}

	private ParticleSystem CreateRainParticles(float density, float speed, float size)
	{
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		//IL_000b: Expected O, but got Unknown
		//IL_0039: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0048: Unknown result type (might be due to invalid IL or missing references)
		//IL_004d: Unknown result type (might be due to invalid IL or missing references)
		//IL_005c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0066: Unknown result type (might be due to invalid IL or missing references)
		//IL_006b: Unknown result type (might be due to invalid IL or missing references)
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		//IL_009e: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
		//IL_00be: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00dd: 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_010a: Unknown result type (might be due to invalid IL or missing references)
		//IL_010f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0131: Unknown result type (might be due to invalid IL or missing references)
		//IL_0136: Unknown result type (might be due to invalid IL or missing references)
		//IL_0158: Unknown result type (might be due to invalid IL or missing references)
		//IL_0163: Unknown result type (might be due to invalid IL or missing references)
		//IL_0168: 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_017d: 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_019e: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ee: Expected O, but got Unknown
		GameObject val = new GameObject("BirdieRain");
		val.transform.position = (((Object)(object)Camera.main != (Object)null) ? (((Component)Camera.main).transform.position + Vector3.up * 14f + ((Component)Camera.main).transform.forward * 12f) : (Vector3.up * 14f));
		val.transform.rotation = Quaternion.Euler(12f, ((Object)(object)Camera.main != (Object)null) ? ((Component)Camera.main).transform.eulerAngles.y : 0f, 0f);
		ParticleSystem obj = val.AddComponent<ParticleSystem>();
		MainModule main = obj.main;
		((MainModule)(ref main)).startLifetime = new MinMaxCurve(1f, 1.6f);
		((MainModule)(ref main)).startSpeed = MinMaxCurve.op_Implicit(speed);
		((MainModule)(ref main)).startSize = MinMaxCurve.op_Implicit(size);
		((MainModule)(ref main)).startColor = MinMaxGradient.op_Implicit(new Color(0.75f, 0.85f, 1f, 0.55f));
		((MainModule)(ref main)).maxParticles = (int)(density * 6000f);
		((MainModule)(ref main)).simulationSpace = (ParticleSystemSimulationSpace)1;
		ShapeModule shape = obj.shape;
		((ShapeModule)(ref shape)).enabled = true;
		((ShapeModule)(ref shape)).shapeType = (ParticleSystemShapeType)5;
		((ShapeModule)(ref shape)).scale = new Vector3(100f, 1f, 100f);
		EmissionModule emission = obj.emission;
		((EmissionModule)(ref emission)).rateOverTime = MinMaxCurve.op_Implicit(density * 1500f);
		VelocityOverLifetimeModule velocityOverLifetime = obj.velocityOverLifetime;
		((VelocityOverLifetimeModule)(ref velocityOverLifetime)).enabled = true;
		((VelocityOverLifetimeModule)(ref velocityOverLifetime)).space = (ParticleSystemSimulationSpace)1;
		((VelocityOverLifetimeModule)(ref velocityOverLifetime)).y = new MinMaxCurve((0f - speed) * 1.2f);
		ParticleSystemRenderer component = val.GetComponent<ParticleSystemRenderer>();
		component.renderMode = (ParticleSystemRenderMode)1;
		component.velocityScale = 0.04f;
		component.lengthScale = 2.5f;
		((Renderer)component).material = TrackMat(new Material(Shader.Find("Particles/Standard Unlit") ?? Shader.Find("Sprites/Default")));
		return obj;
	}

	private ParticleSystem CreateTornadoParticles(Vector3 worldPosition)
	{
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		//IL_000b: Expected O, but got Unknown
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_0026: Unknown result type (might be due to invalid IL or missing references)
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0038: Unknown result type (might be due to invalid IL or missing references)
		//IL_004e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0064: Unknown result type (might be due to invalid IL or missing references)
		//IL_0084: Unknown result type (might be due to invalid IL or missing references)
		//IL_009d: 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_00c1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c6: 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_00f5: 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_0108: Unknown result type (might be due to invalid IL or missing references)
		//IL_010d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0126: Unknown result type (might be due to invalid IL or missing references)
		//IL_0137: Unknown result type (might be due to invalid IL or missing references)
		//IL_014d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0193: Unknown result type (might be due to invalid IL or missing references)
		//IL_019d: Expected O, but got Unknown
		//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b4: Expected O, but got Unknown
		//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ed: 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_0211: Unknown result type (might be due to invalid IL or missing references)
		//IL_0227: Unknown result type (might be due to invalid IL or missing references)
		//IL_0247: Unknown result type (might be due to invalid IL or missing references)
		//IL_024c: Unknown result type (might be due to invalid IL or missing references)
		//IL_026b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0270: Unknown result type (might be due to invalid IL or missing references)
		//IL_0290: Unknown result type (might be due to invalid IL or missing references)
		//IL_0295: Unknown result type (might be due to invalid IL or missing references)
		//IL_029e: Unknown result type (might be due to invalid IL or missing references)
		//IL_02a9: Unknown result type (might be due to invalid IL or missing references)
		//IL_02ae: Unknown result type (might be due to invalid IL or missing references)
		//IL_02c7: Unknown result type (might be due to invalid IL or missing references)
		//IL_02d8: Unknown result type (might be due to invalid IL or missing references)
		//IL_02ee: Unknown result type (might be due to invalid IL or missing references)
		//IL_031f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0329: Expected O, but got Unknown
		//IL_0338: Unknown result type (might be due to invalid IL or missing references)
		//IL_033f: Expected O, but got Unknown
		//IL_0359: Unknown result type (might be due to invalid IL or missing references)
		//IL_0373: Unknown result type (might be due to invalid IL or missing references)
		//IL_0378: Unknown result type (might be due to invalid IL or missing references)
		//IL_0386: Unknown result type (might be due to invalid IL or missing references)
		//IL_039c: Unknown result type (might be due to invalid IL or missing references)
		//IL_03b2: Unknown result type (might be due to invalid IL or missing references)
		//IL_03d2: Unknown result type (might be due to invalid IL or missing references)
		//IL_03eb: Unknown result type (might be due to invalid IL or missing references)
		//IL_03f0: Unknown result type (might be due to invalid IL or missing references)
		//IL_040f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0414: Unknown result type (might be due to invalid IL or missing references)
		//IL_043f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0444: Unknown result type (might be due to invalid IL or missing references)
		//IL_044d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0458: Unknown result type (might be due to invalid IL or missing references)
		//IL_045d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0476: Unknown result type (might be due to invalid IL or missing references)
		//IL_0487: Unknown result type (might be due to invalid IL or missing references)
		//IL_049d: Unknown result type (might be due to invalid IL or missing references)
		//IL_04ce: Unknown result type (might be due to invalid IL or missing references)
		//IL_04d8: Expected O, but got Unknown
		GameObject val = new GameObject("BirdieTornado");
		val.transform.position = worldPosition;
		ParticleSystem obj = val.AddComponent<ParticleSystem>();
		obj.Stop(true, (ParticleSystemStopBehavior)0);
		MainModule main = obj.main;
		((MainModule)(ref main)).startLifetime = new MinMaxCurve(2.5f, 5f);
		((MainModule)(ref main)).startSpeed = new MinMaxCurve(10f, 24f);
		((MainModule)(ref main)).startSize = new MinMaxCurve(0.022f, 0.048f);
		((MainModule)(ref main)).startColor = new MinMaxGradient(new Color(1f, 1f, 1f, 0.92f), new Color(0.8f, 0.82f, 0.88f, 0.48f));
		((MainModule)(ref main)).maxParticles = 2500;
		((MainModule)(ref main)).simulationSpace = (ParticleSystemSimulationSpace)1;
		ShapeModule shape = obj.shape;
		((ShapeModule)(ref shape)).enabled = true;
		((ShapeModule)(ref shape)).shapeType = (ParticleSystemShapeType)4;
		((ShapeModule)(ref shape)).angle = 3f;
		((ShapeModule)(ref shape)).radius = 0.12f;
		EmissionModule emission = obj.emission;
		((EmissionModule)(ref emission)).rateOverTime = MinMaxCurve.op_Implicit(280f);
		VelocityOverLifetimeModule velocityOverLifetime = obj.velocityOverLifetime;
		((VelocityOverLifetimeModule)(ref velocityOverLifetime)).enabled = true;
		((VelocityOverLifetimeModule)(ref velocityOverLifetime)).space = (ParticleSystemSimulationSpace)1;
		((VelocityOverLifetimeModule)(ref velocityOverLifetime)).orbitalY = new MinMaxCurve(24f);
		((VelocityOverLifetimeModule)(ref velocityOverLifetime)).radial = new MinMaxCurve(-0.55f);
		((VelocityOverLifetimeModule)(ref velocityOverLifetime)).y = new MinMaxCurve(4f, 12f);
		ParticleSystemRenderer component = val.GetComponent<ParticleSystemRenderer>();
		component.renderMode = (ParticleSystemRenderMode)1;
		component.velocityScale = 0.2f;
		component.lengthScale = 12f;
		((Renderer)component).material = TrackMat(new Material(Shader.Find("Particles/Standard Unlit") ?? Shader.Find("Sprites/Default")));
		obj.Play();
		GameObject val2 = new GameObject("TornadoRing");
		val2.transform.SetParent(val.transform, false);
		val2.transform.localPosition = Vector3.zero;
		ParticleSystem obj2 = val2.AddComponent<ParticleSystem>();
		obj2.Stop(true, (ParticleSystemStopBehavior)0);
		MainModule main2 = obj2.main;
		((MainModule)(ref main2)).startLifetime = new MinMaxCurve(1f, 2.5f);
		((MainModule)(ref main2)).startSpeed = new MinMaxCurve(0.5f, 2.5f);
		((MainModule)(ref main2)).startSize = new MinMaxCurve(0.06f, 0.18f);
		((MainModule)(ref main2)).startColor = MinMaxGradient.op_Implicit(new Color(0.55f, 0.48f, 0.38f, 0.6f));
		((MainModule)(ref main2)).maxParticles = 350;
		((MainModule)(ref main2)).simulationSpace = (ParticleSystemSimulationSpace)1;
		ShapeModule shape2 = obj2.shape;
		((ShapeModule)(ref shape2)).enabled = true;
		((ShapeModule)(ref shape2)).shapeType = (ParticleSystemShapeType)10;
		((ShapeModule)(ref shape2)).radius = 3.5f;
		EmissionModule emission2 = obj2.emission;
		((EmissionModule)(ref emission2)).rateOverTime = MinMaxCurve.op_Implicit(65f);
		VelocityOverLifetimeModule velocityOverLifetime2 = obj2.velocityOverLifetime;
		((VelocityOverLifetimeModule)(ref velocityOverLifetime2)).enabled = true;
		((VelocityOverLifetimeModule)(ref velocityOverLifetime2)).space = (ParticleSystemSimulationSpace)1;
		((VelocityOverLifetimeModule)(ref velocityOverLifetime2)).orbitalY = new MinMaxCurve(12f);
		((VelocityOverLifetimeModule)(ref velocityOverLifetime2)).radial = new MinMaxCurve(0.5f);
		((VelocityOverLifetimeModule)(ref velocityOverLifetime2)).y = new MinMaxCurve(0.2f, 1.5f);
		ParticleSystemRenderer component2 = val2.GetComponent<ParticleSystemRenderer>();
		component2.renderMode = (ParticleSystemRenderMode)0;
		((Renderer)component2).material = TrackMat(new Material(Shader.Find("Particles/Standard Unlit") ?? Shader.Find("Sprites/Default")));
		obj2.Play();
		GameObject val3 = new GameObject("TornadoDebris");
		val3.transform.SetParent(val.transform, false);
		val3.transform.localPosition = Vector3.zero;
		ParticleSystem obj3 = val3.AddComponent<ParticleSystem>();
		obj3.Stop(true, (ParticleSystemStopBehavior)0);
		MainModule main3 = obj3.main;
		((MainModule)(ref main3)).startLifetime = new MinMaxCurve(2f, 5f);
		((MainModule)(ref main3)).startSpeed = new MinMaxCurve(4f, 10f);
		((MainModule)(ref main3)).startSize = new MinMaxCurve(0.04f, 0.12f);
		((MainModule)(ref main3)).startColor = new MinMaxGradient(new Color(0.18f, 0.42f, 0.08f, 0.88f), new Color(0.38f, 0.24f, 0.06f, 0.88f));
		((MainModule)(ref main3)).maxParticles = 130;
		((MainModule)(ref main3)).simulationSpace = (ParticleSystemSimulationSpace)1;
		ShapeModule shape3 = obj3.shape;
		((ShapeModule)(ref shape3)).enabled = true;
		((ShapeModule)(ref shape3)).shapeType = (ParticleSystemShapeType)4;
		((ShapeModule)(ref shape3)).angle = 25f;
		((ShapeModule)(ref shape3)).radius = 2.5f;
		EmissionModule emission3 = obj3.emission;
		((EmissionModule)(ref emission3)).rateOverTime = MinMaxCurve.op_Implicit(18f);
		VelocityOverLifetimeModule velocityOverLifetime3 = obj3.velocityOverLifetime;
		((VelocityOverLifetimeModule)(ref velocityOverLifetime3)).enabled = true;
		((VelocityOverLifetimeModule)(ref velocityOverLifetime3)).space = (ParticleSystemSimulationSpace)1;
		((VelocityOverLifetimeModule)(ref velocityOverLifetime3)).orbitalY = new MinMaxCurve(10f);
		((VelocityOverLifetimeModule)(ref velocityOverLifetime3)).radial = new MinMaxCurve(-0.35f);
		((VelocityOverLifetimeModule)(ref velocityOverLifetime3)).y = new MinMaxCurve(1f, 5f);
		ParticleSystemRenderer component3 = val3.GetComponent<ParticleSystemRenderer>();
		component3.renderMode = (ParticleSystemRenderMode)0;
		((Renderer)component3).material = TrackMat(new Material(Shader.Find("Particles/Standard Unlit") ?? Shader.Find("Sprites/Default")));
		obj3.Play();
		return obj;
	}

	private void DoLightningFlash(Vector3 strikePosition)
	{
		//IL_003d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0043: Expected O, but got Unknown
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0054: Unknown result type (might be due to invalid IL or missing references)
		//IL_0059: Unknown result type (might be due to invalid IL or missing references)
		//IL_0090: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
		//IL_0101: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)_lightningLight != (Object)null && (Object)(object)((Component)_lightningLight).gameObject != (Object)null)
		{
			Object.Destroy((Object)(object)((Component)_lightningLight).gameObject);
			_lightningLight = null;
		}
		GameObject val = new GameObject("BirdieLightningLight");
		val.transform.position = strikePosition + Vector3.up * 2f;
		_lightningLight = val.AddComponent<Light>();
		_lightningLight.type = (LightType)2;
		_lightningLight.color = new Color(0.9f, 0.95f, 1f);
		_lightningLight.intensity = 10f;
		_lightningLight.range = 60f;
		_lightningFlashEndTime = Time.time + 0.18f;
		_lightningScreenFlash = true;
		_lightningScreenFlashEnd = Time.time + 0.1f;
		if ((Object)(object)playerMovement != (Object)null && Vector3.Distance(playerMovement.transform.position, strikePosition) < 5f)
		{
			_playerStruckFlash = true;
			_playerStruckFlashEnd = Time.time + 0.45f;
		}
	}

	private void ParentToRoot(GameObject child)
	{
		if (!((Object)(object)child == (Object)null) && !((Object)(object)_weatherVfxRoot == (Object)null))
		{
			child.transform.SetParent(_weatherVfxRoot.transform, true);
		}
	}

	private static void PlayLoop(AudioSource src, AudioClip clip, float volume)
	{
		if (!((Object)(object)src == (Object)null))
		{
			src.clip = clip;
			src.volume = volume;
			if ((Object)(object)clip != (Object)null)
			{
				src.Play();
			}
		}
	}

	internal void PlayGustSound()
	{
		if ((Object)(object)_weatherAudio != (Object)null && (Object)(object)_clipWindGust != (Object)null)
		{
			_weatherAudio.PlayOneShot(_clipWindGust, 4f);
		}
	}

	internal void PlayThunderSound()
	{
		if ((Object)(object)_weatherAudio != (Object)null && (Object)(object)_clipThunderCrack != (Object)null)
		{
			_weatherAudio.PlayOneShot(_clipThunderCrack, 4f);
		}
	}

	internal IEnumerator LoadWeatherSounds()
	{
		string path = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) ?? "";
		string soundsDir = Path.Combine(path, "BirdieMod", "sounds");
		yield return LoadClip(soundsDir, "rain_loop.wav", (AudioType)20, delegate(AudioClip c)
		{
			_clipRainLoop = c;
		});
		yield return LoadClip(soundsDir, "wind_loop.wav", (AudioType)20, delegate(AudioClip c)
		{
			_clipWindLoop = c;
		});
		yield return LoadClip(soundsDir, "wind_gust.mp3", (AudioType)13, delegate(AudioClip c)
		{
			_clipWindGust = c;
		});
		yield return LoadClip(soundsDir, "thunder_crack.mp3", (AudioType)13, delegate(AudioClip c)
		{
			_clipThunderCrack = c;
		});
		yield return LoadClip(soundsDir, "tornado_loop.mp3", (AudioType)13, delegate(AudioClip c)
		{
			_clipTornadoLoop = c;
		});
		_soundsLoaded = true;
		BirdieLog.Msg("[Birdie] Weather sounds loaded.");
	}

	private IEnumerator LoadClip(string dir, string file, AudioType type, Action<AudioClip> setter)
	{
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		string text = Path.Combine(dir, file);
		if (!File.Exists(text))
		{
			BirdieLog.Warning("[Birdie] Sound not found: " + text);
			yield break;
		}
		string text2 = "file:///" + text.Replace('\\', '/');
		UnityWebRequest req = UnityWebRequestMultimedia.GetAudioClip(text2, type);
		try
		{
			yield return req.SendWebRequest();
			if ((int)req.result == 1)
			{
				setter(DownloadHandlerAudioClip.GetContent(req));
			}
			else
			{
				BirdieLog.Warning("[Birdie] Failed to load sound: " + file + " — " + req.error);
			}
		}
		finally
		{
			((IDisposable)req)?.Dispose();
		}
	}

	static BirdieMod()
	{
		Key[] array = new Key[12];
		RuntimeHelpers.InitializeArray(array, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		SpawnableItemKeys = (Key[])(object)array;
		SpawnableItemKeyLabels = new string[12]
		{
			"1", "2", "3", "4", "5", "6", "7", "8", "9", "0",
			"-", "="
		};
		SettingsKeybindDisplayNames = new string[19]
		{
			"Assist Toggle", "Coffee Boost", "Nearest Ball Mode", "Unlock Cosmetics", "Item Spawner", "HUD Toggle", "Random Item (Crate)", "Ice Toggle", "Settings Panel", "Landmine Immunity",
			"Lock-On Any Dist.", "No Wind", "Perfect Shot", "No Air Drag", "Speed Multiplier", "Infinite Item Usage", "No Recoil", "No Knockback", "Expanded Slots"
		};
		Key[] array2 = new Key[10];
		RuntimeHelpers.InitializeArray(array2, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
		SettingsSelectionKeys = (Key[])(object)array2;
	}
}
internal static class BirdieLog
{
	internal static Action<string> MsgImpl;

	internal static Action<string> WarnImpl;

	internal static void Msg(string s)
	{
		MsgImpl?.Invoke(s);
	}

	internal static void Warning(string s)
	{
		WarnImpl?.Invoke(s);
	}
}
internal static class BirdieCoroutine
{
	internal static Action<IEnumerator> StartImpl;

	internal static void Start(IEnumerator e)
	{
		StartImpl?.Invoke(e);
	}
}
internal static class BirdieNoKnockbackBridge
{
	internal static bool IsActive;

	internal static object LocalPlayerHittable;

	private static bool patchApplied;

	internal static void EnsurePatchApplied()
	{
		if (patchApplied)
		{
			return;
		}
		patchApplied = true;
		try
		{
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			Type type = null;
			for (int i = 0; i < assemblies.Length; i++)
			{
				type = assemblies[i].GetType("Hittable");
				if (type != null)
				{
					break;
				}
			}
			if (type == null)
			{
				BirdieLog.Warning("[Birdie] No Knockback patch: Hittable type not found");
				patchApplied = false;
				return;
			}
			MethodInfo method = type.GetMethod("HitWithItem", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method2 = type.GetMethod("HitWithRocketLauncherBackBlast", BindingFlags.Instance | BindingFlags.Public);
			if (method == null && method2 == null)
			{
				BirdieLog.Warning("[Birdie] No Knockback patch: neither Hittable target method found");
				patchApplied = false;
				return;
			}
			Type type2 = null;
			Type type3 = null;
			for (int j = 0; j < assemblies.Length; j++)
			{
				if (type2 == null)
				{
					type2 = assemblies[j].GetType("HarmonyLib.Harmony");
				}
				if (type3 == null)
				{
					type3 = assemblies[j].GetType("HarmonyLib.HarmonyMethod");
				}
				if (type2 != null && type3 != null)
				{
					break;
				}
			}
			if (type2 == null || type3 == null)
			{
				BirdieLog.Warning("[Birdie] No Knockback patch: HarmonyLib types not found");
				patchApplied = false;
				return;
			}
			object obj = Activator.CreateInstance(type2, "birdie.noknockback");
			MethodInfo method3 = typeof(BirdieNoKnockbackBridge).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			if (method3 == null)
			{
				BirdieLog.Warning("[Birdie] No Knockback patch: Prefix method not found");
				patchApplied = false;
				return;
			}
			object harmonyPrefix = Activator.CreateInstance(type3, method3);
			MethodInfo methodInfo = null;
			MethodInfo[] methods = type2.GetMethods(BindingFlags.Instance | BindingFlags.Public);
			foreach (MethodInfo methodInfo2 in methods)
			{
				if (!(methodInfo2.Name != "Patch") && !methodInfo2.IsGenericMethod)
				{
					ParameterInfo[] parameters = methodInfo2.GetParameters();
					if (parameters.Length >= 2 && parameters[0].ParameterType.FullName == "System.Reflection.MethodBase")
					{
						methodInfo = methodInfo2;
						break;
					}
				}
			}
			if (methodInfo == null)
			{
				BirdieLog.Warning("[Birdie] No Knockback patch: Harmony.Patch overload not found");
				patchApplied = false;
				return;
			}
			ParameterInfo[] parameters2 = methodInfo.GetParameters();
			if (method != null)
			{
				object[] parameters3 = BuildArgs(parameters2, method, harmonyPrefix);
				methodInfo.Invoke(obj, parameters3);
				BirdieLog.Msg("[Birdie] No Knockback patch: registered prefix on Hittable.HitWithItem");
			}
			if (method2 != null)
			{
				object[] parameters4 = BuildArgs(parameters2, method2, harmonyPrefix);
				methodInfo.Invoke(obj, parameters4);
				BirdieLog.Msg("[Birdie] No Knockback patch: registered prefix on Hittable.HitWithRocketLauncherBackBlast");
			}
		}
		catch (Exception ex)
		{
			BirdieLog.Warning("[Birdie] No Knockback patch error: " + ex.Message);
			patchApplied = false;
		}
	}

	private static object[] BuildArgs(ParameterInfo[] patchParams, MethodInfo original, object harmonyPrefix)
	{
		object[] array = new object[patchParams.Length];
		array[0] = original;
		for (int i = 1; i < patchParams.Length; i++)
		{
			if (((patchParams[i].Name != null) ? patchParams[i].Name.ToLowerInvariant() : string.Empty) == "prefix")
			{
				array[i] = harmonyPrefix;
			}
		}
		return array;
	}

	private static bool Prefix(object __instance)
	{
		if (!IsActive || LocalPlayerHittable == null)
		{
			return true;
		}
		return __instance != LocalPlayerHittable;
	}
}
internal static class BirdieInfiniteAmmoBridge
{
	internal static bool IsActive;

	internal static object LocalPlayerInventory;

	private static bool patchApplied;

	internal static void EnsurePatchApplied()
	{
		if (patchApplied)
		{
			return;
		}
		patchApplied = true;
		try
		{
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			Type type = null;
			for (int i = 0; i < assemblies.Length; i++)
			{
				type = assemblies[i].GetType("PlayerInventory");
				if (type != null)
				{
					break;
				}
			}
			if (type == null)
			{
				BirdieLog.Warning("[Birdie] Infinite Ammo patch: PlayerInventory type not found");
				patchApplied = false;
				return;
			}
			MethodInfo method = type.GetMethod("DecrementUseFromSlotAt", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (method == null)
			{
				BirdieLog.Warning("[Birdie] Infinite Ammo patch: DecrementUseFromSlotAt not found");
				patchApplied = false;
				return;
			}
			Type type2 = null;
			Type type3 = null;
			for (int j = 0; j < assemblies.Length; j++)
			{
				if (type2 == null)
				{
					type2 = assemblies[j].GetType("HarmonyLib.Harmony");
				}
				if (type3 == null)
				{
					type3 = assemblies[j].GetType("HarmonyLib.HarmonyMethod");
				}
				if (type2 != null && type3 != null)
				{
					break;
				}
			}
			if (type2 == null || type3 == null)
			{
				BirdieLog.Warning("[Birdie] Infinite Ammo patch: HarmonyLib types not found");
				patchApplied = false;
				return;
			}
			object obj = Activator.CreateInstance(type2, "birdie.infiniteammo");
			MethodInfo method2 = typeof(BirdieInfiniteAmmoBridge).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			if (method2 == null)
			{
				BirdieLog.Warning("[Birdie] Infinite Ammo patch: Prefix method not found");
				patchApplied = false;
				return;
			}
			object obj2 = Activator.CreateInstance(type3, method2);
			MethodInfo methodInfo = null;
			MethodInfo[] methods = type2.GetMethods(BindingFlags.Instance | BindingFlags.Public);
			foreach (MethodInfo methodInfo2 in methods)
			{
				if (!(methodInfo2.Name != "Patch") && !methodInfo2.IsGenericMethod)
				{
					ParameterInfo[] parameters = methodInfo2.GetParameters();
					if (parameters.Length >= 2 && parameters[0].ParameterType.FullName == "System.Reflection.MethodBase")
					{
						methodInfo = methodInfo2;
						break;
					}
				}
			}
			if (methodInfo == null)
			{
				BirdieLog.Warning("[Birdie] Infinite Ammo patch: Harmony.Patch overload not found");
				patchApplied = false;
				return;
			}
			ParameterInfo[] parameters2 = methodInfo.GetParameters();
			object[] array = new object[parameters2.Length];
			array[0] = method;
			for (int l = 1; l < parameters2.Length; l++)
			{
				if (((parameters2[l].Name != null) ? parameters2[l].Name.ToLowerInvariant() : string.Empty) == "prefix")
				{
					array[l] = obj2;
				}
			}
			methodInfo.Invoke(obj, array);
			BirdieLog.Msg("[Birdie] Infinite Ammo patch: registered prefix on PlayerInventory.DecrementUseFromSlotAt");
		}
		catch (Exception ex)
		{
			BirdieLog.Warning("[Birdie] Infinite Ammo patch error: " + ex.Message);
			patchApplied = false;
		}
	}

	private static bool Prefix(object __instance)
	{
		if (!IsActive || LocalPlayerInventory == null)
		{
			return true;
		}
		return __instance != LocalPlayerInventory;
	}
}
internal static class BirdieLandmineImmunityBridge
{
	internal static bool IsActive;

	internal static object LocalPlayerHittable;

	internal static object LandmineItemTypeValue;

	private static bool patchApplied;

	internal static void EnsurePatchApplied()
	{
		if (patchApplied)
		{
			return;
		}
		patchApplied = true;
		try
		{
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			Type type = null;
			for (int i = 0; i < assemblies.Length; i++)
			{
				type = assemblies[i].GetType("Hittable");
				if (type != null)
				{
					break;
				}
			}
			if (type == null)
			{
				BirdieLog.Warning("[Birdie] Landmine Immunity patch: Hittable type not found");
				patchApplied = false;
				return;
			}
			MethodInfo method = type.GetMethod("HitWithItemInternal", BindingFlags.Instance | BindingFlags.NonPublic);
			if (method == null)
			{
				BirdieLog.Warning("[Birdie] Landmine Immunity patch: HitWithItemInternal method not found");
				patchApplied = false;
				return;
			}
			Type type2 = null;
			for (int j = 0; j < assemblies.Length; j++)
			{
				type2 = assemblies[j].GetType("ItemType");
				if (type2 != null)
				{
					break;
				}
			}
			if (type2 != null)
			{
				try
				{
					LandmineItemTypeValue = Enum.Parse(type2, "Landmine");
				}
				catch
				{
				}
			}
			Type type3 = null;
			Type type4 = null;
			for (int k = 0; k < assemblies.Length; k++)
			{
				if (type3 == null)
				{
					type3 = assemblies[k].GetType("HarmonyLib.Harmony");
				}
				if (type4 == null)
				{
					type4 = assemblies[k].GetType("HarmonyLib.HarmonyMethod");
				}
				if (type3 != null && type4 != null)
				{
					break;
				}
			}
			if (type3 == null || type4 == null)
			{
				BirdieLog.Warning("[Birdie] Landmine Immunity patch: HarmonyLib types not found");
				patchApplied = false;
				return;
			}
			object obj2 = Activator.CreateInstance(type3, "birdie.landmineimmunity");
			MethodInfo method2 = typeof(BirdieLandmineImmunityBridge).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			if (method2 == null)
			{
				BirdieLog.Warning("[Birdie] Landmine Immunity patch: Prefix method not found");
				patchApplied = false;
				return;
			}
			object obj3 = Activator.CreateInstance(type4, method2);
			MethodInfo methodInfo = null;
			MethodInfo[] methods = type3.GetMethods(BindingFlags.Instance | BindingFlags.Public);
			foreach (MethodInfo methodInfo2 in methods)
			{
				if (!(methodInfo2.Name != "Patch") && !methodInfo2.IsGenericMethod)
				{
					ParameterInfo[] parameters = methodInfo2.GetParameters();
					if (parameters.Length >= 2 && parameters[0].ParameterType.FullName == "System.Reflection.MethodBase")
					{
						methodInfo = methodInfo2;
						break;
					}
				}
			}
			if (methodInfo == null)
			{
				BirdieLog.Warning("[Birdie] Landmine Immunity patch: Harmony.Patch overload not found");
				patchApplied = false;
				return;
			}
			ParameterInfo[] parameters2 = methodInfo.GetParameters();
			object[] array = new object[parameters2.Length];
			array[0] = method;
			for (int m = 1; m < parameters2.Length; m++)
			{
				if (((parameters2[m].Name != null) ? parameters2[m].Name.ToLowerInvariant() : string.Empty) == "prefix")
				{
					array[m] = obj3;
				}
			}
			methodInfo.Invoke(obj2, array);
			BirdieLog.Msg("[Birdie] Landmine Immunity patch: registered prefix on Hittable.HitWithItemInternal");
		}
		catch (Exception ex)
		{
			BirdieLog.Warning("[Birdie] Landmine Immunity patch error: " + ex.Message);
			patchApplied = false;
		}
	}

	private static bool Prefix(object __instance, object itemType)
	{
		if (!IsActive || LocalPlayerHittable == null)
		{
			return true;
		}
		if (__instance != LocalPlayerHittable)
		{
			return true;
		}
		if (LandmineItemTypeValue == null || !object.Equals(itemType, LandmineItemTypeValue))
		{
			return true;
		}
		return false;
	}
}
internal static class BirdieIcePatchBridge
{
	internal static bool IsActive;

	internal static FieldInfo HorizontalDragField;

	internal static float NormalDragValue = 10f;

	private static bool patchApplied;

	internal static void EnsurePatchApplied()
	{
		if (patchApplied)
		{
			return;
		}
		patchApplied = true;
		try
		{
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			Type type = null;
			for (int i = 0; i < assemblies.Length; i++)
			{
				type = assemblies[i].GetType("PlayerMovement");
				if (type != null)
				{
					break;
				}
			}
			if (type == null)
			{
				BirdieLog.Warning("[Birdie] Ice patch: PlayerMovement type not found");
				patchApplied = false;
				return;
			}
			MethodInfo method = type.GetMethod("UpdatePhysicsParameters", BindingFlags.Instance | BindingFlags.NonPublic);
			if (method == null)
			{
				BirdieLog.Warning("[Birdie] Ice patch: PlayerMovement.UpdatePhysicsParameters not found");
				patchApplied = false;
				return;
			}
			Type type2 = null;
			Type type3 = null;
			for (int j = 0; j < assemblies.Length; j++)
			{
				if (type2 == null)
				{
					type2 = assemblies[j].GetType("HarmonyLib.Harmony");
				}
				if (type3 == null)
				{
					type3 = assemblies[j].GetType("HarmonyLib.HarmonyMethod");
				}
				if (type2 != null && type3 != null)
				{
					break;
				}
			}
			if (type2 == null)
			{
				BirdieLog.Warning("[Birdie] Ice patch: HarmonyLib.Harmony not found at runtime");
				patchApplied = false;
				return;
			}
			if (type3 == null)
			{
				BirdieLog.Warning("[Birdie] Ice patch: HarmonyLib.HarmonyMethod not found at runtime");
				patchApplied = false;
				return;
			}
			object obj = Activator.CreateInstance(type2, "birdie.icephysics");
			MethodInfo method2 = typeof(BirdieIcePatchBridge).GetMethod("Postfix", BindingFlags.Static | BindingFlags.NonPublic);
			if (method2 == null)
			{
				BirdieLog.Warning("[Birdie] Ice patch: Postfix method not found on BirdieIcePatchBridge");
				patchApplied = false;
				return;
			}
			object obj2 = Activator.CreateInstance(type3, method2);
			MethodInfo methodInfo = null;
			MethodInfo[] methods = type2.GetMethods(BindingFlags.Instance | BindingFlags.Public);
			foreach (MethodInfo methodInfo2 in methods)
			{
				if (!(methodInfo2.Name != "Patch") && !methodInfo2.IsGenericMethod)
				{
					ParameterInfo[] parameters = methodInfo2.GetParameters();
					if (parameters.Length >= 2 && parameters[0].ParameterType.FullName == "System.Reflection.MethodBase")
					{
						methodInfo = methodInfo2;
						break;
					}
				}
			}
			if (methodInfo == null)
			{
				BirdieLog.Warning("[Birdie] Ice patch: Harmony.Patch(MethodBase,...) overload not found");
				patchApplied = false;
				return;
			}
			ParameterInfo[] parameters2 = methodInfo.GetParameters();
			object[] array = new object[parameters2.Length];
			array[0] = method;
			for (int l = 1; l < parameters2.Length; l++)
			{
				if (((parameters2[l].Name != null) ? parameters2[l].Name.ToLowerInvariant() : string.Empty) == "postfix")
				{
					array[l] = obj2;
				}
			}
			methodInfo.Invoke(obj, array);
			BirdieLog.Msg("[Birdie] Ice patch: Harmony postfix registered on PlayerMovement.UpdatePhysicsParameters");
		}
		catch (Exception ex)
		{
			BirdieLog.Warning("[Birdie] Ice patch error: " + ex.Message);
			patchApplied = false;
		}
	}

	private static void Postfix(object __instance)
	{
		if (!IsActive || HorizontalDragField == null)
		{
			return;
		}
		try
		{
			if ((float)HorizontalDragField.GetValue(__instance) < NormalDragValue * 0.9f)
			{
				HorizontalDragField.SetValue(__instance, NormalDragValue);
			}
		}
		catch
		{
		}
	}
}
internal enum WeatherType : byte
{
	None,
	RainLight,
	RainMedium,
	RainHeavy,
	WindGustsLight,
	WindGustsMedium,
	WindGustsHeavy,
	Thunderstorm,
	Tornado
}
internal static class BirdieWeatherBridge
{
	private const string RpcMethodName = "System.Void PlayerInventory::BirdieCmdSyncWeather(System.Byte,System.Boolean)";

	internal static byte ReceivedWeatherType;

	internal static bool WeatherAllowedByHost = true;

	internal static bool ReceivedNewWeather;

	private static bool initialized;

	private static float _nextRetry = -1f;

	private static ushort registeredRpcHash;

	private static Type mirrorNbType;

	private static Type mirrorReaderType;

	private static Type mirrorConnType;

	private static Type mirrorRpcType;

	private static Type mirrorRcdType;

	private static Type mirrorRctType;

	private static Type mirrorRpcMsgType;

	private static Type mirrorNsType;

	private static Type mirrorNwpType;

	private static Type mirrorNwExtType;

	private static Type mirrorNrExtType;

	private static MethodInfo mirrorRegisterDelegate;

	private static MethodInfo mirrorNsSendToAll;

	private static MethodInfo mirrorWriterExtWriteBool;

	private static MethodInfo mirrorWriterExtWriteByte;

	private static MethodInfo mirrorWriterPoolGet;

	private static MethodInfo mirrorWriterPoolReturn;

	private static MethodInfo mirrorWriterToArraySegment;

	private static MethodInfo mirrorReaderExtReadBool;

	private static MethodInfo mirrorReaderExtReadByte;

	private static PropertyInfo mirrorNbNetId;

	private static PropertyInfo mirrorNbComponentIndex;

	private static FieldInfo mirrorRpcNetId;

	private static FieldInfo mirrorRpcComponentIndex;

	private static FieldInfo mirrorRpcFunctionHash;

	private static FieldInfo mirrorRpcPayload;

	private static PropertyInfo cachedLocalPlayerInventoryProperty;

	internal static void EnsureHandlersRegistered()
	{
		if (initialized)
		{
			return;
		}
		float time = Time.time;
		if (time < _nextRetry)
		{
			return;
		}
		_nextRetry = time + 2f;
		try
		{
			if (CollectReflectionCaches())
			{
				RegisterRpcHandler();
				if (registeredRpcHash != 0)
				{
					initialized = true;
					BirdieLog.Msg("[Birdie] Weather bridge ready.");
				}
			}
		}
		catch (Exception ex)
		{
			BirdieLog.Warning("[Birdie] Weather bridge init: " + ex.Message);
		}
	}

	internal static void BroadcastWeather(byte weatherType, bool weatherAllowed)
	{
		EnsureHandlersRegistered();
		try
		{
			Type type = mirrorNsType;
			if (type != null)
			{
				PropertyInfo property = type.GetProperty("active", BindingFlags.Static | BindingFlags.Public);
				if (property != null && !(bool)property.GetValue(null, null))
				{
					BirdieLog.Warning("[Birdie] Weather bridge: NetworkServer is not active — cannot broadcast.");
					return;
				}
			}
		}
		catch (Exception ex)
		{
			BirdieLog.Warning("[Birdie] Weather bridge (server check): " + ex.Message);
			return;
		}
		if (registeredRpcHash == 0 || mirrorNbNetId == null || mirrorNbComponentIndex == null || mirrorRpcMsgType == null || mirrorNsSendToAll == null || mirrorWriterExtWriteByte == null || mirrorWriterExtWriteBool == null || mirrorWriterPoolGet == null || mirrorWriterPoolReturn == null || mirrorWriterToArraySegment == null || cachedLocalPlayerInventoryProperty == null)
		{
			BirdieLog.Warning("[Birdie] Weather bridge: broadcast not ready (reflection incomplete).");
			return;
		}
		try
		{
			object? value = cachedLocalPlayerInventoryProperty.GetValue(null, null);
			Component val = (Component)((value is Component) ? value : null);
			if ((Object)(object)val == (Object)null)
			{
				BirdieLog.Warning("[Birdie] Weather bridge: LocalPlayerInventory is null.");
				return;
			}
			uint num = (uint)mirrorNbNetId.GetValue(val, null);
			byte b = (byte)mirrorNbComponentIndex.GetValue(val, null);
			object obj = mirrorWriterPoolGet.Invoke(null, null);
			mirrorWriterExtWriteByte.Invoke(null, new object[2] { obj, weatherType });
			mirrorWriterExtWriteBool.Invoke(null, new object[2] { obj, weatherAllowed });
			ArraySegment<byte> arraySegment = (ArraySegment<byte>)mirrorWriterToArraySegment.Invoke(obj, null);
			object obj2 = Activator.CreateInstance(mirrorRpcMsgType);
			mirrorRpcNetId.SetValue(obj2, num);
			mirrorRpcComponentIndex.SetValue(obj2, b);
			mirrorRpcFunctionHash.SetValue(obj2, registeredRpcHash);
			mirrorRpcPayload.SetValue(obj2, arraySegment);
			mirrorNsSendToAll.Invoke(null, new object[2] { obj2, 0 });
			mirrorWriterPoolReturn.Invoke(null, new object[1] { obj });
		}
		catch (Exception ex2)
		{
			BirdieLog.Warning("[Birdie] Weather bridge (broadcast): " + ex2.Message);
		}
	}

	private static void ClientHandleSyncWeather(object nbObj, object readerObj, object connObj)
	{
		try
		{
			if (readerObj != null)
			{
				if (mirrorReaderExtReadByte == null || mirrorReaderExtReadBool == null)
				{
					BirdieLog.Warning("[Birdie] Weather bridge client handler: reflection incomplete.");
					return;
				}
				byte receivedWeatherType = (byte)mirrorReaderExtReadByte.Invoke(null, new object[1] { readerObj });
				bool weatherAllowedByHost = (bool)mirrorReaderExtReadBool.Invoke(null, new object[1] { readerObj });
				ReceivedWeatherType = receivedWeatherType;
				WeatherAllowedByHost = weatherAllowedByHost;
				ReceivedNewWeather = true;
				BirdieLog.Msg("[Birdie] Weather bridge: weatherType=" + receivedWeatherType + " weatherAllowed=" + weatherAllowedByHost);
			}
		}
		catch (Exception ex)
		{
			BirdieLog.Warning("[Birdie] Weather bridge client handler: " + ex.Message);
		}
	}

	private static bool CollectReflectionCaches()
	{
		Assembly assembly = null;
		Assembly assembly2 = null;
		Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
		foreach (Assembly assembly3 in assemblies)
		{
			switch (assembly3.GetName().Name)
			{
			case "Mirror":
				assembly = assembly3;
				break;
			case "Assembly-CSharp":
			case "GameAssembly":
				assembly2 = assembly3;
				break;
			}
		}
		if (assembly == null || assembly2 == null)
		{
			return false;
		}
		mirrorNbType = assembly.GetType("Mirror.NetworkBehaviour");
		mirrorReaderType = assembly.GetType("Mirror.NetworkReader");
		mirrorConnType = assembly.GetType("Mirror.NetworkConnectionToClient");
		mirrorRpcType = assembly.GetType("Mirror.RemoteCalls.RemoteProcedureCalls");
		mirrorRcdType = assembly.GetType("Mirror.RemoteCalls.RemoteCallDelegate");
		mirrorRctType = assembly.GetType("Mirror.RemoteCalls.RemoteCallType");
		mirrorRpcMsgType = assembly.GetType("Mirror.RpcMessage");
		mirrorNsType = assembly.GetType("Mirror.NetworkServer");
		mirrorNwpType = assembly.GetType("Mirror.NetworkWriterPool");
		mirrorNwExtType = assembly.GetType("Mirror.NetworkWriterExtensions");
		mirrorNrExtType = assembly.GetType("Mirror.NetworkReaderExtensions");
		if (mirrorNbType == null || mirrorReaderType == null || mirrorConnType == null || mirrorRpcType == null || mirrorRcdType == null || mirrorRctType == null || mirrorRpcMsgType == null || mirrorNsType == null || mirrorNwpType == null || mirrorNwExtType == null || mirrorNrExtType == null)
		{
			return false;
		}
		mirrorRegisterDelegate = mirrorRpcType.GetMethod("RegisterDelegate", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
		MethodInfo method = mirrorNsType.GetMethod("SendToAll", BindingFlags.Static | BindingFlags.Public);
		if (method != null)
		{
			mirrorNsSendToAll = method.MakeGenericMethod(mirrorRpcMsgType);
		}
		mirrorWriterExtWriteBool = mirrorNwExtType.GetMethod("WriteBool", BindingFlags.Static | BindingFlags.Public);
		mirrorWriterExtWriteByte = mirrorNwExtType.GetMethod("WriteByte", BindingFlags.Static | BindingFlags.Public);
		mirrorWriterPoolGet = mirrorNwpType.GetMethod("Get", BindingFlags.Static | BindingFlags.Public);
		mirrorWriterPoolReturn = mirrorNwpType.GetMethod("Return", BindingFlags.Static | BindingFlags.Public);
		Type type = assembly.GetType("Mirror.NetworkWriter");
		if (type != null)
		{
			mirrorWriterToArraySegment = type.GetMethod("ToArraySegment", BindingFlags.Instance | BindingFlags.Public);
		}
		mirrorReaderExtReadBool = mirrorNrExtType.GetMethod("ReadBool", BindingFlags.Static | BindingFlags.Public);
		mirrorReaderExtReadByte = mirrorNrExtType.GetMethod("ReadByte", BindingFlags.Static | BindingFlags.Public);
		mirrorNbNetId = mirrorNbType.GetProperty("netId", BindingFlags.Instance | BindingFlags.Public);
		mirrorNbComponentIndex = mirrorNbType.GetProperty("ComponentIndex", BindingFlags.Instance | BindingFlags.Public);
		mirrorRpcNetId = mirrorRpcMsgType.GetField("netId");
		mirrorRpcComponentIndex = mirrorRpcMsgType.GetField("componentIndex");
		mirrorRpcFunctionHash = mirrorRpcMsgType.GetField("functionHash");
		mirrorRpcPayload = mirrorRpcMsgType.GetField("payload");
		Type type2 = assembly2.GetType("PlayerInventory");
		Type type3 = assembly2.GetType("GameManager");
		if (type3 != null)
		{
			cachedLocalPlayerInventoryProperty = type3.GetProperty("LocalPlayerInventory", BindingFlags.Static | BindingFlags.Public);
		}
		if (mirrorRegisterDelegate != null && mirrorNsSendToAll != null && mirrorWriterExtWriteBool != null && mirrorWriterExtWriteByte != null && mirrorWriterPoolGet != null && mirrorWriterToArraySegment != null && mirrorReaderExtReadBool != null && mirrorReaderExtReadByte != null && mirrorNbNetId != null && mirrorNbComponentIndex != null && mirrorRpcNetId != null)
		{
			return type2 != null;
		}
		return false;
	}

	private static void RegisterRpcHandler()
	{
		if (mirrorRegisterDelegate == null || mirrorRcdType == null || mirrorNbType == null || mirrorReaderType == null || mirrorConnType == null || mirrorRctType == null)
		{
			return;
		}
		Type type = null;
		Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
		for (int i = 0; i < assemblies.Length; i++)
		{
			type = assemblies[i].GetType("PlayerInventory");
			if (type != null)
			{
				break;
			}
		}
		if (type == null)
		{
			BirdieLog.Warning("[Birdie] Weather bridge: PlayerInventory type not found.");
			return;
		}
		DynamicMethod dynamicMethod = new DynamicMethod("BirdieWeatherRpcHandler", typeof(void), new Type[3] { mirrorNbType, mirrorReaderType, mirrorConnType }, typeof(BirdieWeatherBridge).Module, skipVisibility: true);
		MethodInfo method = typeof(BirdieWeatherBridge).GetMethod("ClientHandleSyncWeather", BindingFlags.Static | BindingFlags.NonPublic);
		if (method == null)
		{
			BirdieLog.Warning("[Birdie] Weather bridge: ClientHandleSyncWeather not found via reflection.");
			return;
		}
		ILGenerator iLGenerator = dynamicMethod.GetILGenerator();
		iLGenerator.Emit(OpCodes.Ldarg_0);
		iLGenerator.Emit(OpCodes.Ldarg_1);
		iLGenerator.Emit(OpCodes.Ldarg_2);
		iLGenerator.Emit(OpCodes.Call, method);
		iLGenerator.Emit(OpCodes.Ret);
		Delegate @delegate = dynamicMethod.CreateDelegate(mirrorRcdType);
		object obj = Enum.Parse(mirrorRctType, "ClientRpc");
		registeredRpcHash = (ushort)mirrorRegisterDelegate.Invoke(null, new object[5] { type, "System.Void PlayerInventory::BirdieCmdSyncWeather(System.Byte,System.Boolean)", obj, @delegate, false });
		if (registeredRpcHash == 0)
		{
			BirdieLog.Warning("[Birdie] Weather bridge: RegisterDelegate returned hash 0 — may indicate a collision.");
		}
	}
}
internal static class ModReflectionHelper
{
	private const BindingFlags MemberFlags = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;

	private static readonly object CacheLock = new object();

	private static readonly Dictionary<string, PropertyInfo> PropertyCache = new Dictionary<string, PropertyInfo>(128);

	private static readonly Dictionary<string, FieldInfo> FieldCache = new Dictionary<string, FieldInfo>(128);

	private static string BuildCacheKey(Type instanceType, string memberName)
	{
		return instanceType.AssemblyQualifiedName + "|" + memberName;
	}

	private static PropertyInfo GetCachedProperty(Type instanceType, string memberName)
	{
		string key = BuildCacheKey(instanceType, memberName);
		lock (CacheLock)
		{
			if (PropertyCache.TryGetValue(key, out var value))
			{
				return value;
			}
			value = instanceType.GetProperty(memberName, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			PropertyCache[key] = value;
			return value;
		}
	}

	private static FieldInfo GetCachedField(Type instanceType, string memberName)
	{
		string key = BuildCacheKey(instanceType, memberName);
		lock (CacheLock)
		{
			if (FieldCache.TryGetValue(key, out var value))
			{
				return value;
			}
			value = instanceType.GetField(memberName, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			FieldCache[key] = value;
			return value;
		}
	}

	internal static float GetFloatMemberValue(object instance, string memberName, float fallbackValue)
	{
		if (instance == null)
		{
			return fallbackValue;
		}
		Type type = instance.GetType();
		try
		{
			PropertyInfo cachedProperty = GetCachedProperty(type, memberName);
			if (cachedProperty != null)
			{
				object value = cachedProperty.GetValue(instance, null);
				if (value is float result)
				{
					return result;
				}
				if (value is double)
				{
					return (float)(double)value;
				}
				if (value is int)
				{
					return (int)value;
				}
			}
		}
		catch
		{
		}
		try
		{
			FieldInfo cachedField = GetCachedField(type, memberName);
			if (cachedField != null)
			{
				object value2 = cachedField.GetValue(instance);
				if (value2 is float result2)
				{
					return result2;
				}
				if (value2 is double)
				{
					return (float)(double)value2;
				}
				if (value2 is int)
				{
					return (int)value2;
				}
			}
		}
		catch
		{
		}
		return fallbackValue;
	}

	internal static bool SetFloatMemberValue(object instance, string memberName, float value)
	{
		if (instance == null)
		{
			return false;
		}
		Type type = instance.GetType();
		try
		{
			PropertyInfo cachedProperty = GetCachedProperty(type, memberName);
			if (cachedProperty != null && cachedProperty.CanWrite && cachedProperty.PropertyType == typeof(float))
			{
				cachedProperty.SetValue(instance, value, null);
				return true;
			}
		}
		catch
		{
		}
		try
		{
			FieldInfo cachedField = GetCachedField(type, memberName);
			if (cachedField != null && cachedField.FieldType == typeof(float))
			{
				cachedField.SetValue(instance, value);
				return true;
			}
		}
		catch
		{
		}
		return false;
	}

	internal static object GetMemberValue(object instance, string memberName)
	{
		if (instance == null)
		{
			return null;
		}
		Type type = instance.GetType();
		try
		{
			PropertyInfo cachedProperty = GetCachedProperty(type, memberName);
			if (cachedProperty != null)
			{
				return cachedProperty.GetValue(instance, null);
			}
		}
		catch
		{
		}
		try
		{
			FieldInfo cachedField = GetCachedField(type, memberName);
			if (cachedField != null)
			{
				return cachedField.GetValue(instance);
			}
		}
		catch
		{
		}
		return null;
	}
}
internal static class ModTextHelper
{
	internal static string EscapeRichText(string value)
	{
		if (string.IsNullOrEmpty(value))
		{
			return "";
		}
		return value.Replace("&", "&amp;").Replace("<", "&lt;").Replace(">", "&gt;");
	}

	internal static string NormalizeDisplayName(string value)
	{
		if (string.IsNullOrEmpty(value))
		{
			return "";
		}
		string text = value.Trim();
		if (text.EndsWith("(Clone)", StringComparison.OrdinalIgnoreCase))
		{
			text = text.Substring(0, text.Length - "(Clone)".Length).Trim();
		}
		return text;
	}

	internal static bool TryGetValidDisplayName(string value, out string displayName)
	{
		displayName = null;
		string text = NormalizeDisplayName(value);
		if (string.IsNullOrEmpty(text))
		{
			return false;
		}
		switch (text.ToLowerInvariant())
		{
		case "null":
		case "none":
		case "unknown":
			return false;
		default:
			displayName = text;
			return true;
		}
	}
}