using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using JetpackPocket.Patches;
using LethalConfig;
using LethalConfig.ConfigItems;
using LethalConfig.ConfigItems.Options;
using Unity.Netcode;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("JetpackPocket")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("JetpackPocket")]
[assembly: AssemblyCopyright("Copyright © 2026")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("16975d87-0cf9-4922-88fd-a28d56a3ae51")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace JetpackPocket
{
internal static class JetpackHelper
{
public struct JetpackState
{
public bool HasJetpack;
public int HasTwoHandedItem;
}
private static readonly Dictionary<ulong, JetpackState> PlayerDictionary = new Dictionary<ulong, JetpackState>();
public static bool HasJetpack(PlayerControllerB player)
{
if ((Object)(object)player == (Object)null)
{
return false;
}
if (PlayerDictionary.TryGetValue(player.playerClientId, out var value))
{
return value.HasJetpack;
}
return false;
}
public static bool HasTwoHandedAndJetpack(PlayerControllerB player)
{
if (PlayerDictionary.TryGetValue(player.playerClientId, out var value) && value.HasJetpack)
{
return value.HasTwoHandedItem > 0;
}
return false;
}
public static bool HasTwoHanded(PlayerControllerB player)
{
if (PlayerDictionary.TryGetValue(player.playerClientId, out var value))
{
return value.HasTwoHandedItem > 0;
}
return false;
}
private static void SaveState(ulong player, JetpackState value)
{
PlayerDictionary[player] = value;
}
public static void Rescan(PlayerControllerB player)
{
if ((Object)(object)player == (Object)null)
{
return;
}
JetpackState value = default(JetpackState);
GrabbableObject[] itemSlots = player.ItemSlots;
foreach (GrabbableObject item in itemSlots)
{
if (IsJetpack(item))
{
value.HasJetpack = true;
}
if (IsTwoHanded(item))
{
value.HasTwoHandedItem++;
}
}
if (IsJetpack(player.ItemOnlySlot))
{
value.HasJetpack = true;
}
SaveState(player.playerClientId, value);
}
private static bool IsJetpack(GrabbableObject item)
{
if ((Object)(object)item == (Object)null)
{
return false;
}
return ((object)item).GetType().Name == "JetpackItem";
}
private static bool IsTwoHanded(GrabbableObject item)
{
if ((Object)(object)item == (Object)null)
{
return false;
}
return item.itemProperties.twoHanded;
}
public static void UpdateHUD(PlayerControllerB __instance)
{
if ((Object)(object)__instance != (Object)null)
{
bool flag = HasTwoHanded(__instance);
bool flag2 = HasJetpack(__instance);
((Behaviour)HUDManager.Instance.holdingTwoHandedItem).enabled = (flag && !flag2) || (flag && flag2 && !JetpackPocketPatchBase.instance.JetpackPocketConfigEntry.Value);
}
}
public static void UpdateHUD()
{
PlayerControllerB localPlayerController = GameNetworkManager.Instance.localPlayerController;
if ((Object)(object)localPlayerController != (Object)null)
{
UpdateHUD(localPlayerController);
}
}
}
[BepInPlugin("PixelIndieDev_JetpackPocket", "Jetpack Pocket", "1.2.0.0")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public class JetpackPocketPatchBase : BaseUnityPlugin
{
private readonly Harmony harmony = new Harmony("PixelIndieDev_JetpackPocket");
public static JetpackPocketPatchBase instance;
public ConfigEntry<bool> JetpackPocketConfigEntry;
internal static ManualLogSource logSource;
private void Awake()
{
//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_0084: Expected O, but got Unknown
//IL_007f: Unknown result type (might be due to invalid IL or missing references)
//IL_0089: Expected O, but got Unknown
if ((Object)(object)instance == (Object)null)
{
instance = this;
}
logSource = Logger.CreateLogSource("PixelIndieDev_JetpackPocket");
JetpackPocketConfigEntry = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Carry multiple two-handed items", false, "Enables carrying multiple two-handed items at the same time while having a jetpack.");
JetpackPocketConfigEntry.SettingChanged += delegate
{
JetpackHelper.UpdateHUD();
};
LethalConfigManager.AddConfigItem((BaseConfigItem)new BoolCheckBoxConfigItem(JetpackPocketConfigEntry, new BoolCheckBoxOptions
{
RequiresRestart = false
}));
harmony.PatchAll(typeof(JetpackPocketPatchBase));
harmony.PatchAll(typeof(PlayerControllerBPatch));
harmony.PatchAll(typeof(NetworkPatch));
logSource.LogInfo((object)"Jetpack Pocket (version - 1.2.0.0): patches applied successfully");
}
}
internal static class ModInfo
{
internal const string modGUID = "PixelIndieDev_JetpackPocket";
internal const string modName = "Jetpack Pocket";
internal const string modVersion = "1.2.0.0";
}
}
namespace JetpackPocket.Patches
{
[HarmonyPatch(typeof(NetworkManager))]
internal static class NetworkPatch
{
[HarmonyPostfix]
[HarmonyPatch("SetSingleton")]
private static void RegisterPrefab()
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_000b: Expected O, but got Unknown
//IL_000d: 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)
GameObject val = new GameObject("PixelIndieDev_JetpackPocket Prefab");
((Object)val).hideFlags = (HideFlags)(((Object)val).hideFlags | 0x3D);
Object.DontDestroyOnLoad((Object)(object)val);
NetworkObject obj = val.AddComponent<NetworkObject>();
typeof(NetworkObject).GetField("GlobalObjectIdHash", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(obj, GetHash("PixelIndieDev_JetpackPocket"));
NetworkManager.Singleton.PrefabHandler.AddNetworkPrefab(val);
}
private static uint GetHash(string value)
{
return value?.Aggregate(17u, (uint current, char c) => (current * 31) ^ c) ?? 0;
}
}
[HarmonyPatch(typeof(PlayerControllerB))]
internal class PlayerControllerBPatch
{
[HarmonyPatch("GrabObjectClientRpc")]
[HarmonyPostfix]
[HarmonyPriority(0)]
private static void GrabObjectClientRpcPatch(PlayerControllerB __instance)
{
JetpackHelper.Rescan(__instance);
JetpackHelper.UpdateHUD(__instance);
}
[HarmonyPatch("ThrowObjectClientRpc")]
[HarmonyPostfix]
[HarmonyPriority(0)]
private static void ThrowObjectClientRpcPatch(PlayerControllerB __instance)
{
JetpackHelper.Rescan(__instance);
JetpackHelper.UpdateHUD(__instance);
}
[HarmonyPatch("PlaceObjectClientRpc")]
[HarmonyPostfix]
[HarmonyPriority(0)]
private static void PlaceObjectClientRpcPatch(PlayerControllerB __instance)
{
JetpackHelper.Rescan(__instance);
JetpackHelper.UpdateHUD(__instance);
}
[HarmonyPatch("DropAllHeldItems")]
[HarmonyPostfix]
[HarmonyPriority(0)]
private static void DropAllHeldItemsPatch(PlayerControllerB __instance)
{
JetpackHelper.Rescan(__instance);
JetpackHelper.UpdateHUD(__instance);
}
[HarmonyPatch("DespawnHeldObjectClientRpc")]
[HarmonyPostfix]
[HarmonyPriority(0)]
private static void DespawnHeldObjectClientRpcPatch(PlayerControllerB __instance)
{
JetpackHelper.Rescan(__instance);
JetpackHelper.UpdateHUD(__instance);
}
[HarmonyPatch("ScrollMouse_performed")]
[HarmonyPrefix]
[HarmonyPriority(0)]
private static void ScrollPatch(PlayerControllerB __instance)
{
if (((NetworkBehaviour)__instance).IsOwner && __instance.isPlayerControlled && !__instance.inTerminalMenu)
{
if (__instance.twoHanded && JetpackHelper.HasJetpack(__instance))
{
__instance.twoHanded = false;
}
JetpackHelper.UpdateHUD(__instance);
}
}
[HarmonyPatch("UseUtilitySlot_performed")]
[HarmonyPrefix]
[HarmonyPriority(0)]
private static void tabPatch(PlayerControllerB __instance)
{
if (((NetworkBehaviour)__instance).IsOwner && __instance.isPlayerControlled && !__instance.inTerminalMenu)
{
if (__instance.twoHanded && JetpackHelper.HasJetpack(__instance))
{
__instance.twoHanded = false;
}
JetpackHelper.UpdateHUD(__instance);
}
}
[HarmonyPatch("BeginGrabObject")]
[HarmonyPrefix]
[HarmonyPriority(0)]
private static bool BeginGrabObjectPatch(PlayerControllerB __instance)
{
//IL_003a: 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_00af: 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_00cb: 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_00da: Unknown result type (might be due to invalid IL or missing references)
if (JetpackPocketPatchBase.instance.JetpackPocketConfigEntry.Value)
{
return true;
}
if (__instance.twoHanded)
{
return true;
}
if (!((NetworkBehaviour)__instance).IsOwner || !__instance.isPlayerControlled)
{
return true;
}
RaycastHit val = default(RaycastHit);
if (!Physics.Raycast(new Ray(((Component)__instance.gameplayCamera).transform.position, ((Component)__instance.gameplayCamera).transform.forward), ref val, __instance.grabDistance, 1073742656) || ((Component)((RaycastHit)(ref val)).collider).gameObject.layer == 8 || ((Component)((RaycastHit)(ref val)).collider).tag != "PhysicsProp" || __instance.sinkingValue > 0.73f || Physics.Linecast(((Component)__instance.gameplayCamera).transform.position, ((Component)((RaycastHit)(ref val)).collider).transform.position + ((Component)__instance).transform.up * 0.16f, 1073741824, (QueryTriggerInteraction)1))
{
return true;
}
if (JetpackHelper.HasTwoHanded(__instance))
{
GrabbableObject component = ((Component)((Component)((RaycastHit)(ref val)).collider).transform).gameObject.GetComponent<GrabbableObject>();
if ((Object)(object)component != (Object)null && component.itemProperties.twoHanded)
{
JetpackHelper.UpdateHUD(__instance);
return false;
}
}
return true;
}
[HarmonyPatch("SwitchToItemSlot")]
[HarmonyPostfix]
[HarmonyPriority(0)]
private static void SwitchToItem(PlayerControllerB __instance)
{
JetpackHelper.Rescan(__instance);
JetpackHelper.UpdateHUD(__instance);
}
}
}
