using System;
using System.Diagnostics;
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 Unity.Netcode;
using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("InstantItemSlots")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("InstantItemSlots")]
[assembly: AssemblyCopyright("Copyright © 2026")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("4cc5e582-3cd6-41fb-87fe-c92a18523560")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace InstantItemSlots;
[BepInPlugin("kviks.instantitemslots", "Instant Item Slots", "15.04.2026")]
public class InstantItemSlotsPlugin : BaseUnityPlugin
{
internal static ManualLogSource Log;
internal static bool DebugEnabled;
internal static bool ArrowEmotesOnly;
internal static int ControlledSlots;
internal static float CooldownSeconds;
internal static float SpawnDelaySeconds;
internal static bool IgnoreBusyDuringSpawnDelay;
internal static bool IgnoreBusyChecksAlways;
internal static bool PlayGrabSfx;
internal static bool SyncStepsFallback;
private static Harmony _harmony;
private static ConfigEntry<bool> _debug;
private static ConfigEntry<bool> _arrowEmotesOnly;
private static ConfigEntry<int> _controlledSlots;
private static ConfigEntry<float> _cooldownSeconds;
private static ConfigEntry<float> _spawnDelaySeconds;
private static ConfigEntry<bool> _ignoreBusyDuringSpawnDelay;
private static ConfigEntry<bool> _ignoreBusyChecksAlways;
private static ConfigEntry<bool> _playGrabSfx;
private static ConfigEntry<bool> _syncStepsFallback;
private void Awake()
{
//IL_014d: Unknown result type (might be due to invalid IL or missing references)
//IL_0157: Expected O, but got Unknown
Log = ((BaseUnityPlugin)this).Logger;
_debug = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "EnableDebugLogging", false, "Enables debug logging.");
_arrowEmotesOnly = ((BaseUnityPlugin)this).Config.Bind<bool>("Emotes", "UseArrowEmotesOnly", true, "UpArrow = emote 1, DownArrow = emote 2. Vanilla emote input is blocked while enabled.");
_controlledSlots = ((BaseUnityPlugin)this).Config.Bind<int>("Hotbar", "DigitControlledSlots", 4, "How many slots are controlled by 1/2/3/4 (1..4).");
_cooldownSeconds = ((BaseUnityPlugin)this).Config.Bind<float>("Hotbar", "DigitSwitchCooldownSeconds", 0f, "Minimum time since last switch allowed.");
_spawnDelaySeconds = ((BaseUnityPlugin)this).Config.Bind<float>("Spawn", "RelaxedRulesWindowSeconds", 0f, "Seconds after level load where switching rules can be relaxed.");
_ignoreBusyDuringSpawnDelay = ((BaseUnityPlugin)this).Config.Bind<bool>("Spawn", "IgnoreBusyChecksInsideRelaxedWindow", true, "Ignore animation/interact/activatingItem/twoHanded during the relaxed window.");
_ignoreBusyChecksAlways = ((BaseUnityPlugin)this).Config.Bind<bool>("Spawn", "IgnoreBusyChecksAlways", false, "Always ignore animation/interact/activatingItem/twoHanded checks.");
_playGrabSfx = ((BaseUnityPlugin)this).Config.Bind<bool>("Audio", "PlayGrabSoundOnDigitSwitch", true, "Play grab sound when switching with digits.");
_syncStepsFallback = ((BaseUnityPlugin)this).Config.Bind<bool>("Network", "UseLegacyStepRpcFallback", true, "Fallback sync for old versions without direct slot RPC.");
ApplyConfig();
HookConfigChanges();
GameAccess.Init();
_harmony = new Harmony("kviks.instantitemslots");
_harmony.PatchAll();
if (DebugEnabled)
{
Log.LogInfo((object)"[IIS] Loaded.");
}
}
private void ApplyConfig()
{
DebugEnabled = _debug.Value;
ArrowEmotesOnly = _arrowEmotesOnly.Value;
ControlledSlots = Mathf.Clamp(_controlledSlots.Value, 1, 4);
CooldownSeconds = Mathf.Max(0f, _cooldownSeconds.Value);
SpawnDelaySeconds = Mathf.Max(0f, _spawnDelaySeconds.Value);
IgnoreBusyDuringSpawnDelay = _ignoreBusyDuringSpawnDelay.Value;
IgnoreBusyChecksAlways = _ignoreBusyChecksAlways.Value;
PlayGrabSfx = _playGrabSfx.Value;
SyncStepsFallback = _syncStepsFallback.Value;
}
private void HookConfigChanges()
{
_debug.SettingChanged += delegate
{
ApplyConfig();
};
_arrowEmotesOnly.SettingChanged += delegate
{
ApplyConfig();
};
_controlledSlots.SettingChanged += delegate
{
ApplyConfig();
};
_cooldownSeconds.SettingChanged += delegate
{
ApplyConfig();
};
_spawnDelaySeconds.SettingChanged += delegate
{
ApplyConfig();
};
_ignoreBusyDuringSpawnDelay.SettingChanged += delegate
{
ApplyConfig();
};
_ignoreBusyChecksAlways.SettingChanged += delegate
{
ApplyConfig();
};
_playGrabSfx.SettingChanged += delegate
{
ApplyConfig();
};
_syncStepsFallback.SettingChanged += delegate
{
ApplyConfig();
};
}
internal static void HandleLocalUpdate(PlayerControllerB player)
{
if ((Object)(object)player == (Object)null || !((NetworkBehaviour)player).IsOwner || (!player.isPlayerControlled && !player.isTestingPlayer))
{
return;
}
Keyboard current = Keyboard.current;
if (current == null)
{
return;
}
if (ArrowEmotesOnly)
{
if (current.upArrowKey != null && ((ButtonControl)current.upArrowKey).wasPressedThisFrame)
{
TryPerformArrowEmote(player, 1);
return;
}
if (current.downArrowKey != null && ((ButtonControl)current.downArrowKey).wasPressedThisFrame)
{
TryPerformArrowEmote(player, 2);
return;
}
}
int num = -1;
if (current.digit1Key != null && ((ButtonControl)current.digit1Key).wasPressedThisFrame)
{
num = 0;
}
else if (current.digit2Key != null && ((ButtonControl)current.digit2Key).wasPressedThisFrame)
{
num = 1;
}
else if (current.digit3Key != null && ((ButtonControl)current.digit3Key).wasPressedThisFrame)
{
num = 2;
}
else if (current.digit4Key != null && ((ButtonControl)current.digit4Key).wasPressedThisFrame)
{
num = 3;
}
if (num >= 0)
{
if (DebugEnabled)
{
Log.LogInfo((object)("[IIS] Key pressed -> slot " + (num + 1)));
}
TrySwitchToSlot(player, num);
}
}
private static void TryPerformArrowEmote(PlayerControllerB player, int emoteId)
{
try
{
if (!GameAccess.EmoteReady)
{
if (DebugEnabled)
{
Log.LogWarning((object)"[IIS] Emote reflection not ready.");
}
}
else if (((((NetworkBehaviour)player).IsOwner && player.isPlayerControlled && (!((NetworkBehaviour)player).IsServer || player.isHostPlayerObject)) || player.isTestingPlayer) && GameAccess.CheckConditionsForEmote(player) && !(GameAccess.GetTimeSinceStartingEmote(player) < 0.5f))
{
GameAccess.SetTimeSinceStartingEmote(player, 0f);
GameAccess.SetPerformingEmote(player, value: true);
if ((Object)(object)player.playerBodyAnimator != (Object)null)
{
player.playerBodyAnimator.SetInteger("emoteNumber", emoteId);
}
GameAccess.StartPerformingEmoteServerRpc(player);
}
}
catch (Exception ex)
{
Log.LogError((object)("[IIS] Emote error: " + ex));
}
}
private static void TrySwitchToSlot(PlayerControllerB player, int targetSlot)
{
try
{
if (!GameAccess.Ready)
{
if (DebugEnabled)
{
Log.LogWarning((object)"[IIS] Not ready: reflection cache missing.");
}
return;
}
if (player.inTerminalMenu || player.isTypingChat || player.inSpecialMenu)
{
if (DebugEnabled)
{
Log.LogInfo((object)"[IIS] Blocked: menu/terminal/chat.");
}
return;
}
bool flag = SpawnDelaySeconds > 0f && Time.timeSinceLevelLoad < SpawnDelaySeconds;
if (!IgnoreBusyChecksAlways && (!flag || !IgnoreBusyDuringSpawnDelay) && (player.isGrabbingObjectAnimation || player.inSpecialInteractAnimation || player.activatingItem || player.twoHanded))
{
if (DebugEnabled)
{
Log.LogInfo((object)"[IIS] Blocked: animation/interact/activatingItem/twoHanded.");
}
return;
}
if ((player.jetpackControls || player.disablingJetpackControls) && (Object)(object)player.currentlyHeldObjectServer != (Object)null && (Object)(object)player.currentlyHeldObjectServer.itemProperties != (Object)null && player.currentlyHeldObjectServer.itemProperties.itemId == 13)
{
if (DebugEnabled)
{
Log.LogInfo((object)"[IIS] Blocked: jetpackControls.");
}
return;
}
if ((Object)(object)player.quickMenuManager != (Object)null && player.quickMenuManager.isMenuOpen)
{
if (DebugEnabled)
{
Log.LogInfo((object)"[IIS] Blocked: quick menu.");
}
return;
}
if (GameAccess.GetThrowingObject(player))
{
if (DebugEnabled)
{
Log.LogInfo((object)"[IIS] Blocked: throwingObject.");
}
return;
}
float timeSinceSwitchingSlots = GameAccess.GetTimeSinceSwitchingSlots(player);
if (timeSinceSwitchingSlots >= 0f && timeSinceSwitchingSlots < CooldownSeconds)
{
if (DebugEnabled)
{
Log.LogInfo((object)("[IIS] Blocked: cooldown timeSinceSwitchingSlots=" + timeSinceSwitchingSlots));
}
return;
}
GrabbableObject[] itemSlots = player.ItemSlots;
if (itemSlots == null || itemSlots.Length == 0)
{
return;
}
int num = Mathf.Min(itemSlots.Length, ControlledSlots);
if (num <= 0)
{
return;
}
targetSlot = Mathf.Clamp(targetSlot, 0, num - 1);
if (player.currentItemSlot != targetSlot)
{
ShipBuildModeManager instance = ShipBuildModeManager.Instance;
if ((Object)(object)instance != (Object)null && instance.InBuildMode)
{
instance.CancelBuildMode(true);
}
if ((Object)(object)player.playerBodyAnimator != (Object)null)
{
player.playerBodyAnimator.SetBool("GrabValidated", false);
}
if (GameAccess.HasDirectSlotRpc)
{
GameAccess.SwitchToItemSlot(player, targetSlot);
GameAccess.SwitchToSlotServerRpc(player, targetSlot);
}
else
{
DoLegacyStepSwitch(player, targetSlot, num);
}
PlayGrabSound(player);
GameAccess.SetTimeSinceSwitchingSlots(player, 0f);
}
}
catch (Exception ex)
{
Log.LogError((object)("[IIS] Switch error: " + ex));
}
}
private static void DoLegacyStepSwitch(PlayerControllerB player, int targetSlot, int len)
{
if (!SyncStepsFallback)
{
GameAccess.SwitchToItemSlot(player, targetSlot);
return;
}
int currentItemSlot = player.currentItemSlot;
int num = (targetSlot - currentItemSlot + len) % len;
int num2 = (currentItemSlot - targetSlot + len) % len;
bool flag = num < num2;
int num3 = (flag ? num : num2);
if (num3 <= 0 && currentItemSlot != targetSlot)
{
flag = true;
num3 = num;
}
for (int i = 0; i < num3; i++)
{
int slot = (flag ? ((player.currentItemSlot + 1) % len) : ((player.currentItemSlot == 0) ? (len - 1) : (player.currentItemSlot - 1)));
GameAccess.SwitchToItemSlot(player, slot);
GameAccess.SwitchItemSlotsServerRpc(player, flag);
}
}
private static void PlayGrabSound(PlayerControllerB player)
{
if (!PlayGrabSfx || (Object)(object)player.currentlyHeldObjectServer == (Object)null)
{
return;
}
Item itemProperties = player.currentlyHeldObjectServer.itemProperties;
if (!((Object)(object)itemProperties == (Object)null) && !((Object)(object)itemProperties.grabSFX == (Object)null))
{
AudioSource component = ((Component)player.currentlyHeldObjectServer).gameObject.GetComponent<AudioSource>();
if ((Object)(object)component != (Object)null)
{
component.PlayOneShot(itemProperties.grabSFX, 0.6f);
}
}
}
}
internal static class GameAccess
{
internal static bool Ready;
internal static bool EmoteReady;
private static MethodInfo _switchToItemSlot;
private static MethodInfo _switchToSlotServerRpc;
private static MethodInfo _switchItemSlotsServerRpc;
private static MethodInfo _checkConditionsForEmote;
private static MethodInfo _startPerformingEmoteServerRpc;
private static FieldInfo _throwingObject;
private static FieldInfo _timeSinceSwitchingSlots;
private static FieldInfo _timeSinceStartingEmote;
private static FieldInfo _performingEmote;
internal static bool HasDirectSlotRpc => _switchToSlotServerRpc != null;
internal static void Init()
{
try
{
Type typeFromHandle = typeof(PlayerControllerB);
_switchToItemSlot = AccessTools.Method(typeFromHandle, "SwitchToItemSlot", new Type[2]
{
typeof(int),
typeof(GrabbableObject)
}, (Type[])null);
_switchToSlotServerRpc = AccessTools.Method(typeFromHandle, "SwitchToSlotServerRpc", new Type[1] { typeof(int) }, (Type[])null);
_switchItemSlotsServerRpc = AccessTools.Method(typeFromHandle, "SwitchItemSlotsServerRpc", new Type[1] { typeof(bool) }, (Type[])null);
_throwingObject = AccessTools.Field(typeFromHandle, "throwingObject");
_timeSinceSwitchingSlots = AccessTools.Field(typeFromHandle, "timeSinceSwitchingSlots");
_checkConditionsForEmote = AccessTools.Method(typeFromHandle, "CheckConditionsForEmote", (Type[])null, (Type[])null);
_startPerformingEmoteServerRpc = AccessTools.Method(typeFromHandle, "StartPerformingEmoteServerRpc", (Type[])null, (Type[])null);
_timeSinceStartingEmote = AccessTools.Field(typeFromHandle, "timeSinceStartingEmote");
_performingEmote = AccessTools.Field(typeFromHandle, "performingEmote");
Ready = _switchToItemSlot != null && _throwingObject != null && _timeSinceSwitchingSlots != null && (_switchToSlotServerRpc != null || _switchItemSlotsServerRpc != null);
EmoteReady = _checkConditionsForEmote != null && _startPerformingEmoteServerRpc != null && _timeSinceStartingEmote != null && _performingEmote != null;
if (InstantItemSlotsPlugin.DebugEnabled && InstantItemSlotsPlugin.Log != null)
{
InstantItemSlotsPlugin.Log.LogInfo((object)("[IIS] Reflection: SwitchToItemSlot=" + (_switchToItemSlot != null) + " SwitchToSlotServerRpc=" + (_switchToSlotServerRpc != null) + " SwitchItemSlotsServerRpc=" + (_switchItemSlotsServerRpc != null) + " CheckConditionsForEmote=" + (_checkConditionsForEmote != null) + " StartPerformingEmoteServerRpc=" + (_startPerformingEmoteServerRpc != null)));
}
}
catch (Exception ex)
{
Ready = false;
EmoteReady = false;
if (InstantItemSlotsPlugin.Log != null)
{
InstantItemSlotsPlugin.Log.LogError((object)("[IIS] Reflection init failed: " + ex));
}
}
}
internal static void SwitchToItemSlot(PlayerControllerB player, int slot)
{
_switchToItemSlot.Invoke(player, new object[2] { slot, null });
}
internal static void SwitchToSlotServerRpc(PlayerControllerB player, int slot)
{
_switchToSlotServerRpc?.Invoke(player, new object[1] { slot });
}
internal static void SwitchItemSlotsServerRpc(PlayerControllerB player, bool forward)
{
_switchItemSlotsServerRpc?.Invoke(player, new object[1] { forward });
}
internal static bool GetThrowingObject(PlayerControllerB player)
{
try
{
return (bool)_throwingObject.GetValue(player);
}
catch
{
return false;
}
}
internal static float GetTimeSinceSwitchingSlots(PlayerControllerB player)
{
try
{
return (float)_timeSinceSwitchingSlots.GetValue(player);
}
catch
{
return -1f;
}
}
internal static void SetTimeSinceSwitchingSlots(PlayerControllerB player, float value)
{
try
{
_timeSinceSwitchingSlots.SetValue(player, value);
}
catch
{
}
}
internal static bool CheckConditionsForEmote(PlayerControllerB player)
{
try
{
return (bool)_checkConditionsForEmote.Invoke(player, null);
}
catch
{
return false;
}
}
internal static float GetTimeSinceStartingEmote(PlayerControllerB player)
{
try
{
return (float)_timeSinceStartingEmote.GetValue(player);
}
catch
{
return -1f;
}
}
internal static void SetTimeSinceStartingEmote(PlayerControllerB player, float value)
{
try
{
_timeSinceStartingEmote.SetValue(player, value);
}
catch
{
}
}
internal static void SetPerformingEmote(PlayerControllerB player, bool value)
{
try
{
_performingEmote.SetValue(player, value);
}
catch
{
}
}
internal static void StartPerformingEmoteServerRpc(PlayerControllerB player)
{
_startPerformingEmoteServerRpc?.Invoke(player, null);
}
}
[HarmonyPatch]
internal static class Patches
{
[HarmonyPatch(typeof(PlayerControllerB), "Update")]
[HarmonyPostfix]
private static void PlayerUpdatePostfix(PlayerControllerB __instance)
{
InstantItemSlotsPlugin.HandleLocalUpdate(__instance);
}
[HarmonyPatch(typeof(PlayerControllerB), "PerformEmote")]
[HarmonyPrefix]
private static bool PerformEmotePrefix()
{
return !InstantItemSlotsPlugin.ArrowEmotesOnly;
}
}
