using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Security;
using System.Security.Permissions;
using BagConfig.Dependency;
using BagConfig.InputUtils;
using BagConfig.Networking;
using BagConfig.Patches;
using BagConfig.Utils;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using HarmonyLib.Public.Patching;
using JetBrains.Annotations;
using LethalCompanyInputUtils.Api;
using LethalConfig;
using LethalConfig.ConfigItems;
using LethalConfig.ConfigItems.Options;
using LobbyCompatibility.Enums;
using LobbyCompatibility.Features;
using Microsoft.CodeAnalysis;
using Mono.Cecil;
using Mono.Cecil.Cil;
using Mono.Collections.Generic;
using MonoMod.RuntimeDetour;
using MonoMod.Utils;
using Unity.Collections;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.InputSystem;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("AmazingAssets.TerrainToMesh")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp-firstpass")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: IgnoresAccessChecksTo("ClientNetworkTransform")]
[assembly: IgnoresAccessChecksTo("com.olegknyazev.softmask")]
[assembly: IgnoresAccessChecksTo("DissonanceVoip")]
[assembly: IgnoresAccessChecksTo("EasyTextEffects")]
[assembly: IgnoresAccessChecksTo("Facepunch Transport for Netcode for GameObjects")]
[assembly: IgnoresAccessChecksTo("Facepunch.Steamworks.Win64")]
[assembly: IgnoresAccessChecksTo("Unity.AI.Navigation")]
[assembly: IgnoresAccessChecksTo("Unity.Animation.Rigging")]
[assembly: IgnoresAccessChecksTo("Unity.Animation.Rigging.DocCodeExamples")]
[assembly: IgnoresAccessChecksTo("Unity.Burst")]
[assembly: IgnoresAccessChecksTo("Unity.Burst.Unsafe")]
[assembly: IgnoresAccessChecksTo("Unity.Collections")]
[assembly: IgnoresAccessChecksTo("Unity.Collections.LowLevel.ILSupport")]
[assembly: IgnoresAccessChecksTo("Unity.InputSystem")]
[assembly: IgnoresAccessChecksTo("Unity.InputSystem.ForUI")]
[assembly: IgnoresAccessChecksTo("Unity.Jobs")]
[assembly: IgnoresAccessChecksTo("Unity.Mathematics")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.Common")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.MetricTypes")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStats")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsMonitor.Component")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsMonitor.Configuration")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsMonitor.Implementation")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsReporting")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetworkProfiler.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetworkSolutionInterface")]
[assembly: IgnoresAccessChecksTo("Unity.Netcode.Components")]
[assembly: IgnoresAccessChecksTo("Unity.Netcode.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.Networking.Transport")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.Csg")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.KdTree")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.Poly2Tri")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.Stl")]
[assembly: IgnoresAccessChecksTo("Unity.Profiling.Core")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.Core.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.Core.ShaderLibrary")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.HighDefinition.Config.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.HighDefinition.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.ShaderGraph.ShaderGraphLibrary")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Authentication")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Analytics")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Components")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Configuration")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Device")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Environments")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Environments.Internal")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Internal")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Networking")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Registration")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Scheduler")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Telemetry")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Threading")]
[assembly: IgnoresAccessChecksTo("Unity.Services.QoS")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Relay")]
[assembly: IgnoresAccessChecksTo("Unity.TextMeshPro")]
[assembly: IgnoresAccessChecksTo("Unity.Timeline")]
[assembly: IgnoresAccessChecksTo("Unity.VisualEffectGraph.Runtime")]
[assembly: IgnoresAccessChecksTo("UnityEngine.ARModule")]
[assembly: IgnoresAccessChecksTo("UnityEngine.NVIDIAModule")]
[assembly: IgnoresAccessChecksTo("UnityEngine.UI")]
[assembly: AssemblyCompany("mattymatty")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.3")]
[assembly: AssemblyInformationalVersion("1.0.3+867df470be87d0129e569a7e0a6dcfcb6e1b1e17")]
[assembly: AssemblyProduct("BagConfig")]
[assembly: AssemblyTitle("BagConfig - Plugin")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.3.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 BagConfig
{
[BepInPlugin("mattymatty.BagConfig", "BagConfig", "1.0.3")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
internal class BagConfig : BaseUnityPlugin
{
internal static readonly ISet<Hook> Hooks = new HashSet<Hook>();
internal static readonly Harmony Harmony = new Harmony("mattymatty.BagConfig");
public const string GUID = "mattymatty.BagConfig";
public const string NAME = "BagConfig";
public const string VERSION = "1.0.3";
internal static ManualLogSource Log;
public static BagConfig INSTANCE { get; private set; }
private void Awake()
{
INSTANCE = this;
Log = ((BaseUnityPlugin)this).Logger;
try
{
if (LobbyCompatibilityChecker.Enabled)
{
LobbyCompatibilityChecker.Init();
}
if (InputUtilsProxy.Enabled)
{
InputUtilsProxy.Init();
}
Log.LogInfo((object)"Initializing Configs");
PluginConfig.Init();
Log.LogInfo((object)"Patching Methods");
PatchLateJoin.Init();
Harmony.PatchAll();
BeltBagPatch.Patch();
Log.LogInfo((object)"BagConfig v1.0.3 Loaded!");
}
catch (Exception ex)
{
Log.LogError((object)("Exception while initializing: \n" + ex));
}
}
}
internal static class PluginConfig
{
public static class Misc
{
public static ConfigEntry<bool> Tooltip { get; internal set; }
public static ConfigEntry<bool> DropAll { get; internal set; }
public static ConfigEntry<bool> HideBag { get; internal set; }
public static ConfigEntry<float> GrabRange { get; internal set; }
}
public static class Host
{
public static ConfigEntry<bool> Capacity { get; internal set; }
public static ConfigEntry<bool> Category { get; internal set; }
public static ConfigEntry<bool> Range { get; internal set; }
public static ConfigEntry<bool> AllowVanilla { get; internal set; }
}
public static class Limits
{
public static StringDictionary ItemCategoryAssociations = new StringDictionary();
public static readonly Dictionary<string, ICategoryConfig> CategoryConfigs = new Dictionary<string, ICategoryConfig>();
public static ConfigEntry<int> Capacity { get; internal set; }
public static ConfigEntry<string> ItemCategories { get; internal set; }
}
public interface ICategoryConfig
{
string CategoryName { get; }
bool Allow { get; }
int Limit { get; }
}
public class StaticCategoryConfig : ICategoryConfig
{
public string CategoryName { get; }
public bool Allow { get; }
public int Limit { get; }
public StaticCategoryConfig(string categoryName, bool allow, int limit)
{
CategoryName = categoryName;
Allow = allow;
Limit = limit;
}
}
public class BepInExCategoryConfig : ICategoryConfig
{
private readonly ConfigEntry<bool> _allowConfig;
private readonly ConfigEntry<int> _limitConfig;
public string CategoryName { get; }
public bool Allow => _allowConfig.Value;
public int Limit => _limitConfig.Value;
public BepInExCategoryConfig(string categoryName, bool allow = false, int max = -1)
{
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
//IL_0043: Expected O, but got Unknown
//IL_008e: Unknown result type (might be due to invalid IL or missing references)
//IL_0098: Expected O, but got Unknown
CategoryName = categoryName;
_allowConfig = ((BaseUnityPlugin)BagConfig.INSTANCE).Config.Bind<bool>("Limit." + CategoryName, "Allow", allow, new ConfigDescription("Allow grabbing this category!", (AcceptableValueBase)null, Array.Empty<object>()));
_limitConfig = ((BaseUnityPlugin)BagConfig.INSTANCE).Config.Bind<int>("Limit." + CategoryName, "Max Amount", max, new ConfigDescription("How many items of this category can be stored at the same time?", (AcceptableValueBase)(object)new AcceptableValueRange<int>(-1, Limits.Capacity?.Value ?? int.MaxValue), Array.Empty<object>()));
if (LethalConfigProxy.Enabled)
{
LethalConfigProxy.AddConfig(_allowConfig);
LethalConfigProxy.AddConfig(_limitConfig);
}
}
}
private const string ToolsCategory = "Tools";
private const string DenyCategory = "Deny";
private const string OneHandedCategory = "One Handed Scrap";
private const string TwoHandedCategory = "Two Handed Scrap";
internal static void Init()
{
//IL_0085: Unknown result type (might be due to invalid IL or missing references)
//IL_008f: Expected O, but got Unknown
//IL_0122: Unknown result type (might be due to invalid IL or missing references)
//IL_012c: Expected O, but got Unknown
//IL_014c: Unknown result type (might be due to invalid IL or missing references)
//IL_0156: Expected O, but got Unknown
ConfigFile config = ((BaseUnityPlugin)BagConfig.INSTANCE).Config;
Misc.Tooltip = config.Bind<bool>("Miscellaneous", "Tooltip", true, "Show a tooltip if the target item cannot be stored");
Misc.DropAll = config.Bind<bool>("Miscellaneous", "Add Empty Bag Action", true, "Add action to Drop the entire bag inventory");
Misc.HideBag = config.Bind<bool>("Miscellaneous", "Hide Bag When Pocketed", false, "Hide the bag when in pocket ( also disables opening it by looking down )");
Misc.GrabRange = config.Bind<float>("Miscellaneous", "Grab Range", 4f, new ConfigDescription("Max range for grabbing items with the bag", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 20f), Array.Empty<object>()));
Host.Capacity = config.Bind<bool>("Host Settings", "Enforce Capacity", true, "Server-side check to limit the bag Capacity");
Host.Category = config.Bind<bool>("Host Settings", "Enforce Restrictions", true, "Server-side check to limit the items allowed inside the Bag");
Host.Range = config.Bind<bool>("Host Settings", "Enforce Range", true, "Server-side check to limit the grab range");
Host.AllowVanilla = config.Bind<bool>("Host Settings", "Allow Vanilla Clients", false, "Allow clients w/o the mod to join the lobby");
Limits.Capacity = config.Bind<int>("Limits", "Capacity", 15, new ConfigDescription("How many items can the bag store", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, int.MaxValue), Array.Empty<object>()));
Limits.ItemCategories = config.Bind<string>("Limits", "Item Categories", "Body: Deny", new ConfigDescription("Dictionary describing the association between a Item and a Category name", (AcceptableValueBase)null, Array.Empty<object>()));
Limits.CategoryConfigs["Tools"] = new BepInExCategoryConfig("Tools", allow: true);
Limits.CategoryConfigs["One Handed Scrap"] = new BepInExCategoryConfig("One Handed Scrap");
Limits.CategoryConfigs["Two Handed Scrap"] = new BepInExCategoryConfig("Two Handed Scrap");
Limits.CategoryConfigs["Deny"] = new StaticCategoryConfig("Deny", allow: false, 0);
ProcessCategories(Limits.ItemCategories);
Limits.ItemCategories.SettingChanged += delegate
{
ProcessCategories(Limits.ItemCategories);
};
if (LethalConfigProxy.Enabled)
{
LethalConfigProxy.AddConfig(Misc.Tooltip);
LethalConfigProxy.AddConfig(Misc.DropAll, requiresRestart: true);
LethalConfigProxy.AddConfig(Misc.HideBag);
LethalConfigProxy.AddConfig(Misc.GrabRange);
LethalConfigProxy.AddConfig(Limits.Capacity);
LethalConfigProxy.AddConfig(Limits.ItemCategories);
LethalConfigProxy.AddConfig(Host.Capacity);
LethalConfigProxy.AddConfig(Host.Category);
LethalConfigProxy.AddConfig(Host.Range);
LethalConfigProxy.AddConfig(Host.AllowVanilla, requiresRestart: true);
LethalConfigProxy.AddButton("Fixes", "Fix Locked BeltBags", "Re-Enable all BeltBags that are in a broken state", "Fix", delegate
{
NamedMessages.FixBagsClientRpc();
}, () => ((Object)(object)StartOfRound.Instance == (Object)null) ? (false, "You need to be in a lobby to call this") : ((!GameNetworkManager.Instance.isHostingGame) ? (false, "Only host can call this function") : (true, "")));
}
CleanAndSave();
static void ProcessCategories(ConfigEntry<string> entry)
{
Limits.ItemCategoryAssociations = ProcessDictionary(entry);
foreach (string value3 in Limits.ItemCategoryAssociations.Values)
{
if (!Limits.CategoryConfigs.ContainsKey(value3))
{
Limits.CategoryConfigs[value3] = new BepInExCategoryConfig(value3, allow: true);
}
}
}
static StringDictionary ProcessDictionary(ConfigEntry<string> entry)
{
string value = entry.Value;
StringDictionary stringDictionary = new StringDictionary();
string[] array = value.Split(",");
foreach (string text in array)
{
string text2 = text.Trim();
string[] array2 = text2.Split(":");
if (array2.Length != 2)
{
BagConfig.Log.LogError((object)("Item Association: malformed Entry! " + text2));
}
else
{
string text3 = array2[0].Trim();
string value2 = array2[1].Trim();
if (stringDictionary.ContainsKey(text3))
{
BagConfig.Log.LogWarning((object)("Item Association: " + text3 + " was already defined - overwriting!"));
}
stringDictionary[text3] = value2;
}
}
return stringDictionary;
}
}
internal static void CleanAndSave()
{
ConfigFile config = ((BaseUnityPlugin)BagConfig.INSTANCE).Config;
PropertyInfo propertyInfo = AccessTools.Property(((object)config).GetType(), "OrphanedEntries");
Dictionary<ConfigDefinition, string> dictionary = (Dictionary<ConfigDefinition, string>)propertyInfo.GetValue(config, null);
dictionary.Clear();
config.Save();
}
public static ICategoryConfig GetBagCategory(this GrabbableObject grabbable)
{
if (Limits.ItemCategoryAssociations.ContainsKey(grabbable.itemProperties.itemName))
{
return Limits.CategoryConfigs[Limits.ItemCategoryAssociations[grabbable.itemProperties.itemName]];
}
bool isScrap = grabbable.itemProperties.isScrap;
bool twoHanded = grabbable.itemProperties.twoHanded;
if (!isScrap)
{
return Limits.CategoryConfigs["Tools"];
}
if (!twoHanded)
{
return Limits.CategoryConfigs["One Handed Scrap"];
}
return Limits.CategoryConfigs["Two Handed Scrap"];
}
}
public static class MyPluginInfo
{
public const string PLUGIN_GUID = "mattymatty.BagConfig";
public const string PLUGIN_NAME = "BagConfig";
public const string PLUGIN_VERSION = "1.0.3";
}
}
namespace BagConfig.Utils
{
public static class NgoUtils
{
private static readonly MethodInfo BeginSendClientRpc = AccessTools.Method(typeof(NetworkBehaviour), "__beginSendClientRpc", (Type[])null, (Type[])null);
private static readonly MethodInfo BeginSendServerRpc = AccessTools.Method(typeof(NetworkBehaviour), "__beginSendServerRpc", (Type[])null, (Type[])null);
private static readonly __RpcExecStage ClientRpcStage;
private static readonly __RpcExecStage ServerRpcStage;
public static bool IsRPCClientStage(this NetworkBehaviour self)
{
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
NetworkManager networkManager = self.NetworkManager;
if ((Object)(object)networkManager == (Object)null || !networkManager.IsListening)
{
return false;
}
if (self.__rpc_exec_stage != ClientRpcStage || (!networkManager.IsClient && !networkManager.IsHost))
{
return false;
}
return true;
}
public static bool IsRPCServerStage(this NetworkBehaviour self)
{
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
NetworkManager networkManager = self.NetworkManager;
if ((Object)(object)networkManager == (Object)null || !networkManager.IsListening)
{
return false;
}
if (self.__rpc_exec_stage != ServerRpcStage || (!networkManager.IsServer && !networkManager.IsHost))
{
return false;
}
return true;
}
internal static bool TryGetRpcID(this MethodInfo methodInfo, out uint rpcID)
{
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_0071: Unknown result type (might be due to invalid IL or missing references)
//IL_0076: Unknown result type (might be due to invalid IL or missing references)
//IL_0046: Unknown result type (might be due to invalid IL or missing references)
//IL_004b: Unknown result type (might be due to invalid IL or missing references)
Collection<Instruction> instructions = PatchManager.GetMethodPatcher((MethodBase)methodInfo).CopyOriginal().Definition.Body.Instructions;
rpcID = 0u;
for (int i = 0; i < instructions.Count; i++)
{
if (instructions[i].OpCode == OpCodes.Ldc_I4 && instructions[i - 1].OpCode == OpCodes.Ldarg_0)
{
rpcID = (uint)(int)instructions[i].Operand;
}
if (!(instructions[i].OpCode != OpCodes.Call))
{
object operand = instructions[i].Operand;
MethodReference val = (MethodReference)((operand is MethodReference) ? operand : null);
if (val != null && (Extensions.Is((MemberReference)(object)val, (MemberInfo)BeginSendClientRpc) || Extensions.Is((MemberReference)(object)val, (MemberInfo)BeginSendServerRpc)))
{
BagConfig.Log.LogDebug((object)$"Rpc Id found for {methodInfo.Name}: {rpcID}U");
return true;
}
}
}
BagConfig.Log.LogFatal((object)("Cannot find Rpc ID for " + methodInfo.Name));
return false;
}
static NgoUtils()
{
//IL_004e: 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_0050: Unknown result type (might be due to invalid IL or missing references)
//IL_006d: Unknown result type (might be due to invalid IL or missing references)
//IL_0069: Unknown result type (might be due to invalid IL or missing references)
//IL_006e: Unknown result type (might be due to invalid IL or missing references)
//IL_006f: Unknown result type (might be due to invalid IL or missing references)
string unityVersion = Application.unityVersion;
__RpcExecStage clientRpcStage = ((!(unityVersion == "2022.3.9f1")) ? ((__RpcExecStage)1) : ((__RpcExecStage)2));
ClientRpcStage = clientRpcStage;
string unityVersion2 = Application.unityVersion;
clientRpcStage = ((!(unityVersion2 == "2022.3.9f1")) ? ((__RpcExecStage)1) : ((__RpcExecStage)1));
ServerRpcStage = clientRpcStage;
}
}
}
namespace BagConfig.Patches
{
[HarmonyPatch]
internal static class BeltBagPatch
{
private class CategoryCount
{
public int Count;
}
[HarmonyPatch(typeof(BeltBagItem), "PutObjectInBagLocalClient")]
private static class OnItemPutObjectInBag
{
[UsedImplicitly]
private static void Prefix(BeltBagItem __instance, GrabbableObject gObject, ref bool __state)
{
__state = __instance.objectsInBag.Contains(gObject);
}
[UsedImplicitly]
private static void Postfix(BeltBagItem __instance, GrabbableObject gObject, ref bool __state)
{
if (__state)
{
return;
}
PluginConfig.ICategoryConfig bagCategory = gObject.GetBagCategory();
ConditionalWeakTable<PluginConfig.ICategoryConfig, CategoryCount> orCreateValue = CategoryMemory.GetOrCreateValue(__instance);
orCreateValue.GetOrCreateValue(bagCategory).Count++;
LungProp val = (LungProp)(object)((gObject is LungProp) ? gObject : null);
if (val != null)
{
if (val.isLungDocked)
{
val.isLungDocked = false;
if (val.disconnectAnimation != null)
{
((MonoBehaviour)val).StopCoroutine(val.disconnectAnimation);
}
val.disconnectAnimation = ((MonoBehaviour)val).StartCoroutine(val.DisconnectFromMachinery());
}
if (val.isLungDockedInElevator)
{
val.isLungDockedInElevator = false;
((Component)val).gameObject.GetComponent<AudioSource>().PlayOneShot(val.disconnectSFX);
}
}
if (!((GrabbableObject)__instance).hasBeenHeld)
{
((GrabbableObject)__instance).hasBeenHeld = true;
if (!((GrabbableObject)__instance).isInShipRoom && !StartOfRound.Instance.inShipPhase && StartOfRound.Instance.currentLevel.spawnEnemiesAndScrap)
{
RoundManager instance = RoundManager.Instance;
instance.valueOfFoundScrapItems += ((GrabbableObject)__instance).scrapValue;
}
}
}
}
[CompilerGenerated]
private sealed class <EmptyBagCoroutine>d__4 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public BeltBagItem @this;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <EmptyBagCoroutine>d__4(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
break;
case 1:
<>1__state = -1;
break;
}
if (this.@this.objectsInBag.Count > 0)
{
this.@this.RemoveObjectFromBag(0);
<>2__current = (object)new WaitForEndOfFrame();
<>1__state = 1;
return true;
}
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();
}
}
internal static bool Enabled;
private static readonly Action<GrabbableObject, bool> BaseInteractMethod;
private static readonly ConditionalWeakTable<BeltBagItem, ConditionalWeakTable<PluginConfig.ICategoryConfig, CategoryCount>> CategoryMemory;
internal static void Patch()
{
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
//IL_0049: 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_0054: Expected O, but got Unknown
MethodInfo methodInfo = AccessTools.Method(typeof(BeltBagItem), "ItemInteractLeftRight", (Type[])null, (Type[])null);
MethodInfo methodInfo2 = AccessTools.Method(typeof(BeltBagPatch), "OverrideGrab", (Type[])null, (Type[])null);
BagConfig.Hooks.Add(new Hook((MethodBase)methodInfo, methodInfo2, new HookConfig
{
Priority = -999
}));
}
static BeltBagPatch()
{
Enabled = false;
CategoryMemory = new ConditionalWeakTable<BeltBagItem, ConditionalWeakTable<PluginConfig.ICategoryConfig, CategoryCount>>();
MethodInfo meth = AccessTools.Method(typeof(GrabbableObject), "ItemInteractLeftRight", (Type[])null, (Type[])null);
DynamicMethod dynamicMethod = new DynamicMethod("Base.ItemInteractLeftRight", null, new Type[2]
{
typeof(GrabbableObject),
typeof(bool)
}, typeof(BeltBagItem));
ILGenerator iLGenerator = dynamicMethod.GetILGenerator();
iLGenerator.Emit(OpCodes.Ldarg_0);
iLGenerator.Emit(OpCodes.Ldarg_1);
iLGenerator.Emit(OpCodes.Call, meth);
iLGenerator.Emit(OpCodes.Ret);
BaseInteractMethod = (Action<GrabbableObject, bool>)dynamicMethod.CreateDelegate(typeof(Action<GrabbableObject, bool>));
}
[IteratorStateMachine(typeof(<EmptyBagCoroutine>d__4))]
private static IEnumerator EmptyBagCoroutine(BeltBagItem @this)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <EmptyBagCoroutine>d__4(0)
{
@this = @this
};
}
internal static void TryDumpItems(BeltBagItem @this, bool checkInHand = true)
{
if (PluginConfig.Misc.DropAll.Value && !((Object)(object)((GrabbableObject)@this).playerHeldBy == (Object)null) && (!checkInHand || !((Object)(object)((GrabbableObject)@this).playerHeldBy.currentlyHeldObjectServer != (Object)(object)@this)))
{
((MonoBehaviour)@this).StartCoroutine(EmptyBagCoroutine(@this));
}
}
internal static void TryGrabItem(BeltBagItem @this, bool checkInHand = true)
{
//IL_007d: Unknown result type (might be due to invalid IL or missing references)
//IL_0092: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)((GrabbableObject)@this).playerHeldBy == (Object)null || (checkInHand && (Object)(object)((GrabbableObject)@this).playerHeldBy.currentlyHeldObjectServer != (Object)(object)@this) || @this.tryingAddToBag)
{
return;
}
if (@this.objectsInBag.Count >= PluginConfig.Limits.Capacity.Value)
{
if (PluginConfig.Misc.Tooltip.Value)
{
HUDManager.Instance.DisplayTip("Belt bag Info", "This bag is Full!", false, false, "LC_Tip1");
}
}
else
{
RaycastHit val = default(RaycastHit);
if (!Physics.Raycast(((Component)((GrabbableObject)@this).playerHeldBy.gameplayCamera).transform.position, ((Component)((GrabbableObject)@this).playerHeldBy.gameplayCamera).transform.forward, ref val, PluginConfig.Misc.GrabRange.Value, GameNetworkManager.Instance.localPlayerController.interactableObjectsMask))
{
return;
}
ManualLogSource log = BagConfig.Log;
Transform parent = ((Component)((RaycastHit)(ref val)).collider).transform.parent;
log.LogDebug((object)("Grab Hit: " + ((parent != null) ? ((Object)parent).name : null) + "." + ((Object)((Component)((RaycastHit)(ref val)).collider).gameObject).name));
if (((Component)((RaycastHit)(ref val)).collider).gameObject.layer == 8 || ((Component)((RaycastHit)(ref val)).collider).tag != "PhysicsProp")
{
return;
}
GrabbableObject component = ((Component)((RaycastHit)(ref val)).collider).gameObject.GetComponent<GrabbableObject>();
if (!@this.CanBePutInBag(component))
{
return;
}
if (@this.CheckBagFilters(component, out var limited, out var disallowed))
{
@this.TryAddObjectToBag(component);
}
else if (PluginConfig.Misc.Tooltip.Value)
{
if (!disallowed && limited)
{
PluginConfig.ICategoryConfig bagCategory = component.GetBagCategory();
HUDManager.Instance.DisplayTip("Belt bag Info", "Cannot store any more " + bagCategory.CategoryName + " inside of the bag!", false, false, "LC_Tip1");
}
else
{
HUDManager.Instance.DisplayTip("Belt bag Info", "Cannot store " + component.itemProperties.itemName + " inside of the bag!", false, false, "LC_Tip1");
}
}
}
}
private static void OverrideGrab(Action<BeltBagItem, bool> orig, BeltBagItem @this, bool right)
{
if (!Enabled)
{
orig(@this, arg2: false);
return;
}
BaseInteractMethod((GrabbableObject)(object)@this, right);
if (!InputUtilsProxy.Enabled)
{
if (right)
{
TryDumpItems(@this);
}
else
{
TryGrabItem(@this);
}
}
}
private static bool CanBePutInBag(this BeltBagItem @this, GrabbableObject grabbable)
{
if (Object.op_Implicit((Object)(object)grabbable) && (Object)(object)grabbable != (Object)(object)@this && !grabbable.isHeld && !grabbable.isHeldByEnemy)
{
return grabbable.itemProperties.itemId != 123984;
}
return false;
}
private static bool CheckBagFilters(this BeltBagItem @this, GrabbableObject grabbable, out bool limited, out bool disallowed)
{
limited = false;
PluginConfig.ICategoryConfig bagCategory = grabbable.GetBagCategory();
disallowed = !bagCategory.Allow;
int limit = bagCategory.Limit;
if (limit < 0)
{
return !disallowed;
}
if (limit == 0)
{
limited = true;
return false;
}
ConditionalWeakTable<PluginConfig.ICategoryConfig, CategoryCount> orCreateValue = CategoryMemory.GetOrCreateValue(@this);
if (orCreateValue.TryGetValue(bagCategory, out var value) && value.Count >= limit)
{
limited = true;
return false;
}
return !disallowed;
}
[HarmonyPrefix]
[HarmonyPatch(typeof(StartOfRound), "Start")]
private static void AddBagTooltip(StartOfRound __instance)
{
if (!PluginConfig.Misc.DropAll.Value)
{
return;
}
BeltBagItem val = default(BeltBagItem);
foreach (Item items in __instance.allItemsList.itemsList)
{
if (Object.op_Implicit((Object)(object)items.spawnPrefab) && items.spawnPrefab.TryGetComponent<BeltBagItem>(ref val))
{
Array.Resize(ref items.toolTips, items.toolTips.Length + 1);
items.toolTips[^1] = "Empty Bag: [E]";
break;
}
}
}
[HarmonyPostfix]
[HarmonyPatch(typeof(BeltBagItem), "RemoveFromBagLocalClientNonElevatorParent")]
[HarmonyPatch(typeof(BeltBagItem), "RemoveFromBagLocalClient")]
private static void TrackRemove(BeltBagItem __instance, NetworkObjectReference objectRef)
{
ConditionalWeakTable<PluginConfig.ICategoryConfig, CategoryCount> orCreateValue = CategoryMemory.GetOrCreateValue(__instance);
NetworkObject val = default(NetworkObject);
GrabbableObject grabbable = default(GrabbableObject);
if (((NetworkObjectReference)(ref objectRef)).TryGet(ref val, (NetworkManager)null) && ((Component)val).TryGetComponent<GrabbableObject>(ref grabbable))
{
PluginConfig.ICategoryConfig bagCategory = grabbable.GetBagCategory();
orCreateValue.GetOrCreateValue(bagCategory).Count--;
}
if (__instance.objectsInBag.Count == 0)
{
orCreateValue.Clear();
}
}
[HarmonyPrefix]
[HarmonyPatch(typeof(BeltBagItem), "TryAddObjectToBagServerRpc")]
private static bool EnforceLimits(BeltBagItem __instance, NetworkObjectReference netObjectRef, int playerWhoAdded)
{
//IL_0091: Unknown result type (might be due to invalid IL or missing references)
//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
if (!((NetworkBehaviour)(object)__instance).IsRPCServerStage())
{
return true;
}
NetworkObject val = default(NetworkObject);
if (!((NetworkObjectReference)(ref netObjectRef)).TryGet(ref val, (NetworkManager)null))
{
return true;
}
GrabbableObject component = ((Component)val).GetComponent<GrabbableObject>();
if (!__instance.CanBePutInBag(component))
{
__instance.CancelAddObjectToBagClientRpc(playerWhoAdded);
return false;
}
if (PluginConfig.Host.Capacity.Value && __instance.objectsInBag.Count >= PluginConfig.Limits.Capacity.Value)
{
__instance.CancelAddObjectToBagClientRpc(playerWhoAdded);
return false;
}
if (PluginConfig.Host.Category.Value && !__instance.CheckBagFilters(component, out var _, out var _))
{
__instance.CancelAddObjectToBagClientRpc(playerWhoAdded);
return false;
}
if (PluginConfig.Host.Range.Value)
{
Vector3 position = ((Component)component).transform.position;
PlayerControllerB playerHeldBy = ((GrabbableObject)__instance).playerHeldBy;
if (Vector3.Distance(position, (playerHeldBy != null) ? ((Component)playerHeldBy.gameplayCamera).transform.position : Vector3.positiveInfinity) > PluginConfig.Misc.GrabRange.Value)
{
__instance.CancelAddObjectToBagClientRpc(playerWhoAdded);
return false;
}
}
return true;
}
[HarmonyPostfix]
[HarmonyPatch(typeof(BeltBagItem), "CancelAddObjectToBagClientRpc")]
private static void OnServerRefusal(int playerWhoAdded)
{
if (!((Object)(object)StartOfRound.Instance.allPlayerScripts[playerWhoAdded] != (Object)(object)GameNetworkManager.Instance.localPlayerController))
{
HUDManager.Instance.DisplayTip("Belt bag Info", "Host refused your grab request!", true, false, "LC_Tip1");
}
}
[HarmonyTranspiler]
[HarmonyPatch(typeof(BeltBagItem), "RemoveObjectFromBag")]
private static IEnumerable<CodeInstruction> FixDrop(IEnumerable<CodeInstruction> instructions, ILGenerator ilGenerator)
{
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: Expected O, but got Unknown
//IL_0053: Unknown result type (might be due to invalid IL or missing references)
//IL_0059: Expected O, but got Unknown
//IL_008f: Unknown result type (might be due to invalid IL or missing references)
//IL_0095: Expected O, but got Unknown
//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
//IL_00b0: Expected O, but got Unknown
//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
//IL_00cb: Expected O, but got Unknown
List<CodeInstruction> list = instructions.ToList();
MethodInfo methodInfo = AccessTools.Method(typeof(GrabbableObject), "GetItemFloorPosition", (Type[])null, (Type[])null);
MethodInfo methodInfo2 = AccessTools.Method(typeof(BeltBagPatch), "FixVerticalOffset", (Type[])null, (Type[])null);
CodeMatcher val = new CodeMatcher((IEnumerable<CodeInstruction>)list, ilGenerator);
val.MatchForward(true, (CodeMatch[])(object)new CodeMatch[1]
{
new CodeMatch((OpCode?)OpCodes.Call, (object)methodInfo, (string)null)
});
if (val.IsInvalid)
{
BagConfig.Log.LogError((object)"Patch RemoveObjectFromBag, Fail - 1 ");
return list;
}
val.Advance(1);
val.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
{
new CodeInstruction(OpCodes.Ldarg_0, (object)null)
});
val.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
{
new CodeInstruction(OpCodes.Ldarg_1, (object)null)
});
val.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
{
new CodeInstruction(OpCodes.Call, (object)methodInfo2)
});
return val.Instructions();
}
private static Vector3 FixVerticalOffset(Vector3 position, BeltBagItem beltBagItem, int index)
{
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
//IL_0042: Unknown result type (might be due to invalid IL or missing references)
//IL_0044: Unknown result type (might be due to invalid IL or missing references)
//IL_0045: Unknown result type (might be due to invalid IL or missing references)
//IL_0055: Unknown result type (might be due to invalid IL or missing references)
//IL_005a: Unknown result type (might be due to invalid IL or missing references)
//IL_005f: Unknown result type (might be due to invalid IL or missing references)
//IL_0061: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
if (beltBagItem.objectsInBag.Count <= index)
{
return position;
}
GrabbableObject val = beltBagItem.objectsInBag[index];
if (!Object.op_Implicit((Object)(object)val))
{
return position;
}
position += Vector3.down * ((GrabbableObject)beltBagItem).itemProperties.verticalOffset;
position += Vector3.up * val.itemProperties.verticalOffset;
return position;
}
[HarmonyPostfix]
[HarmonyPatch(typeof(BeltBagItem), "PocketItem")]
private static void HideWhenInPocket(BeltBagItem __instance)
{
if (((NetworkBehaviour)__instance).IsOwner && PluginConfig.Misc.HideBag.Value)
{
((Component)__instance.useBagTrigger).GetComponent<Collider>().enabled = false;
((GrabbableObject)__instance).EnableItemMeshes(false);
}
}
[HarmonyPrefix]
[HarmonyPatch(typeof(StartOfRound), "Start")]
private static void OnLobbyJoin(StartOfRound __instance)
{
Enabled = ((NetworkBehaviour)__instance).IsServer;
}
[HarmonyPostfix]
[HarmonyPatch(typeof(StartOfRound), "OnClientConnect")]
private static void OnClientJoined(StartOfRound __instance, ulong clientId)
{
if (((NetworkBehaviour)__instance).IsServer)
{
NamedMessages.HostPresentClientRpc(new <>z__ReadOnlySingleElementList<ulong>(clientId));
}
}
[HarmonyPrefix]
[HarmonyPatch(typeof(MenuManager), "Start")]
private static void OnMainMenu()
{
Enabled = false;
}
}
[HarmonyPatch]
internal class NetworkManagerPatch
{
[HarmonyPostfix]
[HarmonyPatch(typeof(NetworkManager), "Initialize")]
private static void AfterInitialize()
{
BagConfig.Log.LogInfo((object)"Registering Named Messages!");
NamedMessages.RegisterNamedMessages();
}
[HarmonyPostfix]
[HarmonyPatch(typeof(GameNetworkManager), "SetInstanceValuesBackToDefault")]
public static void SetInstanceValuesBackToDefault()
{
if (!((Object)(object)NetworkManager.Singleton == (Object)null) && NetworkManager.Singleton.CustomMessagingManager != null)
{
BagConfig.Log.LogInfo((object)"Unregistering Named Messages!");
NamedMessages.UnregisterNamedMessages();
}
}
[HarmonyPostfix]
[HarmonyPatch(typeof(NetworkManager), "SetSingleton")]
private static void RegisterPrefab()
{
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: Expected O, but got Unknown
//IL_001a: 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)
if (!PluginConfig.Host.AllowVanilla.Value)
{
GameObject val = new GameObject("BagConfig Prefab");
((Object)val).hideFlags = (HideFlags)(((Object)val).hideFlags | 0x3D);
Object.DontDestroyOnLoad((Object)(object)val);
NetworkObject val2 = val.AddComponent<NetworkObject>();
val2.GlobalObjectIdHash = GetHash("mattymatty.BagConfig");
NetworkManager.Singleton.PrefabHandler.AddNetworkPrefab(val);
}
static uint GetHash(string value)
{
return value?.Aggregate(17u, (uint current, char c) => (current * 31) ^ c) ?? 0;
}
}
}
internal static class PatchLateJoin
{
private static uint _tryAddObjectToBagClientRpc;
internal static void Init()
{
MethodInfo methodInfo = AccessTools.Method(typeof(BeltBagItem), "TryAddObjectToBagClientRpc", (Type[])null, (Type[])null);
if (!methodInfo.TryGetRpcID(out _tryAddObjectToBagClientRpc))
{
throw new MissingMemberException("BeltBagItem", "TryAddObjectToBagClientRpc");
}
}
[HarmonyPostfix]
[HarmonyPatch(typeof(StartOfRound), "SyncAlreadyHeldObjectsClientRpc")]
private static void SyncItemsInBags(StartOfRound __instance, NetworkObjectReference[] gObjects, int joiningClientId)
{
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_0020: Invalid comparison between Unknown and I4
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
//IL_0084: Unknown result type (might be due to invalid IL or missing references)
//IL_0089: 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_0097: Unknown result type (might be due to invalid IL or missing references)
//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
//IL_00bd: 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_00c5: Unknown result type (might be due to invalid IL or missing references)
//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
//IL_00d3: 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)
//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
NetworkManager networkManager = ((NetworkBehaviour)__instance).NetworkManager;
if ((Object)(object)networkManager == (Object)null || !networkManager.IsListening || (int)((NetworkBehaviour)__instance).__rpc_exec_stage == 2 || (!networkManager.IsServer && !networkManager.IsHost))
{
return;
}
NetworkObject val2 = default(NetworkObject);
BeltBagItem val3 = default(BeltBagItem);
for (int i = 0; i < gObjects.Length; i++)
{
NetworkObjectReference val = gObjects[i];
if (!((NetworkObjectReference)(ref val)).TryGet(ref val2, (NetworkManager)null) || !((Component)val2).TryGetComponent<BeltBagItem>(ref val3))
{
continue;
}
foreach (GrabbableObject item in val3.objectsInBag)
{
NetworkObjectReference val4 = NetworkObjectReference.op_Implicit(((NetworkBehaviour)item).NetworkObject);
ClientRpcParams val5 = default(ClientRpcParams);
val5.Send = new ClientRpcSendParams
{
TargetClientIds = new <>z__ReadOnlySingleElementList<ulong>((ulong)joiningClientId)
};
ClientRpcParams val6 = val5;
FastBufferWriter val7 = ((NetworkBehaviour)val3).__beginSendClientRpc(_tryAddObjectToBagClientRpc, val6, (RpcDelivery)0);
((FastBufferWriter)(ref val7)).WriteValueSafe<NetworkObjectReference>(ref val4, default(ForNetworkSerializable));
BytePacker.WriteValueBitPacked(val7, ((GrabbableObject)val3).playerHeldBy.actualClientId);
((NetworkBehaviour)val3).__endSendClientRpc(ref val7, _tryAddObjectToBagClientRpc, val6, (RpcDelivery)0);
}
}
}
}
}
namespace BagConfig.Networking
{
internal static class NamedMessages
{
[CompilerGenerated]
private static class <>O
{
public static HandleNamedMessageDelegate <0>__OnHostPresentClientRpc;
public static HandleNamedMessageDelegate <1>__OnFixBagsClientRpc;
}
private static readonly string BaseName = typeof(NamedMessages).FullName;
private static readonly string HostPresentClientRpcMessage = BaseName + "|HostPresentClientRpc";
private static readonly string FixBagsClientRpcMessage = BaseName + "|FixBagsClientRpc";
internal static void RegisterNamedMessages()
{
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Expected O, but got Unknown
//IL_004e: 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_0059: Expected O, but got Unknown
CustomMessagingManager customMessagingManager = NetworkManager.Singleton.CustomMessagingManager;
string hostPresentClientRpcMessage = HostPresentClientRpcMessage;
object obj = <>O.<0>__OnHostPresentClientRpc;
if (obj == null)
{
HandleNamedMessageDelegate val = OnHostPresentClientRpc;
<>O.<0>__OnHostPresentClientRpc = val;
obj = (object)val;
}
customMessagingManager.RegisterNamedMessageHandler(hostPresentClientRpcMessage, (HandleNamedMessageDelegate)obj);
CustomMessagingManager customMessagingManager2 = NetworkManager.Singleton.CustomMessagingManager;
string fixBagsClientRpcMessage = FixBagsClientRpcMessage;
object obj2 = <>O.<1>__OnFixBagsClientRpc;
if (obj2 == null)
{
HandleNamedMessageDelegate val2 = OnFixBagsClientRpc;
<>O.<1>__OnFixBagsClientRpc = val2;
obj2 = (object)val2;
}
customMessagingManager2.RegisterNamedMessageHandler(fixBagsClientRpcMessage, (HandleNamedMessageDelegate)obj2);
}
internal static void UnregisterNamedMessages()
{
NetworkManager.Singleton.CustomMessagingManager.UnregisterNamedMessageHandler(HostPresentClientRpcMessage);
NetworkManager.Singleton.CustomMessagingManager.UnregisterNamedMessageHandler(FixBagsClientRpcMessage);
}
internal static void HostPresentClientRpc(IReadOnlyList<ulong> targets = null)
{
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
if (NetworkManager.Singleton.IsServer)
{
FastBufferWriter val = default(FastBufferWriter);
((FastBufferWriter)(ref val))..ctor(0, (Allocator)2, -1);
if (targets == null)
{
NetworkManager.Singleton.CustomMessagingManager.SendNamedMessageToAll(HostPresentClientRpcMessage, val, (NetworkDelivery)3);
}
else
{
NetworkManager.Singleton.CustomMessagingManager.SendNamedMessage(HostPresentClientRpcMessage, targets, val, (NetworkDelivery)3);
}
}
}
private static void OnHostPresentClientRpc(ulong senderId, FastBufferReader data)
{
if (senderId == 0L)
{
BeltBagPatch.Enabled = true;
}
}
internal static void FixBagsClientRpc(IReadOnlyList<ulong> targets = null)
{
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
if (NetworkManager.Singleton.IsServer)
{
FastBufferWriter val = default(FastBufferWriter);
((FastBufferWriter)(ref val))..ctor(0, (Allocator)2, -1);
if (targets == null)
{
NetworkManager.Singleton.CustomMessagingManager.SendNamedMessageToAll(FixBagsClientRpcMessage, val, (NetworkDelivery)3);
}
else
{
NetworkManager.Singleton.CustomMessagingManager.SendNamedMessage(FixBagsClientRpcMessage, targets, val, (NetworkDelivery)3);
}
}
}
private static void OnFixBagsClientRpc(ulong senderId, FastBufferReader data)
{
if (senderId == 0L && !((Object)(object)StartOfRound.Instance == (Object)null))
{
BagConfig.Log.LogWarning((object)"Host requested all beltBags to be freed!");
BeltBagItem[] array = Object.FindObjectsByType<BeltBagItem>((FindObjectsInactive)1, (FindObjectsSortMode)0);
BeltBagItem[] array2 = array;
foreach (BeltBagItem val in array2)
{
BagConfig.Log.LogDebug((object)$"Fixing status of 0x{((NetworkBehaviour)val).NetworkObjectId:X}, was: {val.tryingAddToBag}");
val.tryingAddToBag = false;
val.tryingCheckBag = false;
}
}
}
}
}
namespace BagConfig.InputUtils
{
public class BagInputs : LcInputActions
{
public static BagInputs Instance { get; }
[InputAction(/*Could not decode attribute arguments.*/)]
public InputAction DropAll { get; set; }
[InputAction(/*Could not decode attribute arguments.*/)]
public InputAction GrabOne { get; set; }
static BagInputs()
{
Instance = new BagInputs();
Instance.DropAll.performed += delegate
{
if (BeltBagPatch.Enabled && TryGetBeltBag(out var beltBag3))
{
BeltBagPatch.TryDumpItems(beltBag3);
}
static bool TryGetBeltBag(out BeltBagItem beltBag)
{
beltBag = null;
GameNetworkManager instance = GameNetworkManager.Instance;
if ((Object)(object)instance == (Object)null)
{
return false;
}
GrabbableObject currentlyHeldObjectServer = instance.localPlayerController.currentlyHeldObjectServer;
BeltBagItem val = (BeltBagItem)(object)((currentlyHeldObjectServer is BeltBagItem) ? currentlyHeldObjectServer : null);
if (val == null)
{
return false;
}
beltBag = val;
return true;
}
};
Instance.GrabOne.performed += delegate
{
if (BeltBagPatch.Enabled && BagInputs.<.cctor>g__TryGetBeltBag|0_2(out BeltBagItem beltBag2))
{
BeltBagPatch.TryGrabItem(beltBag2);
}
};
}
}
}
namespace BagConfig.Dependency
{
public static class InputUtilsProxy
{
private static bool? _enabled;
public static bool Enabled
{
get
{
bool valueOrDefault = _enabled.GetValueOrDefault();
if (!_enabled.HasValue)
{
valueOrDefault = Chainloader.PluginInfos.ContainsKey("com.rune580.LethalCompanyInputUtils");
_enabled = valueOrDefault;
}
return _enabled.Value;
}
}
[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
internal static void Init()
{
if (Enabled)
{
_ = BagInputs.Instance;
}
}
}
public static class LethalConfigProxy
{
public struct CanModifyResult
{
public readonly bool CanModify;
public readonly string Reason;
public CanModifyResult(bool canModify, string reason)
{
CanModify = canModify;
Reason = reason;
}
public static implicit operator CanModifyResult((bool result, string reason) tuple)
{
return new CanModifyResult(tuple.result, tuple.reason);
}
public static implicit operator (bool result, string reason)(CanModifyResult result)
{
return (result.CanModify, result.Reason);
}
}
public delegate CanModifyResult CanModifyDelegate();
private static bool? _enabled;
public static bool Enabled
{
get
{
bool valueOrDefault = _enabled.GetValueOrDefault();
if (!_enabled.HasValue)
{
valueOrDefault = Chainloader.PluginInfos.ContainsKey("ainavt.lc.lethalconfig");
_enabled = valueOrDefault;
}
return _enabled.Value;
}
}
[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
public static void AddConfig(ConfigEntry<string> entry, bool requiresRestart = false)
{
//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_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Expected O, but got Unknown
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
//IL_0023: Expected O, but got Unknown
LethalConfigManager.AddConfigItem((BaseConfigItem)new TextInputFieldConfigItem(entry, new TextInputFieldOptions
{
RequiresRestart = requiresRestart,
Name = GetPrettyConfigName<string>(entry)
}));
}
[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
public static void AddConfig(ConfigEntry<bool> entry, bool requiresRestart = false)
{
//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_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Expected O, but got Unknown
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
//IL_0023: Expected O, but got Unknown
LethalConfigManager.AddConfigItem((BaseConfigItem)new BoolCheckBoxConfigItem(entry, new BoolCheckBoxOptions
{
RequiresRestart = requiresRestart,
Name = GetPrettyConfigName<bool>(entry)
}));
}
[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
public static void AddConfig(ConfigEntry<float> entry, bool requiresRestart = false)
{
//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_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Expected O, but got Unknown
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
//IL_0023: Expected O, but got Unknown
LethalConfigManager.AddConfigItem((BaseConfigItem)new FloatInputFieldConfigItem(entry, new FloatInputFieldOptions
{
RequiresRestart = requiresRestart,
Name = GetPrettyConfigName<float>(entry)
}));
}
[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
public static void AddConfig(ConfigEntry<int> entry, bool requiresRestart = false)
{
//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_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Expected O, but got Unknown
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
//IL_0023: Expected O, but got Unknown
LethalConfigManager.AddConfigItem((BaseConfigItem)new IntInputFieldConfigItem(entry, new IntInputFieldOptions
{
RequiresRestart = requiresRestart,
Name = GetPrettyConfigName<int>(entry)
}));
}
[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
public static void AddButton(string section, string name, string description, string buttonText, Action callback, CanModifyDelegate canModify = null)
{
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
//IL_002b: Expected O, but got Unknown
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_002c: Expected O, but got Unknown
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
//IL_004b: Expected O, but got Unknown
GenericButtonConfigItem val = new GenericButtonConfigItem(section, name, description, buttonText, (GenericButtonHandler)delegate
{
callback?.Invoke();
});
if (canModify != null)
{
((BaseOptions)val.ButtonOptions).CanModifyCallback = (CanModifyDelegate)(() => CanModifyResult.op_Implicit(((bool result, string reason))canModify()));
}
LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val);
}
private static string GetPrettyConfigName<T>(ConfigEntry<T> entry)
{
return CultureInfo.InvariantCulture.TextInfo.ToTitleCase(((ConfigEntryBase)entry).Definition.Key.Replace("_", " "));
}
}
public static class LobbyCompatibilityChecker
{
private static bool? _enabled;
public static bool Enabled
{
get
{
bool valueOrDefault = _enabled.GetValueOrDefault();
if (!_enabled.HasValue)
{
valueOrDefault = Chainloader.PluginInfos.ContainsKey("BMX.LobbyCompatibility");
_enabled = valueOrDefault;
}
return _enabled.Value;
}
}
[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
public static void Init()
{
PluginHelper.RegisterPlugin("mattymatty.BagConfig", Version.Parse("1.0.3"), (CompatibilityLevel)0, (VersionStrictness)2);
}
}
}
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
internal sealed class IgnoresAccessChecksToAttribute : Attribute
{
public IgnoresAccessChecksToAttribute(string assemblyName)
{
}
}
}
[CompilerGenerated]
internal sealed class <>z__ReadOnlySingleElementList<T> : IEnumerable, ICollection, IList, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, ICollection<T>, IList<T>
{
private sealed class Enumerator : IDisposable, IEnumerator, IEnumerator<T>
{
object IEnumerator.Current => _item;
T IEnumerator<T>.Current => _item;
public Enumerator(T item)
{
_item = item;
}
bool IEnumerator.MoveNext()
{
if (!_moveNextCalled)
{
return _moveNextCalled = true;
}
return false;
}
void IEnumerator.Reset()
{
_moveNextCalled = false;
}
void IDisposable.Dispose()
{
}
}
int ICollection.Count => 1;
bool ICollection.IsSynchronized => false;
object ICollection.SyncRoot => this;
object IList.this[int index]
{
get
{
if (index != 0)
{
throw new IndexOutOfRangeException();
}
return _item;
}
set
{
throw new NotSupportedException();
}
}
bool IList.IsFixedSize => true;
bool IList.IsReadOnly => true;
int IReadOnlyCollection<T>.Count => 1;
T IReadOnlyList<T>.this[int index]
{
get
{
if (index != 0)
{
throw new IndexOutOfRangeException();
}
return _item;
}
}
int ICollection<T>.Count => 1;
bool ICollection<T>.IsReadOnly => true;
T IList<T>.this[int index]
{
get
{
if (index != 0)
{
throw new IndexOutOfRangeException();
}
return _item;
}
set
{
throw new NotSupportedException();
}
}
public <>z__ReadOnlySingleElementList(T item)
{
_item = item;
}
IEnumerator IEnumerable.GetEnumerator()
{
return new Enumerator(_item);
}
void ICollection.CopyTo(Array array, int index)
{
array.SetValue(_item, index);
}
int IList.Add(object value)
{
throw new NotSupportedException();
}
void IList.Clear()
{
throw new NotSupportedException();
}
bool IList.Contains(object value)
{
return EqualityComparer<T>.Default.Equals(_item, (T)value);
}
int IList.IndexOf(object value)
{
if (!EqualityComparer<T>.Default.Equals(_item, (T)value))
{
return -1;
}
return 0;
}
void IList.Insert(int index, object value)
{
throw new NotSupportedException();
}
void IList.Remove(object value)
{
throw new NotSupportedException();
}
void IList.RemoveAt(int index)
{
throw new NotSupportedException();
}
IEnumerator<T> IEnumerable<T>.GetEnumerator()
{
return new Enumerator(_item);
}
void ICollection<T>.Add(T item)
{
throw new NotSupportedException();
}
void ICollection<T>.Clear()
{
throw new NotSupportedException();
}
bool ICollection<T>.Contains(T item)
{
return EqualityComparer<T>.Default.Equals(_item, item);
}
void ICollection<T>.CopyTo(T[] array, int arrayIndex)
{
array[arrayIndex] = _item;
}
bool ICollection<T>.Remove(T item)
{
throw new NotSupportedException();
}
int IList<T>.IndexOf(T item)
{
if (!EqualityComparer<T>.Default.Equals(_item, item))
{
return -1;
}
return 0;
}
void IList<T>.Insert(int index, T item)
{
throw new NotSupportedException();
}
void IList<T>.RemoveAt(int index)
{
throw new NotSupportedException();
}
}
