using System;
using System.Collections;
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.Logging;
using BetterInventory.Patches;
using GameNetcodeStuff;
using HarmonyLib;
using LethalCompanyInputUtils.Api;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.UI;
[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("BetterInventory2")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("Better Inventory 2")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("BetterInventory2")]
[assembly: AssemblyTitle("BetterInventory2")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
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 BetterInventory2
{
public static class PluginInfo
{
public const string PLUGIN_GUID = "BetterInventory2";
public const string PLUGIN_NAME = "BetterInventory2";
public const string PLUGIN_VERSION = "1.0.0";
}
}
namespace BetterInventory
{
[BepInPlugin("Croquette.BetterInventory", "Better Inventory", "1.0.0")]
public class BetterInventory : BaseUnityPlugin
{
private const string modGUID = "Croquette.BetterInventory";
private const string modName = "Better Inventory";
private const string modVersion = "1.0.0";
private readonly Harmony harmony = new Harmony("Croquette.BetterInventory");
private static BetterInventory Instance;
internal static ManualLogSource logger;
private void Awake()
{
if ((Object)(object)Instance == (Object)null)
{
Instance = this;
}
logger = Logger.CreateLogSource("Croquette.BetterInventory");
harmony.PatchAll(typeof(BetterInventory));
harmony.PatchAll(typeof(PlayerControllerBPatch));
harmony.PatchAll(typeof(EasyInventoryInputClass));
harmony.PatchAll(typeof(GlobalFlashlightInputClass));
harmony.PatchAll(typeof(SwapModeInputClass));
}
private static ManualLogSource GetLogger()
{
return logger;
}
}
}
namespace BetterInventory.Patches
{
internal class EasyInventoryInputClass : LcInputActions
{
public static EasyInventoryInputClass Instance = new EasyInventoryInputClass();
[InputAction("<Keyboard>/1", Name = "Inventory 1")]
public InputAction Inventory1Key { get; set; }
[InputAction("<Keyboard>/2", Name = "Inventory 2")]
public InputAction Inventory2Key { get; set; }
[InputAction("<Keyboard>/3", Name = "Inventory 3")]
public InputAction Inventory3Key { get; set; }
[InputAction("<Keyboard>/4", Name = "Inventory 4")]
public InputAction Inventory4Key { get; set; }
public override void CreateInputActions(in InputActionMapBuilder builder)
{
BetterInventory.logger.LogInfo((object)"Creating Input Actions");
}
}
internal class GlobalFlashlightInputClass : LcInputActions
{
public static GlobalFlashlightInputClass Instance = new GlobalFlashlightInputClass();
[InputAction("<Keyboard>/T", Name = "Global Flashlight")]
public InputAction GlobalFlashlightKey { get; set; }
}
internal class SwapModeInputClass : LcInputActions
{
public static SwapModeInputClass Instance = new SwapModeInputClass();
[InputAction("<Keyboard>/X", Name = "Inventory Swap")]
public InputAction SwapModeKey { get; set; }
}
[HarmonyPatch(typeof(PlayerControllerB))]
internal class PlayerControllerBPatch
{
private static EasyInventoryInputClass easyInventoryInputSystem = EasyInventoryInputClass.Instance;
private static GlobalFlashlightInputClass globalFlashlightInputSystem = GlobalFlashlightInputClass.Instance;
private static PlayerControllerB _localPlayer;
private static MethodInfo _switchToItemMethod;
private static MethodInfo _nextItemSlot;
private static MethodInfo _switchItemSlotsServerRpc;
private static bool _shouldDeactivateSwapMode = false;
private static bool swapModeActive = false;
private static int initialSwapIndex = -1;
private static Color _inventoryFrameColor = Color.black;
private static bool skipNextCall = false;
[HarmonyPatch("Start")]
[HarmonyPostfix]
private static void Start()
{
_switchToItemMethod = typeof(PlayerControllerB).GetMethod("SwitchToItemSlot", BindingFlags.Instance | BindingFlags.NonPublic);
_nextItemSlot = typeof(PlayerControllerB).GetMethod("NextItemSlot", BindingFlags.Instance | BindingFlags.NonPublic);
_switchItemSlotsServerRpc = typeof(PlayerControllerB).GetMethod("SwitchItemSlotsServerRpc", BindingFlags.Instance | BindingFlags.NonPublic);
}
[HarmonyPatch("Update")]
[HarmonyPostfix]
private static void UpdatePatch()
{
if (Object.op_Implicit((Object)(object)(_localPlayer = GameNetworkManager.Instance.localPlayerController)))
{
EasyInventoryPatch();
GlobalFlashlight();
ToggleSwapMode();
}
}
private static void EasyInventoryPatch()
{
if (_localPlayer.twoHanded || _localPlayer.inTerminalMenu)
{
return;
}
int num = -1;
if (easyInventoryInputSystem == null)
{
return;
}
if (easyInventoryInputSystem.Inventory1Key.triggered)
{
num = 0;
}
else if (easyInventoryInputSystem.Inventory2Key.triggered)
{
num = 1;
}
else if (easyInventoryInputSystem.Inventory3Key.triggered)
{
num = 2;
}
else if (easyInventoryInputSystem.Inventory4Key.triggered)
{
num = 3;
}
if (num == -1)
{
return;
}
int num2 = _localPlayer.currentItemSlot - num;
if (num2 > 0)
{
object[] parameters = new object[1] { true };
_switchToItemMethod.Invoke(_localPlayer, new object[2] { num, null });
for (int i = 0; i < num2; i++)
{
_switchItemSlotsServerRpc.Invoke(_localPlayer, parameters);
}
}
else if (num2 < 0)
{
object[] parameters2 = new object[1] { false };
_switchToItemMethod.Invoke(_localPlayer, new object[2] { num, null });
for (int num3 = 0; num3 > num2; num3--)
{
_switchItemSlotsServerRpc.Invoke(_localPlayer, parameters2);
}
}
_shouldDeactivateSwapMode = true;
}
private static void GlobalFlashlight()
{
if (_localPlayer.inTerminalMenu || !globalFlashlightInputSystem.GlobalFlashlightKey.triggered)
{
return;
}
for (int i = 0; i < _localPlayer.ItemSlots.Length; i++)
{
if (!(_localPlayer.ItemSlots[i] is FlashlightItem))
{
continue;
}
GrabbableObject obj = _localPlayer.ItemSlots[i];
FlashlightItem val = (FlashlightItem)(object)((obj is FlashlightItem) ? obj : null);
if (((GrabbableObject)val).insertedBattery.charge > 0f)
{
((GrabbableObject)val).UseItemOnClient(true);
if (_localPlayer.currentItemSlot != i)
{
((GrabbableObject)val).PocketItem();
}
break;
}
}
}
private static void ToggleSwapMode()
{
if (SwapModeInputClass.Instance.SwapModeKey.triggered)
{
if (!swapModeActive)
{
ActivateSwapMode();
}
else
{
DeactivateSwapMode();
}
}
if (swapModeActive && (_shouldDeactivateSwapMode || _localPlayer.twoHanded || _localPlayer.inTerminalMenu))
{
DeactivateSwapMode();
}
}
[HarmonyPatch("SwitchToItemSlot")]
[HarmonyPrefix]
private static void ManageSwapMode(int slot, ref GrabbableObject fillSlotWithItem)
{
if (!swapModeActive || _localPlayer.twoHanded)
{
return;
}
if (skipNextCall)
{
skipNextCall = false;
return;
}
if ((Object)(object)fillSlotWithItem != (Object)null)
{
_shouldDeactivateSwapMode = true;
return;
}
GrabbableObject newObject = _localPlayer.ItemSlots[initialSwapIndex];
GrabbableObject newObject2 = _localPlayer.ItemSlots[slot];
skipNextCall = true;
ChangeItemInSlot(initialSwapIndex, newObject2);
skipNextCall = true;
ChangeItemInSlot(slot, newObject);
if (!_shouldDeactivateSwapMode)
{
HighlightInventoryForSwapMode();
initialSwapIndex = slot;
}
}
[HarmonyPatch("SwitchToItemSlot")]
[HarmonyPostfix]
private static void PostSlotSwitch()
{
if (swapModeActive)
{
HUDManager.Instance.PingHUDElement(HUDManager.Instance.Inventory, 0.1f, 1f, 1f);
}
else
{
HUDManager.Instance.PingHUDElement(HUDManager.Instance.Inventory, 1.5f, 1f, 0.13f);
}
}
private static void HighlightInventoryForSwapMode()
{
//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_002a: 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_004e: 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_0053: 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 (_inventoryFrameColor == Color.black)
{
_inventoryFrameColor = ((Graphic)HUDManager.Instance.itemSlotIconFrames[_localPlayer.currentItemSlot]).color;
}
for (int i = 0; i < _localPlayer.ItemSlots.Length; i++)
{
Color color = ((i == _localPlayer.currentItemSlot) ? Color.green : Color.gray);
((Graphic)HUDManager.Instance.itemSlotIconFrames[i]).color = color;
}
}
private static void ActivateSwapMode()
{
swapModeActive = true;
_shouldDeactivateSwapMode = false;
initialSwapIndex = _localPlayer.currentItemSlot;
HighlightInventoryForSwapMode();
PostSlotSwitch();
}
private static void DeactivateSwapMode()
{
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
for (int i = 0; i < _localPlayer.ItemSlots.Length; i++)
{
((Graphic)HUDManager.Instance.itemSlotIconFrames[i]).color = _inventoryFrameColor;
}
swapModeActive = false;
PostSlotSwitch();
}
private static void ChangeItemInSlot(int slotIndex, GrabbableObject newObject)
{
_switchToItemMethod.Invoke(_localPlayer, new object[2] { slotIndex, newObject });
if ((Object)(object)newObject == (Object)null)
{
_localPlayer.ItemSlots[slotIndex] = null;
((Behaviour)HUDManager.Instance.itemSlotIcons[slotIndex]).enabled = false;
}
}
}
internal class ItemPulsing : MonoBehaviour
{
public Vector3 minScale = new Vector3(0.75f, 0.75f, 0.75f);
public Vector3 maxScale = new Vector3(1.25f, 1.25f, 1.25f);
public float scalingSpeed = 0.7f;
public float scalingDuration = 0.5f;
private IEnumerator Start()
{
yield return RepeatLerping(((Component)this).transform.localScale, minScale, scalingDuration);
while (true)
{
yield return RepeatLerping(minScale, maxScale, scalingDuration);
yield return RepeatLerping(maxScale, minScale, scalingDuration);
}
}
private IEnumerator RepeatLerping(Vector3 startScale, Vector3 endScale, float time, bool destroyWhenDone = false)
{
//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)
//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)
float currentTime = 0f;
float rate = 1f / time * scalingSpeed;
while (currentTime < 1f)
{
currentTime += Time.deltaTime * rate;
((Component)this).transform.localScale = Vector3.Lerp(startScale, endScale, currentTime);
yield return null;
}
if (destroyWhenDone)
{
Object.Destroy((Object)(object)this);
}
}
public void StopAnimationAndDestroy()
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
((Component)this).transform.localScale = Vector3.one;
((MonoBehaviour)this).StopAllCoroutines();
Object.Destroy((Object)(object)this);
}
}
}
