using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Logging;
using HarmonyLib;
using LobbyCompatibility.Enums;
using LobbyCompatibility.Features;
using Microsoft.CodeAnalysis;
using TooManyItems.Dependency;
using TooManyItems.Patches;
using Unity.Collections;
using Unity.Netcode;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: IgnoresAccessChecksTo("Unity.Netcode.Components")]
[assembly: IgnoresAccessChecksTo("Unity.Netcode.Runtime")]
[assembly: AssemblyCompany("TooManyItems")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.4.1.0")]
[assembly: AssemblyInformationalVersion("1.4.1+4a764036dce782dcccc577a698a4a188cdf4c9ea")]
[assembly: AssemblyProduct("Too Many Items")]
[assembly: AssemblyTitle("TooManyItems")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.4.1.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 TooManyItems
{
[BepInPlugin("mattymatty.TooManyItems", "TooManyItems", "1.4.1")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
internal class TooManyItems : BaseUnityPlugin
{
public const string GUID = "mattymatty.TooManyItems";
public const string NAME = "TooManyItems";
public const string VERSION = "1.4.1";
internal static ManualLogSource Log;
private void Awake()
{
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Expected O, but got Unknown
Log = ((BaseUnityPlugin)this).Logger;
try
{
if (LobbyCompatibilityChecker.Enabled)
{
LobbyCompatibilityChecker.Init();
}
Log.LogInfo((object)"Patching Methods");
Harmony val = new Harmony("mattymatty.TooManyItems");
if (!Chainloader.PluginInfos.ContainsKey("mattymatty.LobbyControl"))
{
val.PatchAll(typeof(LimitPatcher));
}
if (!Chainloader.PluginInfos.ContainsKey("mattymatty.MattyFixes"))
{
val.PatchAll(typeof(RadarPatch));
val.PatchAll(typeof(OutOfBoundsItemsFix));
val.PatchAll(typeof(RehostItemFixes));
}
Log.LogInfo((object)"TooManyItems v1.4.1 Loaded!");
}
catch (Exception ex)
{
Log.LogError((object)("Exception while initializing: \n" + ex));
}
}
}
}
namespace TooManyItems.Patches
{
[HarmonyPatch]
internal class LimitPatcher
{
[HarmonyTranspiler]
[HarmonyPatch(typeof(StartOfRound), "SyncShipUnlockablesClientRpc")]
private static IEnumerable<CodeInstruction> PacketSizePatch(IEnumerable<CodeInstruction> instructions)
{
//IL_005d: Unknown result type (might be due to invalid IL or missing references)
//IL_0063: Expected O, but got Unknown
//IL_0079: Unknown result type (might be due to invalid IL or missing references)
//IL_007f: Expected O, but got Unknown
//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
//IL_00d5: Expected O, but got Unknown
//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
//IL_00ec: Expected O, but got Unknown
//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
//IL_00fa: Expected O, but got Unknown
//IL_010b: Unknown result type (might be due to invalid IL or missing references)
//IL_0111: Expected O, but got Unknown
//IL_0119: Unknown result type (might be due to invalid IL or missing references)
//IL_011f: Expected O, but got Unknown
MethodInfo method = typeof(NetworkBehaviour).GetMethod("__beginSendClientRpc", BindingFlags.Instance | BindingFlags.NonPublic);
ConstructorInfo constructor = typeof(FastBufferWriter).GetConstructor(new Type[3]
{
typeof(int),
typeof(Allocator),
typeof(int)
});
List<CodeInstruction> list = instructions.ToList();
CodeMatcher val = new CodeMatcher((IEnumerable<CodeInstruction>)list, (ILGenerator)null);
val.MatchForward(true, (CodeMatch[])(object)new CodeMatch[1]
{
new CodeMatch((OpCode?)OpCodes.Call, (object)method, (string)null)
});
if (val.IsInvalid)
{
TooManyItems.Log.LogWarning((object)"PacketSize patch failed 1!!");
TooManyItems.Log.LogDebug((object)string.Join("\n", val.Instructions()));
return list;
}
val.Advance(1);
val.Insert((CodeInstruction[])(object)new CodeInstruction[5]
{
new CodeInstruction(OpCodes.Pop, (object)null),
new CodeInstruction(OpCodes.Ldc_I4, (object)1024),
new CodeInstruction(OpCodes.Ldc_I4_2, (object)null),
new CodeInstruction(OpCodes.Ldc_I4, (object)int.MaxValue),
new CodeInstruction(OpCodes.Newobj, (object)constructor)
});
TooManyItems.Log.LogDebug((object)"Patched PacketSize!");
return val.Instructions();
}
[HarmonyTranspiler]
[HarmonyPriority(800)]
[HarmonyPatch(typeof(StartOfRound), "SyncShipUnlockablesServerRpc")]
private static IEnumerable<CodeInstruction> SyncUnlockablesPatch(IEnumerable<CodeInstruction> instructions)
{
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: Expected O, but got Unknown
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
//IL_0047: Expected O, but got Unknown
//IL_0096: Unknown result type (might be due to invalid IL or missing references)
//IL_009c: 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_00be: Unknown result type (might be due to invalid IL or missing references)
//IL_00c4: Expected O, but got Unknown
MethodInfo method = typeof(GrabbableObject).GetMethod("GetItemDataToSave");
List<CodeInstruction> list = instructions.ToList();
CodeMatcher val = new CodeMatcher((IEnumerable<CodeInstruction>)list, (ILGenerator)null);
val.End();
val.MatchBack(false, (CodeMatch[])(object)new CodeMatch[1]
{
new CodeMatch((OpCode?)OpCodes.Callvirt, (object)method, (string)null)
});
if (val.IsInvalid)
{
TooManyItems.Log.LogWarning((object)"SyncShipUnlockablesServerRpc patch failed 1!!");
TooManyItems.Log.LogDebug((object)string.Join("\n", val.Instructions()));
return list;
}
val.MatchBack(false, (CodeMatch[])(object)new CodeMatch[3]
{
new CodeMatch((OpCode?)OpCodes.Ldloc_S, (object)null, (string)null),
new CodeMatch((OpCode?)OpCodes.Ldc_I4, (object)null, (string)null),
new CodeMatch((OpCode?)OpCodes.Ble, (object)null, (string)null)
});
if (val.IsInvalid)
{
TooManyItems.Log.LogWarning((object)"SyncShipUnlockablesServerRpc patch failed 2!!");
TooManyItems.Log.LogDebug((object)string.Join("\n", val.Instructions()));
return list;
}
List<Label> labels = val.Labels;
val.RemoveInstructions(6);
val.AddLabels((IEnumerable<Label>)labels);
TooManyItems.Log.LogDebug((object)"Patched SyncShipUnlockablesServerRpc!!");
return val.Instructions();
}
[HarmonyTranspiler]
[HarmonyPriority(800)]
[HarmonyPatch(typeof(GameNetworkManager), "SaveItemsInShip")]
private static IEnumerable<CodeInstruction> SaveItemsInShipPatch(IEnumerable<CodeInstruction> instructions)
{
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
//IL_003e: Expected O, but got Unknown
//IL_0054: Unknown result type (might be due to invalid IL or missing references)
//IL_005a: Expected O, but got Unknown
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
//IL_006e: Expected O, but got Unknown
//IL_007c: Unknown result type (might be due to invalid IL or missing references)
//IL_0082: Expected O, but got Unknown
//IL_0090: Unknown result type (might be due to invalid IL or missing references)
//IL_0096: Expected O, but got Unknown
FieldInfo field = typeof(StartOfRound).GetField("maxShipItemCapacity");
MethodInfo getMethod = typeof(StartOfRound).GetProperty("Instance").GetMethod;
List<CodeInstruction> list = instructions.ToList();
CodeMatcher val = new CodeMatcher((IEnumerable<CodeInstruction>)list, (ILGenerator)null);
val.MatchForward(false, (CodeMatch[])(object)new CodeMatch[4]
{
new CodeMatch((OpCode?)OpCodes.Ldloc_S, (object)null, (string)null),
new CodeMatch((OpCode?)OpCodes.Call, (object)getMethod, (string)null),
new CodeMatch((OpCode?)OpCodes.Ldfld, (object)field, (string)null),
new CodeMatch((OpCode?)OpCodes.Bgt, (object)null, (string)null)
});
if (val.IsInvalid)
{
TooManyItems.Log.LogWarning((object)"SaveItemsInShip patch failed 1!!");
TooManyItems.Log.LogDebug((object)string.Join("\n", val.Instructions()));
return list;
}
List<Label> labels = val.Labels;
val.RemoveInstructions(4);
val.AddLabels((IEnumerable<Label>)labels);
TooManyItems.Log.LogDebug((object)"Patched SaveItemsInShip!!");
return val.Instructions();
}
}
[HarmonyPatch]
internal class OutOfBoundsItemsFix
{
internal static bool IsInitializingGame;
[HarmonyPrefix]
[HarmonyPatch(typeof(StartOfRound), "Start")]
private static void MarkServerStart(StartOfRound __instance)
{
IsInitializingGame = true;
((MonoBehaviour)__instance).StartCoroutine(WaitCoupleOfFrames());
}
private static IEnumerator WaitCoupleOfFrames()
{
yield return (object)new WaitForEndOfFrame();
yield return (object)new WaitForEndOfFrame();
yield return (object)new WaitForEndOfFrame();
IsInitializingGame = false;
}
[HarmonyTranspiler]
[HarmonyPatch(typeof(GrabbableObject), "Start")]
private static IEnumerable<CodeInstruction> RedirectSpawnOnGroundCheck(IEnumerable<CodeInstruction> instructions)
{
//IL_004a: Unknown result type (might be due to invalid IL or missing references)
//IL_0051: Expected O, but got Unknown
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
//IL_006e: Expected O, but got Unknown
//IL_007c: Unknown result type (might be due to invalid IL or missing references)
//IL_0082: Expected O, but got Unknown
//IL_0090: Unknown result type (might be due to invalid IL or missing references)
//IL_0096: Expected O, but got Unknown
//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
//IL_00aa: Expected O, but got Unknown
//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
//IL_00e3: Expected O, but got Unknown
List<CodeInstruction> list = instructions.ToList();
FieldInfo fieldInfo = AccessTools.Field(typeof(GrabbableObject), "itemProperties");
FieldInfo fieldInfo2 = AccessTools.Field(typeof(Item), "itemSpawnsOnGround");
MethodInfo methodInfo = AccessTools.Method(typeof(OutOfBoundsItemsFix), "NewSpawnOnGroundCheck", (Type[])null, (Type[])null);
CodeMatcher val = new CodeMatcher((IEnumerable<CodeInstruction>)list, (ILGenerator)null);
val.MatchForward(false, (CodeMatch[])(object)new CodeMatch[4]
{
new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null),
new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo, (string)null),
new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo2, (string)null),
new CodeMatch((OpCode?)OpCodes.Brfalse, (object)null, (string)null)
});
if (val.IsInvalid)
{
return list;
}
val.Advance(1);
val.RemoveInstructions(2);
val.Insert((CodeInstruction[])(object)new CodeInstruction[1]
{
new CodeInstruction(OpCodes.Call, (object)methodInfo)
});
TooManyItems.Log.LogDebug((object)"GrabbableObject.Start patched!");
return val.Instructions();
}
private static bool NewSpawnOnGroundCheck(GrabbableObject grabbableObject)
{
bool itemSpawnsOnGround = grabbableObject.itemProperties.itemSpawnsOnGround;
if (grabbableObject is ClipboardItem || (grabbableObject is PhysicsProp && grabbableObject.itemProperties.itemName == "Sticky note"))
{
return itemSpawnsOnGround;
}
if (Object.op_Implicit((Object)(object)StartOfRound.Instance.localPlayerController) && !IsInitializingGame)
{
return itemSpawnsOnGround;
}
return ((NetworkBehaviour)StartOfRound.Instance).IsServer;
}
[HarmonyPostfix]
[HarmonyPatch(typeof(StartOfRound), "LoadUnlockables")]
private static void CorrectlyPlaceAllUnlockables(StartOfRound __instance)
{
AutoParentToShip[] array = Object.FindObjectsOfType<AutoParentToShip>();
foreach (AutoParentToShip val in array)
{
val.MoveToOffset();
}
Physics.SyncTransforms();
}
[HarmonyTranspiler]
[HarmonyPatch(typeof(GameNetworkManager), "SaveItemsInShip")]
private static IEnumerable<CodeInstruction> SaveItemsCorrectly(IEnumerable<CodeInstruction> instructions, ILGenerator ilGenerator)
{
//IL_0054: Unknown result type (might be due to invalid IL or missing references)
//IL_005b: Expected O, but got Unknown
//IL_0072: Unknown result type (might be due to invalid IL or missing references)
//IL_0078: Expected O, but got Unknown
//IL_0086: Unknown result type (might be due to invalid IL or missing references)
//IL_008c: Expected O, but got Unknown
//IL_009a: Unknown result type (might be due to invalid IL or missing references)
//IL_00a0: Expected O, but got Unknown
//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
//IL_00b4: Expected O, but got Unknown
//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
//IL_00c8: Expected O, but got Unknown
//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
//IL_00dc: Expected O, but got Unknown
//IL_012a: Unknown result type (might be due to invalid IL or missing references)
//IL_0130: Expected O, but got Unknown
//IL_014f: Unknown result type (might be due to invalid IL or missing references)
//IL_0155: Expected O, but got Unknown
List<CodeInstruction> list = instructions.ToList();
MethodInfo methodInfo = AccessTools.Method(typeof(OutOfBoundsItemsFix), "ApplyVerticalOffset", (Type[])null, (Type[])null);
MethodInfo getMethod = AccessTools.Property(typeof(Component), "transform").GetMethod;
MethodInfo getMethod2 = AccessTools.Property(typeof(Transform), "position").GetMethod;
CodeMatcher val = new CodeMatcher((IEnumerable<CodeInstruction>)list, ilGenerator);
val.MatchForward(false, (CodeMatch[])(object)new CodeMatch[6]
{
new CodeMatch((OpCode?)OpCodes.Ldloc_2, (object)null, (string)null),
new CodeMatch((OpCode?)OpCodes.Ldloc_0, (object)null, (string)null),
new CodeMatch((OpCode?)OpCodes.Ldloc_S, (object)null, (string)null),
new CodeMatch((OpCode?)OpCodes.Ldelem_Ref, (object)null, (string)null),
new CodeMatch((OpCode?)OpCodes.Callvirt, (object)getMethod, (string)null),
new CodeMatch((OpCode?)OpCodes.Callvirt, (object)getMethod2, (string)null)
});
if (val.IsInvalid)
{
TooManyItems.Log.LogError((object)"Cannot patch SaveItemsInShip");
TooManyItems.Log.LogDebug((object)string.Join("\n", list));
return list;
}
val.Advance(4);
val.Insert((CodeInstruction[])(object)new CodeInstruction[1]
{
new CodeInstruction(OpCodes.Dup, (object)null)
});
val.Advance(3);
val.Insert((CodeInstruction[])(object)new CodeInstruction[1]
{
new CodeInstruction(OpCodes.Call, (object)methodInfo)
});
TooManyItems.Log.LogDebug((object)"SaveItemsInShip Patched");
return val.Instructions();
}
private static Vector3 ApplyVerticalOffset(GrabbableObject grabbable, Vector3 position)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0023: 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_0034: Unknown result type (might be due to invalid IL or missing references)
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
//IL_003f: Unknown result type (might be due to invalid IL or missing references)
//IL_0040: 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_0054: 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_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
Vector3 val = position;
if (grabbable.isHeld || grabbable.isHeldByEnemy)
{
return position;
}
if (!grabbable.hasHitGround)
{
val = grabbable.targetFloorPosition;
}
val += Vector3.down * grabbable.itemProperties.verticalOffset;
return val + Vector3.up * 0.01f;
}
}
[HarmonyPatch]
internal class RadarPatch
{
[HarmonyPatch]
internal class ItemInShipPatch
{
[HarmonyPostfix]
[HarmonyPatch(typeof(GrabbableObject), "LateUpdate")]
[HarmonyPriority(0)]
private static void UpdatePatch(GrabbableObject __instance, bool __runOriginal)
{
if (__runOriginal && __instance.isInShipRoom && (Object)(object)__instance.radarIcon != (Object)null)
{
Object.Destroy((Object)(object)((Component)__instance.radarIcon).gameObject);
}
}
}
[HarmonyPatch]
internal class DeletedObjectPatch
{
[HarmonyPrefix]
[HarmonyPatch(typeof(NetworkBehaviour), "OnDestroy")]
private static void DestroyPatch(NetworkBehaviour __instance)
{
GrabbableObject val = (GrabbableObject)(object)((__instance is GrabbableObject) ? __instance : null);
if ((Object)(object)val != (Object)null && (Object)(object)val.radarIcon != (Object)null && (Object)(object)((Component)val.radarIcon).gameObject != (Object)null)
{
Object.Destroy((Object)(object)((Component)val.radarIcon).gameObject);
}
}
}
}
[HarmonyPatch]
internal class RehostItemFixes
{
[HarmonyPostfix]
[HarmonyPatch(typeof(NetworkBehaviour), "OnNetworkSpawn")]
[HarmonyPriority(20)]
private static void SpawnPostfix(NetworkBehaviour __instance)
{
GrabbableObject val = (GrabbableObject)(object)((__instance is GrabbableObject) ? __instance : null);
if (val == null || val is ClipboardItem || (val is PhysicsProp && val.itemProperties.itemName == "Sticky note") || (Object.op_Implicit((Object)(object)StartOfRound.Instance.localPlayerController) && !OutOfBoundsItemsFix.IsInitializingGame))
{
return;
}
val.isInElevator = true;
val.isInShipRoom = true;
LungProp val2 = (LungProp)(object)((val is LungProp) ? val : null);
if (val2 != null)
{
val2.isLungDocked = false;
val2.isLungPowered = false;
val2.isLungDockedInElevator = false;
AudioSource component = ((Component)val2).GetComponent<AudioSource>();
if (component != null)
{
component.Stop();
}
}
}
}
}
namespace TooManyItems.Dependency
{
public static class LobbyCompatibilityChecker
{
public static bool Enabled => Chainloader.PluginInfos.ContainsKey("BMX.LobbyCompatibility");
[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
public static void Init()
{
PluginHelper.RegisterPlugin("mattymatty.TooManyItems", Version.Parse("1.4.1"), (CompatibilityLevel)1, (VersionStrictness)0);
}
}
}
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
internal sealed class IgnoresAccessChecksToAttribute : Attribute
{
public IgnoresAccessChecksToAttribute(string assemblyName)
{
}
}
}
