using System;
using System.Collections;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("EasyBackpack")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+1d921d7ec8e70bbd1dca2304f47251b468981950")]
[assembly: AssemblyProduct("EasyBackpack")]
[assembly: AssemblyTitle("EasyBackpack")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
internal sealed class NullableAttribute : Attribute
{
public readonly byte[] NullableFlags;
public NullableAttribute(byte P_0)
{
NullableFlags = new byte[1] { P_0 };
}
public NullableAttribute(byte[] P_0)
{
NullableFlags = P_0;
}
}
[CompilerGenerated]
[Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
internal sealed class NullableContextAttribute : Attribute
{
public readonly byte Flag;
public NullableContextAttribute(byte P_0)
{
Flag = P_0;
}
}
[CompilerGenerated]
[Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace EasyBackpack
{
[BepInPlugin("nickklmao.easybackpack", "EasyBackpack", "1.1.6")]
internal sealed class Entry : BaseUnityPlugin
{
[HarmonyPatch(typeof(BackpackWheel), "Update")]
private static class BackpackWheelUpdatePatch
{
private static bool s_forced;
private static bool s_savedInteract;
[HarmonyPrefix]
private static void Prefix()
{
s_forced = false;
if (isAccessingBackpack && !((Object)(object)Character.localCharacter == (Object)null))
{
s_savedInteract = Character.localCharacter.input.interactIsPressed;
Character.localCharacter.input.interactIsPressed = true;
s_forced = true;
}
}
[HarmonyPostfix]
private static void Postfix()
{
if (s_forced)
{
s_forced = false;
if ((Object)(object)Character.localCharacter != (Object)null)
{
Character.localCharacter.input.interactIsPressed = s_savedInteract;
}
}
}
}
[HarmonyPatch(typeof(CharacterBackpackHandler), "AddFuelToJetpack")]
private static class SelfRefuelRollbackFix
{
private static Coroutine s_fixRoutine;
private static float s_beforeFuel = float.NaN;
private static bool s_baseSet;
private static float s_baseFuel;
private static float s_totalAdded;
[HarmonyPrefix]
private static void Prefix(CharacterBackpackHandler __instance, Character interactor, ref float addedFuel)
{
s_beforeFuel = float.NaN;
if ((Object)(object)interactor == (Object)null || (Object)(object)__instance == (Object)null || interactor.refs == null || (Object)(object)interactor.refs.backpackHandler != (Object)(object)__instance)
{
return;
}
int num = 25;
Item currentItem = interactor.data.currentItem;
if ((Object)(object)currentItem != (Object)null)
{
RopeSpool val = default(RopeSpool);
if (((Component)currentItem).TryGetComponent<RopeSpool>(ref val))
{
num = Mathf.CeilToInt(val.RopeFuel);
}
else if (currentItem.HasData((DataEntryKey)10))
{
num = currentItem.overrideJetpackFuelAmount + Mathf.RoundToInt(currentItem.GetData<FloatItemData>((DataEntryKey)10).Value * currentItem.overrideJetpackFuelPerFuelMult);
}
else if (currentItem is Backpack)
{
num = currentItem.overrideJetpackFuelAmount;
}
else if (currentItem.overrideJetpackFuel)
{
num = (currentItem.HasData((DataEntryKey)2) ? (currentItem.overrideJetpackFuelAmount + currentItem.GetData<OptionableIntItemData>((DataEntryKey)2).Value * currentItem.overrideJetpackFuelPerUse) : currentItem.overrideJetpackFuelAmount);
}
}
addedFuel = num;
Player player = interactor.player;
FloatItemData val2 = default(FloatItemData);
if (!((Object)(object)player == (Object)null) && player.backpackSlot != null && ((ItemSlot)player.backpackSlot).data != null && ((ItemSlot)player.backpackSlot).data.TryGetDataEntry<FloatItemData>((DataEntryKey)10, ref val2))
{
s_beforeFuel = val2.Value;
}
}
[HarmonyPostfix]
private static void Postfix(CharacterBackpackHandler __instance, Character interactor, float addedFuel)
{
if (float.IsNaN(s_beforeFuel) || (Object)(object)interactor == (Object)null || (Object)(object)__instance == (Object)null || interactor.refs == null || (Object)(object)interactor.refs.backpackHandler != (Object)(object)__instance)
{
return;
}
Player player = interactor.player;
FloatItemData val = default(FloatItemData);
if ((Object)(object)player == (Object)null || player.backpackSlot == null || ((ItemSlot)player.backpackSlot).data == null || !((ItemSlot)player.backpackSlot).data.TryGetDataEntry<FloatItemData>((DataEntryKey)10, ref val))
{
return;
}
float value = val.Value;
if (!(value <= s_beforeFuel + 0.01f))
{
if (s_fixRoutine == null)
{
s_baseSet = false;
s_totalAdded = 0f;
}
if (!s_baseSet)
{
s_baseSet = true;
s_baseFuel = s_beforeFuel;
}
s_totalAdded += addedFuel;
float targetFuel = Mathf.Min(s_baseFuel + s_totalAdded, 100f);
if (s_fixRoutine != null)
{
((MonoBehaviour)__instance).StopCoroutine(s_fixRoutine);
}
s_fixRoutine = ((MonoBehaviour)__instance).StartCoroutine(FixLater(__instance, ((Component)__instance).GetComponent<Character>(), targetFuel));
}
}
private static IEnumerator FixLater(CharacterBackpackHandler handler, Character targetCharacter, float targetFuel)
{
yield return (object)new WaitForSeconds(1.5f);
s_fixRoutine = null;
if ((Object)(object)handler == (Object)null || (Object)(object)targetCharacter == (Object)null)
{
yield break;
}
Player player = targetCharacter.player;
if ((Object)(object)player == (Object)null || player.backpackSlot == null || ((ItemSlot)player.backpackSlot).data == null)
{
yield break;
}
ItemInstanceData data = ((ItemSlot)player.backpackSlot).data;
FloatItemData val = default(FloatItemData);
if (data.TryGetDataEntry<FloatItemData>((DataEntryKey)10, ref val) && val.Value < targetFuel - 0.01f)
{
val.Value = targetFuel;
FloatItemData val2 = default(FloatItemData);
if (data.TryGetDataEntry<FloatItemData>((DataEntryKey)11, ref val2))
{
val2.Value = targetFuel / 100f;
}
}
}
}
private static readonly ManualLogSource logger = Logger.CreateLogSource("EasyBackpack");
private static ConfigEntry<KeyCode> backpackKey;
private static ConfigEntry<KeyCode> alternativeBackpackKey;
private static bool isAccessingBackpack;
private static bool isAccessingCarriedPlayersBackpack;
private static float s_lastSlotCountWarn = float.MinValue;
private readonly Harmony m_harmony = new Harmony("nickklmao.easybackpack");
private void Awake()
{
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Expected O, but got Unknown
//IL_0057: Unknown result type (might be due to invalid IL or missing references)
//IL_0061: Expected O, but got Unknown
logger.LogInfo((object)"Creating config entries");
backpackKey = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("Keybinds", "Backpack Key", (KeyCode)98, new ConfigDescription("The key you want to use to access the backpack while it's on your back", (AcceptableValueBase)null, Array.Empty<object>()));
alternativeBackpackKey = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("Keybinds", "Alternative Backpack Key", (KeyCode)0, new ConfigDescription("An optional alternative key for accessing the backpack while it's on your back", (AcceptableValueBase)null, Array.Empty<object>()));
logger.LogInfo((object)"Hooking BackpackWheel.Update");
m_harmony.PatchAll(typeof(BackpackWheelUpdatePatch));
m_harmony.PatchAll(typeof(SelfRefuelRollbackFix));
}
private void Update()
{
//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)
//IL_00b7: 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_00f2: Unknown result type (might be due to invalid IL or missing references)
//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
//IL_00fa: Invalid comparison between Unknown and I4
//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_01a2: Unknown result type (might be due to invalid IL or missing references)
//IL_01a5: Invalid comparison between Unknown and I4
//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_0139: 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_01d8: 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_01e4: 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)
Character localCharacter = Character.localCharacter;
if (!Application.isFocused || (Object)(object)localCharacter == (Object)null)
{
isAccessingCarriedPlayersBackpack = (isAccessingBackpack = false);
return;
}
if (isAccessingCarriedPlayersBackpack)
{
if ((Object)(object)localCharacter.data.carriedPlayer == (Object)null)
{
isAccessingCarriedPlayersBackpack = (isAccessingBackpack = false);
return;
}
}
else if (localCharacter.data.passedOut || localCharacter.data.dead || localCharacter.data.currentItem is Backpack)
{
isAccessingCarriedPlayersBackpack = (isAccessingBackpack = false);
return;
}
if (Input.GetKeyUp(backpackKey.Value) || Input.GetKeyUp(alternativeBackpackKey.Value))
{
isAccessingCarriedPlayersBackpack = (isAccessingBackpack = false);
}
else
{
if (!Input.GetKeyDown(backpackKey.Value) && !Input.GetKeyDown(alternativeBackpackKey.Value))
{
return;
}
if (!((ItemSlot)localCharacter.player.backpackSlot).IsEmpty())
{
BackpackType backpackType = localCharacter.player.backpackSlot.backpackType;
if ((int)backpackType == 4)
{
return;
}
int num = 4;
try
{
CharacterBackpackHandler backpackHandler = localCharacter.refs.backpackHandler;
BackpackOnBackVisuals val = ((backpackHandler != null) ? backpackHandler.activeBackpackVisuals : null);
if ((Object)(object)val != (Object)null)
{
num = val.slotCount;
}
BackpackReference fromEquippedBackpack = BackpackReference.GetFromEquippedBackpack(localCharacter);
GUIManager.instance.OpenBackpackWheel(fromEquippedBackpack, num, backpackType);
isAccessingBackpack = true;
return;
}
catch
{
LogSlotCountFallback();
return;
}
}
Character carriedPlayer = localCharacter.data.carriedPlayer;
if ((Object)(object)carriedPlayer == (Object)null)
{
return;
}
Player player = carriedPlayer.player;
if (!((Object)(object)player != (Object)null))
{
return;
}
BackpackSlot backpackSlot = player.backpackSlot;
if (backpackSlot == null || ((ItemSlot)backpackSlot).IsEmpty())
{
return;
}
BackpackType backpackType2 = player.backpackSlot.backpackType;
if ((int)backpackType2 == 4)
{
return;
}
int num2 = 4;
try
{
CharacterBackpackHandler backpackHandler2 = carriedPlayer.refs.backpackHandler;
BackpackOnBackVisuals val2 = ((backpackHandler2 != null) ? backpackHandler2.activeBackpackVisuals : null);
if ((Object)(object)val2 != (Object)null)
{
num2 = val2.slotCount;
}
BackpackReference fromEquippedBackpack2 = BackpackReference.GetFromEquippedBackpack(carriedPlayer);
GUIManager.instance.OpenBackpackWheel(fromEquippedBackpack2, num2, backpackType2);
isAccessingCarriedPlayersBackpack = (isAccessingBackpack = true);
}
catch
{
LogSlotCountFallback();
}
}
}
private static void LogSlotCountFallback()
{
if (Time.unscaledTime - s_lastSlotCountWarn > 5f)
{
s_lastSlotCountWarn = Time.unscaledTime;
logger.LogWarning((object)"Failed to read backpack visuals slotCount / GetFromEquippedBackpack (refs or ragdoll not ready); backpack wheel was not opened.");
}
}
}
}
