using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using HotbarPlus.Input;
using Microsoft.CodeAnalysis;
using ReservedItemSlotCore;
using ReservedItemSlotCore.Config;
using ReservedItemSlotCore.Data;
using ReservedSlotPositionsForInventory.Cache;
using ReservedSlotPositionsForInventory.Compatibility;
using ReservedSlotPositionsForInventory.NetcodePatcher;
using ReservedSlotPositionsForInventory.Networking;
using ReservedSlotPositionsForInventory.Patches;
using TooManyEmotes;
using TooManyEmotes.Patches;
using Unity.Collections;
using Unity.Netcode;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("ReservedSlotPositionsForInventory")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.6.0")]
[assembly: AssemblyInformationalVersion("1.0.6")]
[assembly: AssemblyProduct("ReservedSlotPositionsForInventory")]
[assembly: AssemblyTitle("ReservedSlotPositionsForInventory")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.6.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: NetcodePatchedAssembly]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace ReservedSlotPositionsForInventory
{
internal static class ConfigManager
{
private static readonly Dictionary<string, SortedDictionary<string, string>> SlotToItems = new Dictionary<string, SortedDictionary<string, string>>(StringComparer.Ordinal);
private static readonly Dictionary<string, ConfigEntry<bool>> SlotToggles = new Dictionary<string, ConfigEntry<bool>>(StringComparer.Ordinal);
private static readonly Dictionary<string, ConfigEntry<string>> SlotItemLists = new Dictionary<string, ConfigEntry<string>>(StringComparer.Ordinal);
internal static ConfigEntry<BoneVisibilityMode> BoneVisibilityModeConfig { get; private set; }
internal static void Initialise(ConfigFile config)
{
BoneVisibilityModeConfig = config.Bind<BoneVisibilityMode>("General", "Visibility Mode", BoneVisibilityMode.FirstPickedUpMode, "Controls which item stays visible when multiple items share the same bone.");
}
internal static bool IsSlotDisabled(string slotName)
{
ConfigEntry<bool> value;
return SlotToggles.TryGetValue(slotName, out value) && value.Value;
}
internal static void EnsureSlotConfig(string slotName)
{
if (!SlotToggles.ContainsKey(slotName))
{
SlotToggles[slotName] = ((BaseUnityPlugin)Plugin.Instance).Config.Bind<bool>("ReservedSlots", "Disable " + slotName + " reserved slot", false, "Disable the ReservedItemSlotCore reserved slot '" + slotName + "'. Will retain custom positions.");
}
if (!SlotItemLists.ContainsKey(slotName))
{
SlotItemLists[slotName] = ((BaseUnityPlugin)Plugin.Instance).Config.Bind<string>("ReservedSlots", "Items used by " + slotName + " slot", SlotToItems.TryGetValue(slotName, out var value) ? string.Join(", ", value.Values) : string.Empty, "Automatically generated list of items used by '" + slotName + "'. Does nothing if changed and is purely informative.");
}
}
internal static void Register(string slotName, ReservedItemData itemData)
{
if (!SlotToItems.TryGetValue(slotName, out var value))
{
value = new SortedDictionary<string, string>(StringComparer.Ordinal);
SlotToItems[slotName] = value;
}
string itemName = itemData.itemName;
bool flag = HasBoneData(itemData);
if (value.TryGetValue(itemName, out var value2) && !value2.EndsWith("[NO BONE DATA]", StringComparison.Ordinal) && !flag)
{
EnsureSlotConfig(slotName);
return;
}
value[itemName] = (flag ? itemName : (itemName + " [NO BONE DATA]"));
EnsureSlotConfig(slotName);
SlotItemLists[slotName].Value = string.Join(", ", value.Values);
}
private static bool HasBoneData(ReservedItemData itemData)
{
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Invalid comparison between Unknown and I4
return itemData.showOnPlayerWhileHolstered && (int)itemData.holsteredParentBone > 0;
}
}
internal enum BoneVisibilityMode
{
FirstPickedUpMode,
LastItemHeldMode
}
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInPlugin("HQ_Team.ReservedSlotPositionsForInventory", "ReservedSlotPositionsForInventory", "1.0.6")]
public sealed class Plugin : BaseUnityPlugin
{
internal const string ModGuid = "HQ_Team.ReservedSlotPositionsForInventory";
private const string ModName = "ReservedSlotPositionsForInventory";
private const string ModVersion = "1.0.6";
private const string HasTooManyEmotes = "FlipMods.TooManyEmotes";
private const string HasHotbarPlus = "FlipMods.HotbarPlus";
private Harmony _harmony;
internal static bool hasTooManyEmotes { get; private set; }
internal static Plugin Instance { get; private set; }
internal static ManualLogSource Log { get; private set; }
private void Awake()
{
//IL_003b: Unknown result type (might be due to invalid IL or missing references)
//IL_0045: Expected O, but got Unknown
hasTooManyEmotes = Chainloader.PluginInfos.ContainsKey("FlipMods.TooManyEmotes");
Instance = this;
Log = ((BaseUnityPlugin)this).Logger;
ConfigManager.Initialise(((BaseUnityPlugin)this).Config);
_harmony = new Harmony("HQ_Team.ReservedSlotPositionsForInventory");
_harmony.PatchAll(typeof(NetworkManagerPatches));
_harmony.PatchAll(typeof(SessionManagerPatches));
_harmony.PatchAll(typeof(ReservedItemSlotDataPatches));
_harmony.PatchAll(typeof(ReservedItemDataPatches));
_harmony.PatchAll(typeof(GrabbableObjectPatches));
_harmony.PatchAll(typeof(StartOfRoundPatches));
_harmony.PatchAll(typeof(FlashlightItemPatches));
_harmony.PatchAll(typeof(ReservedPlayerDataPatches));
_harmony.PatchAll(typeof(PlayerControllerBPatches));
if (Chainloader.PluginInfos.ContainsKey("FlipMods.TooManyEmotes"))
{
_harmony.PatchAll(typeof(TooManyEmotesCompat));
Log.LogInfo((object)"TooManyEmotes compatibility patch ran");
if (Chainloader.PluginInfos.ContainsKey("FlipMods.HotbarPlus"))
{
_harmony.PatchAll(typeof(HotbarPlusCompat));
Log.LogInfo((object)"HotbarPlus compatibility patch ran");
}
}
}
}
public static class PluginInfo
{
public const string PLUGIN_GUID = "ReservedSlotPositionsForInventory";
public const string PLUGIN_NAME = "ReservedSlotPositionsForInventory";
public const string PLUGIN_VERSION = "1.0.6";
}
}
namespace ReservedSlotPositionsForInventory.Patches
{
internal static class FlashlightItemPatches
{
[HarmonyPatch(typeof(FlashlightItem), "SwitchFlashlight")]
[HarmonyPostfix]
private static void SwitchFlashlightPostfix(FlashlightItem __instance, bool on)
{
if (on)
{
FlashlightPriorityCache.MarkToggledOn(__instance);
}
else
{
FlashlightPriorityCache.MarkToggledOff(__instance);
}
HolsterVisibilityCache.RefreshItem((GrabbableObject)(object)__instance);
if (Plugin.hasTooManyEmotes)
{
TooManyEmotesCompat.RefreshItemDuringLocalEmote((GrabbableObject)(object)__instance);
}
}
[HarmonyPatch(typeof(FlashlightItem), "PocketFlashlightClientRpc")]
[HarmonyPostfix]
private static void PocketFlashlightClientRpcPostfix(FlashlightItem __instance, bool stillUsingFlashlight)
{
if (stillUsingFlashlight)
{
FlashlightPriorityCache.MarkToggledOn(__instance);
}
else
{
FlashlightPriorityCache.MarkToggledOff(__instance);
}
HolsterVisibilityCache.RefreshItem((GrabbableObject)(object)__instance);
if (Plugin.hasTooManyEmotes)
{
TooManyEmotesCompat.RefreshItemDuringLocalEmote((GrabbableObject)(object)__instance);
}
}
[HarmonyPatch(typeof(FlashlightItem), "DiscardItem")]
[HarmonyPostfix]
private static void DiscardItemPostfix(FlashlightItem __instance)
{
FlashlightPriorityCache.MarkToggledOff(__instance);
}
[HarmonyPatch(typeof(FlashlightItem), "PocketItem")]
[HarmonyPostfix]
private static void PocketItemPostfix(FlashlightItem __instance)
{
if (((GrabbableObject)__instance).isPocketed && ((GrabbableObject)__instance).isBeingUsed && __instance.usingPlayerHelmetLight)
{
FlashlightPriorityCache.MarkToggledOn(__instance);
}
else
{
FlashlightPriorityCache.MarkToggledOff(__instance);
}
HolsterVisibilityCache.RefreshItem((GrabbableObject)(object)__instance);
if (Plugin.hasTooManyEmotes)
{
TooManyEmotesCompat.RefreshItemDuringLocalEmote((GrabbableObject)(object)__instance);
}
}
}
internal static class GrabbableObjectPatches
{
internal const int HiddenFromLocalPlayerLayer = 23;
private const int VisibleOnRemotePlayersLayer = 6;
private static readonly HashSet<int> LoggedMissingParentItems = new HashSet<int>();
private static readonly HashSet<string> LoggedMissingBones = new HashSet<string>();
internal static bool IsLayerInLocalCameraMask(int layer)
{
Camera gameplayCamera = StartOfRound.Instance.localPlayerController.gameplayCamera;
if ((Object)(object)gameplayCamera == (Object)null)
{
return false;
}
return (gameplayCamera.cullingMask & (1 << layer)) != 0;
}
internal static bool TryGetHolsterData(GrabbableObject item, PlayerControllerB playerController, out ReservedPlayerData playerData, out ReservedItemData itemData)
{
//IL_007e: Unknown result type (might be due to invalid IL or missing references)
//IL_0084: Invalid comparison between Unknown and I4
playerData = null;
itemData = null;
if ((Object)(object)item == (Object)null || (Object)(object)playerController == (Object)null)
{
return false;
}
if (!ReservedPlayerData.allPlayerData.TryGetValue(playerController, out playerData))
{
return false;
}
if (!IsVanillaInventoryOrUtilityItem(item, playerController, playerData))
{
return false;
}
if (playerData.IsItemInReservedItemSlot(item))
{
return false;
}
if (!BoneSlotData.TryGet(item, out itemData))
{
return false;
}
return itemData.showOnPlayerWhileHolstered && (int)itemData.holsteredParentBone > 0;
}
internal static bool TryGetVisibilityHolsterData(GrabbableObject item, PlayerControllerB playerController, out ReservedItemData itemData)
{
itemData = null;
if ((Object)(object)item == (Object)null || (Object)(object)playerController == (Object)null)
{
return false;
}
if (SessionManager.TryGetUnlockedItemData(item, ref itemData) && BoneSlotData.HasBoneData(itemData))
{
return true;
}
return false;
}
private static void RestoreLayers(GrabbableObject item)
{
MeshRenderer[] renderers = RendererCache.GetRenderers(item);
foreach (MeshRenderer val in renderers)
{
if (RendererCache.TryGetOriginalLayer(((Component)val).gameObject, out var layer))
{
((Component)val).gameObject.layer = layer;
RendererCache.ForgetLayer(((Component)val).gameObject);
}
}
}
private static void SetItemVisible(GrabbableObject item, bool visible)
{
if ((Object)(object)item == (Object)null)
{
return;
}
item.EnableItemMeshes(visible);
MeshRenderer[] renderers = RendererCache.GetRenderers(item);
foreach (MeshRenderer val in renderers)
{
if ((Object)(object)val != (Object)null)
{
((Renderer)val).enabled = visible;
}
}
}
internal static GrabbableObject GetEquippedItem(PlayerControllerB playerController)
{
if ((Object)(object)playerController == (Object)null)
{
return null;
}
if (playerController.currentItemSlot == 50)
{
return playerController.ItemOnlySlot;
}
int currentItemSlot = playerController.currentItemSlot;
if (currentItemSlot < 0 || currentItemSlot >= playerController.ItemSlots.Length)
{
return null;
}
return playerController.ItemSlots[currentItemSlot];
}
internal static bool IsVanillaInventoryOrUtilityItem(GrabbableObject item, PlayerControllerB playerController, ReservedPlayerData playerData)
{
if ((Object)(object)item == (Object)null || (Object)(object)playerController == (Object)null || playerData == null)
{
return false;
}
if ((Object)(object)playerController.ItemOnlySlot == (Object)(object)item)
{
return true;
}
int num = Mathf.Min(playerData.reservedHotbarStartIndex, playerController.ItemSlots.Length);
for (int i = 0; i < num; i++)
{
if ((Object)(object)playerController.ItemSlots[i] == (Object)(object)item)
{
return true;
}
}
return false;
}
internal static void Clear()
{
LoggedMissingParentItems.Clear();
LoggedMissingBones.Clear();
}
[HarmonyPatch(typeof(GrabbableObject), "PocketItem")]
[HarmonyPostfix]
private static void PocketItemPostfix(GrabbableObject __instance)
{
//IL_01c6: 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_0124: 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)
PlayerControllerB playerHeldBy = __instance.playerHeldBy;
if ((Object)(object)playerHeldBy == (Object)null)
{
return;
}
if (TryGetHolsterData(__instance, playerHeldBy, out var playerData, out var itemData))
{
MeshRenderer[] renderers = RendererCache.GetRenderers(__instance);
foreach (MeshRenderer val in renderers)
{
RendererCache.RememberLayer(((Component)val).gameObject);
if (playerData.isLocalPlayer)
{
if (IsLayerInLocalCameraMask(((Component)val).gameObject.layer))
{
((Component)val).gameObject.layer = 23;
}
}
else if (!IsLayerInLocalCameraMask(((Component)val).gameObject.layer))
{
((Component)val).gameObject.layer = 6;
}
}
if (__instance.isPocketed)
{
playerData.boneMap.CreateBoneMap(((Component)playerData.playerController).transform, (List<string>)null);
Transform bone = playerData.boneMap.GetBone(itemData.holsteredParentBone);
if ((Object)(object)bone == (Object)null)
{
string item = $"{__instance.itemProperties.itemName}:{itemData.holsteredParentBone}";
if (LoggedMissingBones.Add(item))
{
Plugin.Log.LogWarning((object)$"Failed to find bone '{itemData.holsteredParentBone}' for item '{__instance.itemProperties.itemName}'.");
}
}
else
{
__instance.parentObject = bone;
((Component)__instance).transform.SetParent(bone, false);
__instance.EnableItemMeshes(true);
}
}
}
if (__instance.isPocketed && TryGetVisibilityHolsterData(__instance, playerHeldBy, out var itemData2))
{
HolsterOrderNetwork.EnsureFirstPickupOrder(__instance);
HolsterVisibilityCache.RegisterPocketedItem(playerHeldBy, itemData2.holsteredParentBone, __instance);
}
}
[HarmonyPatch(typeof(GrabbableObject), "EquipItem")]
[HarmonyPatch(typeof(StunGrenadeItem), "EquipItem")]
[HarmonyPostfix]
private static void EquipItemPostfix(GrabbableObject __instance)
{
HolsterVisibilityCache.RemoveItem(__instance);
if (!TryGetHolsterData(__instance, __instance.playerHeldBy, out var playerData, out var _))
{
SetItemVisible(__instance, visible: true);
return;
}
RestoreLayers(__instance);
Transform val = (__instance.parentObject = (playerData.isLocalPlayer ? __instance.playerHeldBy.localItemHolder : __instance.playerHeldBy.serverItemHolder));
if ((Object)(object)val != (Object)null)
{
((Component)__instance).transform.SetParent(val, false);
}
SetItemVisible(__instance, visible: true);
}
[HarmonyPatch(typeof(GrabbableObject), "DiscardItem")]
[HarmonyPostfix]
private static void DiscardItemPostfix(GrabbableObject __instance)
{
if (!((Object)(object)__instance == (Object)null))
{
RestoreLayers(__instance);
HolsterOrderNetwork.NotifyDroppedItem(__instance);
HolsterVisibilityCache.RemoveItemAndForgetPriority(__instance);
}
}
[HarmonyPatch(typeof(GrabbableObject), "LateUpdate")]
[HarmonyPostfix]
private static void LateUpdatePostfix(GrabbableObject __instance)
{
//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
//IL_00fe: 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_0115: 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_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_012b: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)__instance == (Object)null || (Object)(object)__instance.playerHeldBy == (Object)null || !__instance.isHeld || !TryGetHolsterData(__instance, __instance.playerHeldBy, out var playerData, out var itemData) || (Object)(object)__instance == (Object)(object)GetEquippedItem(playerData.playerController))
{
return;
}
if ((Object)(object)__instance.parentObject == (Object)null)
{
int instanceID = ((Object)__instance).GetInstanceID();
if (LoggedMissingParentItems.Add(instanceID))
{
Plugin.Log.LogDebug((object)("parentObject is null for '" + __instance.itemProperties.itemName + "' on player '" + __instance.playerHeldBy.playerUsername + "'."));
}
}
else
{
Transform transform = ((Component)__instance.parentObject).transform;
((Component)__instance).transform.rotation = transform.rotation * Quaternion.Euler(itemData.holsteredRotationOffset);
((Component)__instance).transform.position = transform.position + transform.rotation * itemData.holsteredPositionOffset;
}
}
}
[HarmonyPatch]
internal static class NetworkManagerPatches
{
[HarmonyPatch(typeof(NetworkManager), "Initialize")]
[HarmonyPostfix]
private static void InitializePostfix()
{
HolsterOrderNetwork.RegisterMessages();
}
[HarmonyPatch(typeof(GameNetworkManager), "SetInstanceValuesBackToDefault")]
[HarmonyPostfix]
private static void ResetPostfix()
{
HolsterOrderNetwork.UnregisterMessages();
}
}
internal class PlayerControllerBPatches
{
[HarmonyPatch(typeof(PlayerControllerB), "BeginGrabObject")]
[HarmonyPrefix]
[HarmonyAfter(new string[] { "ReservedItemSlotCore" })]
private static void BeginGrabObjectPrefix(PlayerControllerB __instance)
{
if (!((Object)(object)__instance == (Object)null) && __instance.currentItemSlot == 50 && ReservedPlayerData.allPlayerData.TryGetValue(__instance, out var value) && value.isGrabbingReservedItem)
{
value.previousHotbarIndex = 50;
}
}
[HarmonyPatch(typeof(PlayerControllerB), "GrabObjectClientRpc")]
[HarmonyPrefix]
[HarmonyAfter(new string[] { "ReservedItemSlotCore" })]
private static void GrabObjectClientRpcPrefix(bool grabValidated, PlayerControllerB __instance)
{
if (grabValidated && !((Object)(object)__instance == (Object)null) && __instance.currentItemSlot == 50 && ReservedPlayerData.allPlayerData.TryGetValue(__instance, out var value) && value.isGrabbingReservedItem)
{
value.previousHotbarIndex = 50;
}
}
}
internal static class BoneSlotData
{
private static readonly Dictionary<string, ReservedItemData> CopiedData = new Dictionary<string, ReservedItemData>(StringComparer.Ordinal);
internal static bool TryGet(GrabbableObject item, out ReservedItemData itemData)
{
itemData = null;
string text = item?.itemProperties?.itemName;
return text != null && CopiedData.TryGetValue(text, out itemData);
}
internal static bool TryGet(string itemName, out ReservedItemData itemData)
{
itemData = null;
return !string.IsNullOrEmpty(itemName) && CopiedData.TryGetValue(itemName, out itemData);
}
internal static void Set(string itemName, ReservedItemData itemData)
{
if (string.IsNullOrEmpty(itemName) || itemData == null)
{
return;
}
bool flag = HasBoneData(itemData);
if (!CopiedData.TryGetValue(itemName, out var value))
{
CopiedData[itemName] = itemData;
return;
}
bool flag2 = HasBoneData(value);
if (!flag2 || flag)
{
if (!flag2 && flag)
{
CopiedData[itemName] = itemData;
}
else if (!(flag2 && flag))
{
}
}
}
internal static bool HasBoneData(ReservedItemData itemData)
{
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_0013: Invalid comparison between Unknown and I4
return itemData != null && itemData.showOnPlayerWhileHolstered && (int)itemData.holsteredParentBone > 0;
}
}
[HarmonyPatch(typeof(ReservedItemData))]
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
[HarmonyPatch(new Type[]
{
typeof(string),
typeof(PlayerBone),
typeof(Vector3),
typeof(Vector3)
})]
internal static class ReservedItemDataPatches
{
[HarmonyPostfix]
private static void Postfix(ReservedItemData __instance, string itemName)
{
BoneSlotData.Set(itemName, __instance);
}
}
internal static class ReservedItemSlotDataPatches
{
[HarmonyPatch(typeof(ReservedItemSlotData), "AddItemToReservedItemSlot", new Type[] { typeof(ReservedItemData) })]
[HarmonyPrefix]
private static void Prefix(ReservedItemSlotData __instance, ReservedItemData itemData)
{
if (itemData != null && !string.IsNullOrEmpty(itemData.itemName))
{
ConfigManager.Register(__instance.slotName, itemData);
}
}
[HarmonyPatch(typeof(ReservedItemSlotData), "CreateReservedItemSlotData")]
[HarmonyPostfix]
private static void Postfix(ReservedItemSlotData __result)
{
if (__result != null)
{
ConfigManager.EnsureSlotConfig(__result.slotName);
}
}
}
internal static class ReservedPlayerDataPatches
{
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
[HarmonyPostfix]
private static void CurrentlySelectedItemGetterPostfix(ReservedPlayerData __instance, ref GrabbableObject __result)
{
if (__instance != null && !((Object)(object)__instance.playerController == (Object)null) && __instance.currentItemSlot == 50)
{
__result = __instance.playerController.ItemOnlySlot;
}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
[HarmonyPostfix]
private static void PreviouslyHeldItemGetterPostfix(ReservedPlayerData __instance, ref GrabbableObject __result)
{
if (__instance != null && !((Object)(object)__instance.playerController == (Object)null) && __instance.previousHotbarIndex == 50)
{
__result = __instance.playerController.ItemOnlySlot;
}
}
}
internal static class SessionManagerPatches
{
[HarmonyPatch(typeof(SessionManager), "UnlockReservedItemSlot")]
[HarmonyPrefix]
private static bool Prefix(ReservedItemSlotData itemSlotData)
{
if (ConfigSettings.enablePurchasingItemSlots.Value || itemSlotData == null)
{
return true;
}
return !ConfigManager.IsSlotDisabled(itemSlotData.slotName);
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
[HarmonyPostfix]
private static void TryGetUnlockedItemDataPostfix(GrabbableObject item, ref ReservedItemData itemData, ref bool __result)
{
if ((!__result || !BoneSlotData.HasBoneData(itemData)) && BoneSlotData.TryGet(item, out var itemData2) && BoneSlotData.HasBoneData(itemData2))
{
itemData = itemData2;
__result = true;
}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
[HarmonyPostfix]
private static void TryGetUnlockedItemDataPostfix(string itemName, ref ReservedItemData itemData, ref bool __result)
{
if ((!__result || !BoneSlotData.HasBoneData(itemData)) && BoneSlotData.TryGet(itemName, out var itemData2) && BoneSlotData.HasBoneData(itemData2))
{
itemData = itemData2;
__result = true;
}
}
}
internal static class StartOfRoundPatches
{
[HarmonyPatch(typeof(StartOfRound), "OnDestroy")]
[HarmonyPostfix]
private static void Postfix()
{
Stopwatch stopwatch = Stopwatch.StartNew();
Plugin.Log.LogInfo((object)"Starting cleanup.");
GrabbableObjectPatches.Clear();
Plugin.Log.LogDebug((object)"GrabbableObjectPatches caches cleared");
RendererCache.Clear();
Plugin.Log.LogDebug((object)"Renderer cache cleared");
HolsterVisibilityCache.Clear();
Plugin.Log.LogDebug((object)"HolsterVisibility cache cleared");
HolsterOrderNetwork.UnregisterMessages();
Plugin.Log.LogDebug((object)"HolsterOrderNetwork cache cleared");
FlashlightPriorityCache.Clear();
Plugin.Log.LogDebug((object)"FlashlightPriority cache cleared");
stopwatch.Stop();
Plugin.Log.LogInfo((object)$"Cleanup complete in {stopwatch.Elapsed.TotalMilliseconds:F3} ms");
}
}
}
namespace ReservedSlotPositionsForInventory.Networking
{
internal static class HolsterOrderNetwork
{
[CompilerGenerated]
private static class <>O
{
public static HandleNamedMessageDelegate <0>__OnSetFirstPickupOrderServerRpc;
public static HandleNamedMessageDelegate <1>__OnSetFirstPickupOrderClientRpc;
public static HandleNamedMessageDelegate <2>__OnForgetFirstPickupOrderServerRpc;
public static HandleNamedMessageDelegate <3>__OnForgetFirstPickupOrderClientRpc;
}
private static readonly string SetFirstPickupOrderServerRpcMessage = "HQ_Team.ReservedSlotPositionsForInventory.SetFirstPickupOrderServerRpc";
private static readonly string SetFirstPickupOrderClientRpcMessage = "HQ_Team.ReservedSlotPositionsForInventory.SetFirstPickupOrderClientRpc";
private static readonly string ForgetFirstPickupOrderServerRpcMessage = "HQ_Team.ReservedSlotPositionsForInventory.ForgetFirstPickupOrderServerRpc";
private static readonly string ForgetFirstPickupOrderClientRpcMessage = "HQ_Team.ReservedSlotPositionsForInventory.ForgetFirstPickupOrderClientRpc";
private static long _nextLocalOrder;
private static bool _registered;
internal static void RegisterMessages()
{
//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: Expected O, but got Unknown
//IL_0069: 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_0074: Expected O, but got Unknown
//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: Expected O, but got Unknown
//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
//IL_00c2: Expected O, but got Unknown
if (!_registered && NetworkManager.Singleton.CustomMessagingManager != null)
{
CustomMessagingManager customMessagingManager = NetworkManager.Singleton.CustomMessagingManager;
string setFirstPickupOrderServerRpcMessage = SetFirstPickupOrderServerRpcMessage;
object obj = <>O.<0>__OnSetFirstPickupOrderServerRpc;
if (obj == null)
{
HandleNamedMessageDelegate val = OnSetFirstPickupOrderServerRpc;
<>O.<0>__OnSetFirstPickupOrderServerRpc = val;
obj = (object)val;
}
customMessagingManager.RegisterNamedMessageHandler(setFirstPickupOrderServerRpcMessage, (HandleNamedMessageDelegate)obj);
string setFirstPickupOrderClientRpcMessage = SetFirstPickupOrderClientRpcMessage;
object obj2 = <>O.<1>__OnSetFirstPickupOrderClientRpc;
if (obj2 == null)
{
HandleNamedMessageDelegate val2 = OnSetFirstPickupOrderClientRpc;
<>O.<1>__OnSetFirstPickupOrderClientRpc = val2;
obj2 = (object)val2;
}
customMessagingManager.RegisterNamedMessageHandler(setFirstPickupOrderClientRpcMessage, (HandleNamedMessageDelegate)obj2);
string forgetFirstPickupOrderServerRpcMessage = ForgetFirstPickupOrderServerRpcMessage;
object obj3 = <>O.<2>__OnForgetFirstPickupOrderServerRpc;
if (obj3 == null)
{
HandleNamedMessageDelegate val3 = OnForgetFirstPickupOrderServerRpc;
<>O.<2>__OnForgetFirstPickupOrderServerRpc = val3;
obj3 = (object)val3;
}
customMessagingManager.RegisterNamedMessageHandler(forgetFirstPickupOrderServerRpcMessage, (HandleNamedMessageDelegate)obj3);
string forgetFirstPickupOrderClientRpcMessage = ForgetFirstPickupOrderClientRpcMessage;
object obj4 = <>O.<3>__OnForgetFirstPickupOrderClientRpc;
if (obj4 == null)
{
HandleNamedMessageDelegate val4 = OnForgetFirstPickupOrderClientRpc;
<>O.<3>__OnForgetFirstPickupOrderClientRpc = val4;
obj4 = (object)val4;
}
customMessagingManager.RegisterNamedMessageHandler(forgetFirstPickupOrderClientRpcMessage, (HandleNamedMessageDelegate)obj4);
_registered = true;
_nextLocalOrder = 0L;
}
}
internal static void UnregisterMessages()
{
if (_registered && NetworkManager.Singleton.CustomMessagingManager != null)
{
CustomMessagingManager customMessagingManager = NetworkManager.Singleton.CustomMessagingManager;
customMessagingManager.UnregisterNamedMessageHandler(SetFirstPickupOrderServerRpcMessage);
customMessagingManager.UnregisterNamedMessageHandler(SetFirstPickupOrderClientRpcMessage);
customMessagingManager.UnregisterNamedMessageHandler(ForgetFirstPickupOrderServerRpcMessage);
customMessagingManager.UnregisterNamedMessageHandler(ForgetFirstPickupOrderClientRpcMessage);
_registered = false;
_nextLocalOrder = 0L;
}
}
internal static void EnsureFirstPickupOrder(GrabbableObject item)
{
//IL_0082: 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)
if (HolsterVisibilityCache.UsesSyncedFirstPickupOrdering && TryGetNetworkObjectReference(item, out var itemReference) && (ConfigManager.BoneVisibilityModeConfig.Value == BoneVisibilityMode.LastItemHeldMode || !HolsterVisibilityCache.HasSyncedFirstPickupOrder(((NetworkObjectReference)(ref itemReference)).NetworkObjectId)))
{
long order = _nextLocalOrder++;
HolsterVisibilityCache.ApplySyncedFirstPickupOrder(((NetworkObjectReference)(ref itemReference)).NetworkObjectId, order);
if (NetworkManager.Singleton.IsServer)
{
SendSetFirstPickupOrderClientRpc(itemReference, order);
}
else
{
SendSetFirstPickupOrderServerRpc(itemReference, order);
}
}
}
internal static void NotifyDroppedItem(GrabbableObject item)
{
//IL_0037: 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)
if (TryGetNetworkObjectReference(item, out var itemReference))
{
if (NetworkManager.Singleton.IsServer)
{
HolsterVisibilityCache.RemoveSyncedFirstPickupOrder(((NetworkObjectReference)(ref itemReference)).NetworkObjectId);
SendForgetFirstPickupOrderClientRpc(itemReference);
}
else
{
SendForgetFirstPickupOrderServerRpc(itemReference);
}
}
}
private static void SendSetFirstPickupOrderServerRpc(NetworkObjectReference itemReference, long order)
{
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: 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)
FastBufferWriter val = default(FastBufferWriter);
((FastBufferWriter)(ref val))..ctor(256, (Allocator)2, -1);
try
{
((FastBufferWriter)(ref val)).WriteNetworkSerializable<NetworkObjectReference>(ref itemReference);
((FastBufferWriter)(ref val)).WriteValueSafe<long>(ref order, default(ForPrimitives));
NetworkManager.Singleton.CustomMessagingManager.SendNamedMessage(SetFirstPickupOrderServerRpcMessage, 0uL, val, (NetworkDelivery)2);
}
finally
{
((IDisposable)(FastBufferWriter)(ref val)).Dispose();
}
}
private static void SendSetFirstPickupOrderClientRpc(NetworkObjectReference itemReference, long order)
{
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: 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)
FastBufferWriter val = default(FastBufferWriter);
((FastBufferWriter)(ref val))..ctor(256, (Allocator)2, -1);
try
{
((FastBufferWriter)(ref val)).WriteNetworkSerializable<NetworkObjectReference>(ref itemReference);
((FastBufferWriter)(ref val)).WriteValueSafe<long>(ref order, default(ForPrimitives));
NetworkManager.Singleton.CustomMessagingManager.SendNamedMessageToAll(SetFirstPickupOrderClientRpcMessage, val, (NetworkDelivery)2);
}
finally
{
((IDisposable)(FastBufferWriter)(ref val)).Dispose();
}
}
private static void SendForgetFirstPickupOrderServerRpc(NetworkObjectReference itemReference)
{
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
FastBufferWriter val = default(FastBufferWriter);
((FastBufferWriter)(ref val))..ctor(128, (Allocator)2, -1);
try
{
((FastBufferWriter)(ref val)).WriteNetworkSerializable<NetworkObjectReference>(ref itemReference);
NetworkManager.Singleton.CustomMessagingManager.SendNamedMessage(ForgetFirstPickupOrderServerRpcMessage, 0uL, val, (NetworkDelivery)2);
}
finally
{
((IDisposable)(FastBufferWriter)(ref val)).Dispose();
}
}
private static void SendForgetFirstPickupOrderClientRpc(NetworkObjectReference itemReference)
{
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
FastBufferWriter val = default(FastBufferWriter);
((FastBufferWriter)(ref val))..ctor(128, (Allocator)2, -1);
try
{
((FastBufferWriter)(ref val)).WriteNetworkSerializable<NetworkObjectReference>(ref itemReference);
NetworkManager.Singleton.CustomMessagingManager.SendNamedMessageToAll(ForgetFirstPickupOrderClientRpcMessage, val, (NetworkDelivery)2);
}
finally
{
((IDisposable)(FastBufferWriter)(ref val)).Dispose();
}
}
private static void OnSetFirstPickupOrderServerRpc(ulong senderId, FastBufferReader reader)
{
//IL_0026: 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_0041: Unknown result type (might be due to invalid IL or missing references)
if (!NetworkManager.Singleton.IsServer)
{
return;
}
try
{
NetworkObjectReference itemReference = default(NetworkObjectReference);
((FastBufferReader)(ref reader)).ReadNetworkSerializable<NetworkObjectReference>(ref itemReference);
long order = default(long);
((FastBufferReader)(ref reader)).ReadValueSafe<long>(ref order, default(ForPrimitives));
HolsterVisibilityCache.ApplySyncedFirstPickupOrder(((NetworkObjectReference)(ref itemReference)).NetworkObjectId, order);
SendSetFirstPickupOrderClientRpc(itemReference, order);
}
catch (Exception arg)
{
Plugin.Log.LogError((object)$"SetFirstPickupOrderServerRpc: {arg}");
}
}
private static void OnSetFirstPickupOrderClientRpc(ulong senderId, FastBufferReader reader)
{
//IL_001e: 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)
if (senderId != 0)
{
return;
}
try
{
NetworkObjectReference val = default(NetworkObjectReference);
((FastBufferReader)(ref reader)).ReadNetworkSerializable<NetworkObjectReference>(ref val);
long order = default(long);
((FastBufferReader)(ref reader)).ReadValueSafe<long>(ref order, default(ForPrimitives));
HolsterVisibilityCache.ApplySyncedFirstPickupOrder(((NetworkObjectReference)(ref val)).NetworkObjectId, order);
}
catch (Exception arg)
{
Plugin.Log.LogError((object)$"SetFirstPickupOrderClientRpc: {arg}");
}
}
private static void OnForgetFirstPickupOrderServerRpc(ulong senderId, FastBufferReader reader)
{
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
if (!NetworkManager.Singleton.IsServer)
{
return;
}
try
{
NetworkObjectReference itemReference = default(NetworkObjectReference);
((FastBufferReader)(ref reader)).ReadNetworkSerializable<NetworkObjectReference>(ref itemReference);
HolsterVisibilityCache.RemoveSyncedFirstPickupOrder(((NetworkObjectReference)(ref itemReference)).NetworkObjectId);
SendForgetFirstPickupOrderClientRpc(itemReference);
}
catch (Exception arg)
{
Plugin.Log.LogError((object)$"ForgetFirstPickupOrderServerRpc: {arg}");
}
}
private static void OnForgetFirstPickupOrderClientRpc(ulong senderId, FastBufferReader reader)
{
if (senderId != 0)
{
return;
}
try
{
NetworkObjectReference val = default(NetworkObjectReference);
((FastBufferReader)(ref reader)).ReadNetworkSerializable<NetworkObjectReference>(ref val);
HolsterVisibilityCache.RemoveSyncedFirstPickupOrder(((NetworkObjectReference)(ref val)).NetworkObjectId);
}
catch (Exception arg)
{
Plugin.Log.LogError((object)$"ForgetFirstPickupOrderClientRpc: {arg}");
}
}
private static bool TryGetNetworkObjectReference(GrabbableObject item, out NetworkObjectReference itemReference)
{
//IL_0002: 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_0044: Unknown result type (might be due to invalid IL or missing references)
itemReference = default(NetworkObjectReference);
if ((Object)(object)item == (Object)null || (Object)(object)((NetworkBehaviour)item).NetworkObject == (Object)null || !((NetworkBehaviour)item).NetworkObject.IsSpawned)
{
return false;
}
itemReference = NetworkObjectReference.op_Implicit(((NetworkBehaviour)item).NetworkObject);
return true;
}
}
}
namespace ReservedSlotPositionsForInventory.Compatibility
{
[HarmonyPatch(typeof(Keybinds), "OnPressItemSlotHotkeyAction")]
internal static class HotbarPlusCompat
{
[HarmonyPrefix]
private static bool Prefix()
{
EmoteControllerPlayer emoteControllerLocal = EmoteControllerPlayer.emoteControllerLocal;
return (Object)(object)emoteControllerLocal == (Object)null || !((EmoteController)emoteControllerLocal).IsPerformingCustomEmote();
}
}
internal static class TooManyEmotesCompat
{
internal static bool IsLocalCustomEmoteActive { get; private set; }
internal static void RefreshItemDuringLocalEmote(GrabbableObject item)
{
if (!IsLocalCustomEmoteActive || (Object)(object)item == (Object)null)
{
return;
}
ReservedPlayerData localPlayerData = ReservedPlayerData.localPlayerData;
if (localPlayerData == null)
{
return;
}
PlayerControllerB playerController = localPlayerData.playerController;
if ((Object)(object)playerController == (Object)null || (Object)(object)item.playerHeldBy != (Object)(object)playerController)
{
return;
}
int num = Mathf.Min(localPlayerData.reservedHotbarStartIndex, playerController.ItemSlots.Length);
bool flag = false;
for (int i = 0; i < num; i++)
{
if (!((Object)(object)playerController.ItemSlots[i] != (Object)(object)item))
{
if (i == playerController.currentItemSlot)
{
return;
}
flag = true;
break;
}
}
if (!flag && (Object)(object)playerController.ItemOnlySlot == (Object)(object)item)
{
if (playerController.currentItemSlot == 50)
{
return;
}
flag = true;
}
if (!flag || !GrabbableObjectPatches.TryGetHolsterData(item, playerController, out var _, out var _))
{
return;
}
MeshRenderer[] renderers = RendererCache.GetRenderers(item);
foreach (MeshRenderer val in renderers)
{
((Renderer)val).enabled = true;
if (RendererCache.TryGetOriginalLayer(((Component)val).gameObject, out var layer) && !GrabbableObjectPatches.IsLayerInLocalCameraMask(((Component)val).gameObject.layer))
{
((Component)val).gameObject.layer = layer;
}
}
}
[HarmonyPatch(typeof(ThirdPersonEmoteController), "OnStartCustomEmoteLocal")]
[HarmonyPostfix]
private static void OnStartCustomEmoteLocalPostfix()
{
IsLocalCustomEmoteActive = true;
ReservedPlayerData localPlayerData = ReservedPlayerData.localPlayerData;
if (localPlayerData == null)
{
return;
}
PlayerControllerB playerController = localPlayerData.playerController;
if ((Object)(object)playerController == (Object)null)
{
return;
}
int num = Mathf.Min(localPlayerData.reservedHotbarStartIndex, playerController.ItemSlots.Length);
ReservedPlayerData playerData;
ReservedItemData itemData;
for (int i = 0; i < num; i++)
{
if (i == playerController.currentItemSlot)
{
continue;
}
GrabbableObject val = playerController.ItemSlots[i];
if ((Object)(object)val == (Object)null || !GrabbableObjectPatches.TryGetHolsterData(val, playerController, out playerData, out itemData))
{
continue;
}
MeshRenderer[] renderers = RendererCache.GetRenderers(val);
foreach (MeshRenderer val2 in renderers)
{
((Renderer)val2).enabled = true;
if (RendererCache.TryGetOriginalLayer(((Component)val2).gameObject, out var layer) && !GrabbableObjectPatches.IsLayerInLocalCameraMask(((Component)val2).gameObject.layer))
{
((Component)val2).gameObject.layer = layer;
}
}
}
if (playerController.currentItemSlot == 50)
{
return;
}
GrabbableObject itemOnlySlot = playerController.ItemOnlySlot;
if ((Object)(object)itemOnlySlot == (Object)null || !GrabbableObjectPatches.TryGetHolsterData(itemOnlySlot, playerController, out playerData, out itemData))
{
return;
}
MeshRenderer[] renderers2 = RendererCache.GetRenderers(itemOnlySlot);
foreach (MeshRenderer val3 in renderers2)
{
((Renderer)val3).enabled = true;
if (RendererCache.TryGetOriginalLayer(((Component)val3).gameObject, out var layer2) && !GrabbableObjectPatches.IsLayerInLocalCameraMask(((Component)val3).gameObject.layer))
{
((Component)val3).gameObject.layer = layer2;
}
}
}
[HarmonyPatch(typeof(ThirdPersonEmoteController), "OnStopCustomEmoteLocal")]
[HarmonyPostfix]
private static void OnStopCustomEmoteLocalPostfix()
{
IsLocalCustomEmoteActive = false;
ReservedPlayerData localPlayerData = ReservedPlayerData.localPlayerData;
if (localPlayerData == null)
{
return;
}
PlayerControllerB playerController = localPlayerData.playerController;
if ((Object)(object)playerController == (Object)null)
{
return;
}
int num = Mathf.Min(localPlayerData.reservedHotbarStartIndex, playerController.ItemSlots.Length);
ReservedPlayerData playerData;
ReservedItemData itemData;
int layer;
for (int i = 0; i < num; i++)
{
if (i == playerController.currentItemSlot)
{
continue;
}
GrabbableObject val = playerController.ItemSlots[i];
if ((Object)(object)val == (Object)null || !GrabbableObjectPatches.TryGetHolsterData(val, playerController, out playerData, out itemData))
{
continue;
}
MeshRenderer[] renderers = RendererCache.GetRenderers(val);
foreach (MeshRenderer val2 in renderers)
{
if (RendererCache.TryGetOriginalLayer(((Component)val2).gameObject, out layer) && GrabbableObjectPatches.IsLayerInLocalCameraMask(((Component)val2).gameObject.layer))
{
((Component)val2).gameObject.layer = 23;
}
}
HolsterVisibilityCache.RefreshItem(val);
}
if (playerController.currentItemSlot == 50)
{
return;
}
GrabbableObject itemOnlySlot = playerController.ItemOnlySlot;
if ((Object)(object)itemOnlySlot == (Object)null || !GrabbableObjectPatches.TryGetHolsterData(itemOnlySlot, playerController, out playerData, out itemData))
{
return;
}
MeshRenderer[] renderers2 = RendererCache.GetRenderers(itemOnlySlot);
foreach (MeshRenderer val3 in renderers2)
{
if (RendererCache.TryGetOriginalLayer(((Component)val3).gameObject, out layer) && GrabbableObjectPatches.IsLayerInLocalCameraMask(((Component)val3).gameObject.layer))
{
((Component)val3).gameObject.layer = 23;
}
}
HolsterVisibilityCache.RefreshItem(itemOnlySlot);
}
[HarmonyPatch(typeof(PlayerControllerB), "UseUtilitySlot_performed")]
[HarmonyPrefix]
private static bool UseUtilitySlot_performedPrefix(PlayerControllerB __instance)
{
if (!IsLocalCustomEmoteActive)
{
return true;
}
PlayerControllerB val = StartOfRound.Instance?.localPlayerController;
if ((Object)(object)__instance != (Object)(object)val)
{
return true;
}
return false;
}
}
}
namespace ReservedSlotPositionsForInventory.Cache
{
internal static class FlashlightPriorityCache
{
private static readonly Dictionary<int, long> ToggleOrderByItemId = new Dictionary<int, long>();
private static long NextToggleOrder;
internal static void MarkToggledOn(FlashlightItem flashlight)
{
if (!((Object)(object)flashlight == (Object)null))
{
ToggleOrderByItemId[((Object)flashlight).GetInstanceID()] = NextToggleOrder;
NextToggleOrder++;
}
}
internal static void MarkToggledOff(FlashlightItem flashlight)
{
if (!((Object)(object)flashlight == (Object)null))
{
ToggleOrderByItemId.Remove(((Object)flashlight).GetInstanceID());
}
}
internal static bool TryGetToggleOrder(FlashlightItem flashlight, out long order)
{
order = 0L;
return (Object)(object)flashlight != (Object)null && ToggleOrderByItemId.TryGetValue(((Object)flashlight).GetInstanceID(), out order);
}
internal static void Clear()
{
ToggleOrderByItemId.Clear();
NextToggleOrder = 0L;
}
}
internal readonly struct HolsterBoneKey : IEquatable<HolsterBoneKey>
{
private readonly int _playerId;
private readonly PlayerBone _bone;
internal HolsterBoneKey(PlayerControllerB playerController, PlayerBone bone)
{
//IL_000e: 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)
_playerId = ((Object)playerController).GetInstanceID();
_bone = bone;
}
public bool Equals(HolsterBoneKey other)
{
//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)
return _playerId == other._playerId && _bone == other._bone;
}
public override bool Equals(object obj)
{
return obj is HolsterBoneKey other && Equals(other);
}
public override int GetHashCode()
{
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Expected I4, but got Unknown
return HashCode.Combine(_playerId, (int)_bone);
}
}
internal static class HolsterVisibilityCache
{
internal static readonly Dictionary<HolsterBoneKey, List<GrabbableObject>> ItemsByBone = new Dictionary<HolsterBoneKey, List<GrabbableObject>>();
internal static readonly Dictionary<int, HolsterBoneKey> KeyByItemId = new Dictionary<int, HolsterBoneKey>();
internal static readonly Dictionary<ulong, long> SyncedFirstPickupOrderByNetworkObjectId = new Dictionary<ulong, long>();
internal static bool UsesSyncedFirstPickupOrdering => ConfigManager.BoneVisibilityModeConfig.Value == BoneVisibilityMode.FirstPickedUpMode || ConfigManager.BoneVisibilityModeConfig.Value == BoneVisibilityMode.LastItemHeldMode;
internal static void RegisterPocketedItem(PlayerControllerB playerController, PlayerBone bone, GrabbableObject item)
{
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
int instanceID = ((Object)item).GetInstanceID();
HolsterBoneKey holsterBoneKey = new HolsterBoneKey(playerController, bone);
if (KeyByItemId.TryGetValue(instanceID, out var value) && !value.Equals(holsterBoneKey) && ItemsByBone.TryGetValue(value, out var value2))
{
RemoveDeadAndItem(value2, item);
if (value2.Count == 0)
{
ItemsByBone.Remove(value);
}
else
{
RefreshVisibleItem(value2);
}
}
if (!ItemsByBone.TryGetValue(holsterBoneKey, out var value3))
{
value3 = new List<GrabbableObject>();
ItemsByBone[holsterBoneKey] = value3;
}
RemoveDeadAndItem(value3, item);
value3.Add(item);
KeyByItemId[instanceID] = holsterBoneKey;
RefreshVisibleItem(value3);
}
internal static void RemoveItem(GrabbableObject item)
{
if ((Object)(object)item == (Object)null)
{
return;
}
int instanceID = ((Object)item).GetInstanceID();
if (!KeyByItemId.TryGetValue(instanceID, out var value))
{
SetItemVisible(item, visible: true);
return;
}
KeyByItemId.Remove(instanceID);
if (!ItemsByBone.TryGetValue(value, out var value2))
{
SetItemVisible(item, visible: true);
return;
}
RemoveDeadAndItem(value2, item);
SetItemVisible(item, visible: true);
if (value2.Count == 0)
{
ItemsByBone.Remove(value);
}
else
{
RefreshVisibleItem(value2);
}
}
internal static void RemoveItemAndForgetPriority(GrabbableObject item)
{
RemoveItem(item);
if (TryGetNetworkObjectId(item, out var networkObjectId))
{
RemoveSyncedFirstPickupOrder(networkObjectId);
}
}
internal static bool HasSyncedFirstPickupOrder(ulong networkObjectId)
{
return SyncedFirstPickupOrderByNetworkObjectId.ContainsKey(networkObjectId);
}
internal static void ApplySyncedFirstPickupOrder(ulong networkObjectId, long order)
{
SyncedFirstPickupOrderByNetworkObjectId[networkObjectId] = order;
GrabbableObject grabbableObjectByNetworkId = GetGrabbableObjectByNetworkId(networkObjectId);
if ((Object)(object)grabbableObjectByNetworkId != (Object)null)
{
RefreshItem(grabbableObjectByNetworkId);
}
}
internal static void RemoveSyncedFirstPickupOrder(ulong networkObjectId)
{
if (SyncedFirstPickupOrderByNetworkObjectId.Remove(networkObjectId))
{
GrabbableObject grabbableObjectByNetworkId = GetGrabbableObjectByNetworkId(networkObjectId);
if ((Object)(object)grabbableObjectByNetworkId != (Object)null)
{
RefreshItem(grabbableObjectByNetworkId);
}
}
}
internal static void RefreshItem(GrabbableObject item)
{
if (!((Object)(object)item == (Object)null))
{
int instanceID = ((Object)item).GetInstanceID();
if (KeyByItemId.TryGetValue(instanceID, out var value) && ItemsByBone.TryGetValue(value, out var value2))
{
RefreshVisibleItem(value2);
}
}
}
internal static void Clear()
{
ItemsByBone.Clear();
KeyByItemId.Clear();
SyncedFirstPickupOrderByNetworkObjectId.Clear();
}
private static void RefreshVisibleItem(List<GrabbableObject> items)
{
RemoveDead(items);
if (items.Count != 0)
{
GrabbableObject preferredVisibleItem = GetPreferredVisibleItem(items);
for (int i = 0; i < items.Count; i++)
{
SetItemVisible(items[i], (Object)(object)items[i] == (Object)(object)preferredVisibleItem);
}
}
}
private static GrabbableObject GetPreferredVisibleItem(List<GrabbableObject> items)
{
if (TryGetPriorityFlashlight(items, out var priorityFlashlight))
{
return priorityFlashlight;
}
BoneVisibilityMode value = ConfigManager.BoneVisibilityModeConfig.Value;
if (1 == 0)
{
}
GrabbableObject result = (GrabbableObject)(value switch
{
BoneVisibilityMode.FirstPickedUpMode => GetFirstPickedUpItem(items),
BoneVisibilityMode.LastItemHeldMode => GetLastItemHeldItem(items),
_ => GetFirstPickedUpItem(items),
});
if (1 == 0)
{
}
return result;
}
private static bool TryGetPriorityFlashlight(List<GrabbableObject> items, out GrabbableObject priorityFlashlight)
{
priorityFlashlight = null;
FlashlightItem val = null;
long num = long.MinValue;
bool flag = false;
for (int i = 0; i < items.Count; i++)
{
GrabbableObject obj = items[i];
FlashlightItem val2 = (FlashlightItem)(object)((obj is FlashlightItem) ? obj : null);
if (val2 == null || !IsPriorityFlashlight(val2))
{
continue;
}
if (FlashlightPriorityCache.TryGetToggleOrder(val2, out var order))
{
if (!flag || order > num)
{
val = val2;
num = order;
flag = true;
}
}
else if ((Object)(object)val == (Object)null)
{
val = val2;
}
}
priorityFlashlight = (GrabbableObject)(object)val;
return (Object)(object)priorityFlashlight != (Object)null;
}
private static bool IsPriorityFlashlight(FlashlightItem flashlight)
{
if (!((GrabbableObject)flashlight).isBeingUsed)
{
return false;
}
if (flashlight.usingPlayerHelmetLight)
{
return true;
}
PlayerControllerB playerHeldBy = ((GrabbableObject)flashlight).playerHeldBy;
return (Object)(object)playerHeldBy != (Object)null && (Object)(object)playerHeldBy.pocketedFlashlight == (Object)(object)flashlight;
}
private static GrabbableObject GetFirstPickedUpItem(List<GrabbableObject> items)
{
GrabbableObject val = items[0];
long num = GetSyncedFirstPickupOrder(val);
for (int i = 1; i < items.Count; i++)
{
GrabbableObject val2 = items[i];
long syncedFirstPickupOrder = GetSyncedFirstPickupOrder(val2);
if (syncedFirstPickupOrder < num)
{
val = val2;
num = syncedFirstPickupOrder;
}
}
return val;
}
private static GrabbableObject GetLastItemHeldItem(List<GrabbableObject> items)
{
GrabbableObject val = items[0];
long num = GetSyncedFirstPickupOrder(val);
for (int i = 1; i < items.Count; i++)
{
GrabbableObject val2 = items[i];
long syncedFirstPickupOrder = GetSyncedFirstPickupOrder(val2);
if (syncedFirstPickupOrder > num)
{
val = val2;
num = syncedFirstPickupOrder;
}
}
return val;
}
private static long GetSyncedFirstPickupOrder(GrabbableObject item)
{
if (!TryGetNetworkObjectId(item, out var networkObjectId))
{
return long.MaxValue;
}
long value;
return SyncedFirstPickupOrderByNetworkObjectId.TryGetValue(networkObjectId, out value) ? value : long.MaxValue;
}
private static void RemoveDead(List<GrabbableObject> items)
{
for (int num = items.Count - 1; num >= 0; num--)
{
if (!((Object)(object)items[num] != (Object)null))
{
items.RemoveAt(num);
}
}
}
private static void RemoveDeadAndItem(List<GrabbableObject> items, GrabbableObject item)
{
for (int num = items.Count - 1; num >= 0; num--)
{
GrabbableObject val = items[num];
if (!((Object)(object)val != (Object)null) || !((Object)(object)val != (Object)(object)item))
{
items.RemoveAt(num);
}
}
}
private static bool TryGetNetworkObjectId(GrabbableObject item, out ulong networkObjectId)
{
networkObjectId = 0uL;
if ((Object)(object)item == (Object)null || (Object)(object)((NetworkBehaviour)item).NetworkObject == (Object)null || !((NetworkBehaviour)item).NetworkObject.IsSpawned)
{
return false;
}
networkObjectId = ((NetworkBehaviour)item).NetworkObject.NetworkObjectId;
return true;
}
private static GrabbableObject GetGrabbableObjectByNetworkId(ulong networkObjectId)
{
NetworkManager singleton = NetworkManager.Singleton;
if (((singleton != null) ? singleton.SpawnManager : null) == null)
{
return null;
}
if (!singleton.SpawnManager.SpawnedObjects.TryGetValue(networkObjectId, out var value))
{
return null;
}
return ((Component)value).GetComponent<GrabbableObject>();
}
private static void SetItemVisible(GrabbableObject item, bool visible)
{
if ((Object)(object)item == (Object)null)
{
return;
}
item.EnableItemMeshes(visible);
MeshRenderer[] renderers = RendererCache.GetRenderers(item);
foreach (MeshRenderer val in renderers)
{
if ((Object)(object)val != (Object)null)
{
((Renderer)val).enabled = visible;
}
}
}
}
internal static class RendererCache
{
private static readonly Dictionary<int, MeshRenderer[]> RenderersByItem = new Dictionary<int, MeshRenderer[]>();
private static readonly Dictionary<GameObject, int> OriginalLayers = new Dictionary<GameObject, int>();
internal static MeshRenderer[] GetRenderers(GrabbableObject item)
{
int instanceID = ((Object)item).GetInstanceID();
if (RenderersByItem.TryGetValue(instanceID, out var value) && IsValid(value))
{
return value;
}
MeshRenderer[] componentsInChildren = ((Component)item).GetComponentsInChildren<MeshRenderer>(true);
List<MeshRenderer> list = new List<MeshRenderer>(componentsInChildren.Length);
foreach (MeshRenderer val in componentsInChildren)
{
if (!((Object)(object)val == (Object)null) && ((Object)val).name.IndexOf("ScanNode", StringComparison.Ordinal) < 0 && !((Component)val).gameObject.CompareTag("DoNotSet") && !((Component)val).gameObject.CompareTag("InteractTrigger") && ((Component)val).gameObject.layer != LayerMask.NameToLayer("Enemies"))
{
list.Add(val);
}
}
MeshRenderer[] array = list.ToArray();
RenderersByItem[instanceID] = array;
return array;
}
internal static void RememberLayer(GameObject gameObject)
{
if (!OriginalLayers.ContainsKey(gameObject))
{
OriginalLayers[gameObject] = gameObject.layer;
}
}
internal static bool TryGetOriginalLayer(GameObject gameObject, out int layer)
{
return OriginalLayers.TryGetValue(gameObject, out layer);
}
internal static void ForgetLayer(GameObject gameObject)
{
OriginalLayers.Remove(gameObject);
}
internal static void Clear()
{
RenderersByItem.Clear();
OriginalLayers.Clear();
}
private static bool IsValid(MeshRenderer[] renderers)
{
for (int i = 0; i < renderers.Length; i++)
{
if ((Object)(object)renderers[i] == (Object)null)
{
return false;
}
}
return true;
}
}
}
namespace __GEN
{
internal class NetworkVariableSerializationHelper
{
[RuntimeInitializeOnLoadMethod]
internal static void InitializeSerialization()
{
}
}
}
namespace ReservedSlotPositionsForInventory.NetcodePatcher
{
[AttributeUsage(AttributeTargets.Module)]
internal class NetcodePatchedAssemblyAttribute : Attribute
{
}
}
