using System;
using System.Collections;
using System.Collections.Generic;
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 TMPro;
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: AssemblyTitle("OneHandNeeded")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("OneHandNeeded")]
[assembly: AssemblyCopyright("Copyright © 2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("8fd9cbdb-051b-435f-b586-1a9ed221ccda")]
[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 HoppinHauler.OneHandNeeded;
[BepInPlugin("HoppinHauler.OneHandNeeded", "One Hand Needed (Host Required)", "3.0.0")]
public sealed class Plugin : BaseUnityPlugin
{
public const string PluginGuid = "HoppinHauler.OneHandNeeded";
public const string PluginName = "One Hand Needed (Host Required)";
public const string PluginVersion = "3.0.0";
internal static ManualLogSource Log;
internal static ConfigEntry<int> Host_TwoHandedBeforeHandsFull;
internal static ConfigEntry<bool> Host_SyncConfigToClients;
internal static ConfigEntry<int> Client_TwoHandedBeforeHandsFull;
internal static volatile bool Runtime_ModActive;
internal static volatile int Runtime_TwoHandedBeforeHandsFull;
internal static volatile bool Runtime_UsingHostSync;
private Harmony _harmony;
private HostHandshake _handshake;
private void Awake()
{
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_0039: Expected O, but got Unknown
//IL_005a: Unknown result type (might be due to invalid IL or missing references)
//IL_0064: Expected O, but got Unknown
//IL_0085: Unknown result type (might be due to invalid IL or missing references)
//IL_008f: Expected O, but got Unknown
//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
//IL_00bc: Expected O, but got Unknown
Log = ((BaseUnityPlugin)this).Logger;
Host_TwoHandedBeforeHandsFull = ((BaseUnityPlugin)this).Config.Bind<int>("Host Settings", "TwoHandedItemsBeforeHandsFull", 0, new ConfigDescription("HOST ONLY. Threshold used by the host.\nMeaning: how many two-handed items you can already have BEFORE picking another two-handed item causes 'Hands Full'.\nExample: value = 2 means you can end up carrying 3 two-handed items (the 3rd is what triggers the check).\nSet to 0 for unlimited (never block due to two-handed items).", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 10), Array.Empty<object>()));
Host_SyncConfigToClients = ((BaseUnityPlugin)this).Config.Bind<bool>("Host Settings", "SyncConfigToClients", true, new ConfigDescription("HOST ONLY. If enabled, the host will push its settings to all clients.\nClients will use host settings at runtime regardless of their local config.\nRecommended: ON for consistent multiplayer behavior.", (AcceptableValueBase)null, Array.Empty<object>()));
Client_TwoHandedBeforeHandsFull = ((BaseUnityPlugin)this).Config.Bind<int>("Client Settings", "TwoHandedItemsBeforeHandsFull", 0, new ConfigDescription("CLIENT ONLY fallback. Used only if the host disables SyncConfigToClients.\nIMPORTANT: This mod still requires the host to have it installed.\nSame meaning as host setting: 'how many you can have BEFORE the next pickup causes Hands Full'.\n0 = unlimited.", (AcceptableValueBase)null, Array.Empty<object>()));
Runtime_ModActive = false;
Runtime_UsingHostSync = false;
Runtime_TwoHandedBeforeHandsFull = 0;
_harmony = new Harmony("HoppinHauler.OneHandNeeded");
_harmony.PatchAll();
_handshake = ((Component)this).gameObject.AddComponent<HostHandshake>();
Log.LogInfo((object)"One Hand Needed (Host Required) v3.0.0 loaded (host-required).");
}
private void OnDestroy()
{
try
{
Harmony harmony = _harmony;
if (harmony != null)
{
harmony.UnpatchSelf();
}
}
catch (Exception arg)
{
ManualLogSource log = Log;
if (log != null)
{
log.LogWarning((object)$"UnpatchSelf error: {arg}");
}
}
}
internal static void ApplyHostSettings(int twoHandedBeforeHandsFull, bool usingHostSync)
{
Runtime_ModActive = true;
Runtime_UsingHostSync = usingHostSync;
Runtime_TwoHandedBeforeHandsFull = Clamp(twoHandedBeforeHandsFull, 0, 10);
ManualLogSource log = Log;
if (log != null)
{
log.LogInfo((object)$"Handshake OK. Mod active. UsingHostSync={Runtime_UsingHostSync}, TwoHandedBeforeHandsFull={Runtime_TwoHandedBeforeHandsFull}");
}
}
internal static void ApplyClientFallback()
{
Runtime_ModActive = true;
Runtime_UsingHostSync = false;
Runtime_TwoHandedBeforeHandsFull = Clamp(Client_TwoHandedBeforeHandsFull.Value, 0, 10);
ManualLogSource log = Log;
if (log != null)
{
log.LogInfo((object)$"Handshake OK. Host sync OFF. Using client fallback: TwoHandedBeforeHandsFull={Runtime_TwoHandedBeforeHandsFull}");
}
}
internal static void DisableForSession(string reason)
{
Runtime_ModActive = false;
Runtime_UsingHostSync = false;
ManualLogSource log = Log;
if (log != null)
{
log.LogWarning((object)("Mod disabled for this session: " + reason));
}
}
private static int Clamp(int v, int min, int max)
{
if (v < min)
{
return min;
}
if (v > max)
{
return max;
}
return v;
}
}
internal sealed class HostHandshake : MonoBehaviour
{
[CompilerGenerated]
private sealed class <ClientRequestAndWait>d__9 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
public HostHandshake <>4__this;
private NetworkManager <nm>5__1;
private float <wait>5__2;
private FastBufferWriter <writer>5__3;
private Exception <e>5__4;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <ClientRequestAndWait>d__9(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<nm>5__1 = null;
<e>5__4 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0070: Unknown result type (might be due to invalid IL or missing references)
//IL_0075: Unknown result type (might be due to invalid IL or missing references)
//IL_0087: Unknown result type (might be due to invalid IL or missing references)
//IL_008d: Unknown result type (might be due to invalid IL or missing references)
//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<nm>5__1 = NetworkManager.Singleton;
if ((Object)(object)<nm>5__1 == (Object)null || <nm>5__1.CustomMessagingManager == null)
{
Plugin.DisableForSession("CustomMessagingManager not available.");
return false;
}
<>4__this._clientReceivedResponse = false;
try
{
<writer>5__3 = new FastBufferWriter(4, (Allocator)2, -1);
try
{
ref FastBufferWriter reference = ref <writer>5__3;
int num = 0;
((FastBufferWriter)(ref reference)).WriteValueSafe<int>(ref num, default(ForPrimitives));
<nm>5__1.CustomMessagingManager.SendNamedMessage("HoppinHauler.OneHandNeeded/ConfigRequest", 0uL, <writer>5__3, (NetworkDelivery)3);
}
finally
{
((IDisposable)(FastBufferWriter)(ref <writer>5__3)).Dispose();
}
}
catch (Exception ex)
{
<e>5__4 = ex;
Plugin.DisableForSession("Failed to send config request: " + <e>5__4.GetType().Name);
return false;
}
<wait>5__2 = 3.5f;
break;
case 1:
<>1__state = -1;
break;
}
if (<wait>5__2 > 0f && !<>4__this._clientReceivedResponse)
{
<wait>5__2 -= Time.unscaledDeltaTime;
<>2__current = null;
<>1__state = 1;
return true;
}
if (!<>4__this._clientReceivedResponse)
{
Plugin.DisableForSession("Host did not respond (host likely does not have the mod).");
}
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <InitRoutine>d__5 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
public HostHandshake <>4__this;
private float <timeout>5__1;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <InitRoutine>d__5(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<timeout>5__1 = 12f;
goto IL_0066;
case 1:
<>1__state = -1;
goto IL_0066;
case 2:
{
<>1__state = -1;
break;
}
IL_0066:
if ((Object)(object)NetworkManager.Singleton == (Object)null && <timeout>5__1 > 0f)
{
<timeout>5__1 -= Time.unscaledDeltaTime;
<>2__current = null;
<>1__state = 1;
return true;
}
if ((Object)(object)NetworkManager.Singleton == (Object)null)
{
Plugin.DisableForSession("NetworkManager not found.");
return false;
}
<>4__this.TryRegisterHandlers();
if (NetworkManager.Singleton.IsServer)
{
Plugin.ApplyHostSettings(Plugin.Host_TwoHandedBeforeHandsFull.Value, Plugin.Host_SyncConfigToClients.Value);
break;
}
<>2__current = ((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.ClientRequestAndWait());
<>1__state = 2;
return true;
}
NetworkManager.Singleton.OnClientConnectedCallback += <>4__this.OnClientConnected;
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
private const string Msg_Request = "HoppinHauler.OneHandNeeded/ConfigRequest";
private const string Msg_Response = "HoppinHauler.OneHandNeeded/ConfigResponse";
private bool _started;
private bool _clientReceivedResponse;
private void Start()
{
if (!_started)
{
_started = true;
((MonoBehaviour)this).StartCoroutine(InitRoutine());
}
}
[IteratorStateMachine(typeof(<InitRoutine>d__5))]
private IEnumerator InitRoutine()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <InitRoutine>d__5(0)
{
<>4__this = this
};
}
private void OnDestroy()
{
try
{
if ((Object)(object)NetworkManager.Singleton != (Object)null)
{
NetworkManager.Singleton.OnClientConnectedCallback -= OnClientConnected;
}
}
catch
{
}
}
private void OnClientConnected(ulong clientId)
{
TryRegisterHandlers();
}
private void TryRegisterHandlers()
{
//IL_0075: Unknown result type (might be due to invalid IL or missing references)
//IL_007f: Expected O, but got Unknown
//IL_0040: Unknown result type (might be due to invalid IL or missing references)
//IL_004a: Expected O, but got Unknown
NetworkManager singleton = NetworkManager.Singleton;
if ((Object)(object)singleton == (Object)null || singleton.CustomMessagingManager == null)
{
return;
}
if (singleton.IsServer)
{
try
{
singleton.CustomMessagingManager.RegisterNamedMessageHandler("HoppinHauler.OneHandNeeded/ConfigRequest", new HandleNamedMessageDelegate(OnHostReceivedRequest));
}
catch
{
}
}
if (singleton.IsServer)
{
return;
}
try
{
singleton.CustomMessagingManager.RegisterNamedMessageHandler("HoppinHauler.OneHandNeeded/ConfigResponse", new HandleNamedMessageDelegate(OnClientReceivedResponse));
}
catch
{
}
}
[IteratorStateMachine(typeof(<ClientRequestAndWait>d__9))]
private IEnumerator ClientRequestAndWait()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <ClientRequestAndWait>d__9(0)
{
<>4__this = this
};
}
private void OnHostReceivedRequest(ulong clientId, FastBufferReader reader)
{
//IL_0050: Unknown result type (might be due to invalid IL or missing references)
//IL_0056: Unknown result type (might be due to invalid IL or missing references)
//IL_0064: Unknown result type (might be due to invalid IL or missing references)
//IL_006a: Unknown result type (might be due to invalid IL or missing references)
//IL_0082: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)NetworkManager.Singleton == (Object)null || !NetworkManager.Singleton.IsServer)
{
return;
}
try
{
int value = Plugin.Host_TwoHandedBeforeHandsFull.Value;
bool value2 = Plugin.Host_SyncConfigToClients.Value;
FastBufferWriter val = default(FastBufferWriter);
((FastBufferWriter)(ref val))..ctor(5, (Allocator)2, -1);
try
{
((FastBufferWriter)(ref val)).WriteValueSafe<int>(ref value, default(ForPrimitives));
((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref value2, default(ForPrimitives));
NetworkManager.Singleton.CustomMessagingManager.SendNamedMessage("HoppinHauler.OneHandNeeded/ConfigResponse", clientId, val, (NetworkDelivery)3);
}
finally
{
((IDisposable)(FastBufferWriter)(ref val)).Dispose();
}
}
catch (Exception arg)
{
ManualLogSource log = Plugin.Log;
if (log != null)
{
log.LogWarning((object)$"Failed to send config response to client {clientId}: {arg}");
}
}
}
private void OnClientReceivedResponse(ulong serverClientId, FastBufferReader reader)
{
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
try
{
int twoHandedBeforeHandsFull = default(int);
((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref twoHandedBeforeHandsFull, default(ForPrimitives));
bool flag = default(bool);
((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
_clientReceivedResponse = true;
if (flag)
{
Plugin.ApplyHostSettings(twoHandedBeforeHandsFull, usingHostSync: true);
}
else
{
Plugin.ApplyClientFallback();
}
}
catch (Exception ex)
{
_clientReceivedResponse = true;
Plugin.DisableForSession("Failed to read host config: " + ex.GetType().Name);
}
}
}
[HarmonyPatch]
internal static class PlayerPatches
{
[HarmonyPatch(typeof(PlayerControllerB), "BeginGrabObject")]
[HarmonyPostfix]
private static void BeginGrabObject_Postfix(PlayerControllerB __instance)
{
CancelTwoHanded(__instance);
}
[HarmonyPatch(typeof(PlayerControllerB), "SwitchToItemSlot")]
[HarmonyPostfix]
private static void SwitchToItemSlot_Postfix(PlayerControllerB __instance)
{
CancelTwoHanded(__instance);
}
[HarmonyPatch(typeof(PlayerControllerB), "GrabObjectClientRpc")]
[HarmonyPostfix]
private static void GrabObjectClientRpc_Postfix(PlayerControllerB __instance)
{
CancelTwoHanded(__instance);
}
private static void CancelTwoHanded(PlayerControllerB player)
{
if (!Plugin.Runtime_ModActive)
{
return;
}
try
{
if ((Object)(object)player == (Object)null || !player.twoHanded || IsHoldingLiveEnemy(player))
{
return;
}
int runtime_TwoHandedBeforeHandsFull = Plugin.Runtime_TwoHandedBeforeHandsFull;
if (runtime_TwoHandedBeforeHandsFull == 0)
{
ForceNotTwoHanded(player);
return;
}
int num = CountTwoHandedItemsInInventory(player);
if (num < runtime_TwoHandedBeforeHandsFull)
{
ForceNotTwoHanded(player);
}
}
catch (Exception arg)
{
ManualLogSource log = Plugin.Log;
if (log != null)
{
log.LogWarning((object)$"CancelTwoHanded exception: {arg}");
}
}
}
private static void ForceNotTwoHanded(PlayerControllerB player)
{
player.twoHanded = false;
if (!((NetworkBehaviour)player).IsOwner)
{
return;
}
HUDManager instance = HUDManager.Instance;
if (!((Object)(object)instance == (Object)null))
{
TextMeshProUGUI holdingTwoHandedItem = instance.holdingTwoHandedItem;
if (!((Object)(object)holdingTwoHandedItem == (Object)null))
{
((Behaviour)holdingTwoHandedItem).enabled = false;
}
}
}
private static bool IsHoldingLiveEnemy(PlayerControllerB player)
{
GrabbableObject currentlyHeldObjectServer = player.currentlyHeldObjectServer;
if ((Object)(object)currentlyHeldObjectServer == (Object)null)
{
return false;
}
Component val = (Component)(object)currentlyHeldObjectServer;
if ((Object)(object)val == (Object)null)
{
return false;
}
EnemyAI component = val.GetComponent<EnemyAI>();
if ((Object)(object)component == (Object)null)
{
return false;
}
return !component.isEnemyDead;
}
private static int CountTwoHandedItemsInInventory(PlayerControllerB player)
{
int num = 0;
GrabbableObject[] itemSlots = player.ItemSlots;
if (itemSlots == null)
{
return 0;
}
foreach (GrabbableObject val in itemSlots)
{
if (!((Object)(object)val == (Object)null))
{
Item itemProperties = val.itemProperties;
if (!((Object)(object)itemProperties == (Object)null) && itemProperties.twoHanded)
{
num++;
}
}
}
return num;
}
}
