using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using MicroOptimizer.Patches;
using Microsoft.CodeAnalysis;
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: AssemblyCompany("MicroOptimizer")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("Micro-optimizations for smoother gameplay")]
[assembly: AssemblyFileVersion("1.0.4.0")]
[assembly: AssemblyInformationalVersion("1.0.4")]
[assembly: AssemblyProduct("MicroOptimizer")]
[assembly: AssemblyTitle("MicroOptimizer")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.4.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 MicroOptimizer
{
[BepInPlugin("mrbub.microoptimizer", "MicroOptimizer", "1.0.4")]
public class Plugin : BaseUnityPlugin
{
internal static ManualLogSource Logger;
internal static ConfigFile ConfigFile;
internal static ConfigEntry<bool> OptimizeStringAllocations;
internal static ConfigEntry<bool> CacheRepeatedLookups;
internal static ConfigEntry<bool> OptimizeShipItemCollection;
internal static ConfigEntry<bool> EnableDebugLogging;
private void Awake()
{
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
//IL_0027: Expected O, but got Unknown
Logger = ((BaseUnityPlugin)this).Logger;
ConfigFile = ((BaseUnityPlugin)this).Config;
InitializeConfig();
Harmony val = new Harmony("mrbub.microoptimizer");
if (OptimizeStringAllocations.Value)
{
val.PatchAll(typeof(StringOptimizationPatches));
Logger.LogInfo((object)"String allocation optimization enabled");
}
if (CacheRepeatedLookups.Value)
{
val.PatchAll(typeof(ComponentLookupPatches));
Logger.LogInfo((object)"Component lookup caching enabled");
}
if (OptimizeShipItemCollection.Value)
{
val.PatchAll(typeof(ShipItemOptimizationPatches));
Logger.LogInfo((object)"Ship item collection optimization enabled");
}
Logger.LogInfo((object)"MicroOptimizer v1.0.4 loaded successfully!");
}
private void InitializeConfig()
{
EnableDebugLogging = ((BaseUnityPlugin)this).Config.Bind<bool>("Debug", "EnableDebugLogging", false, "Enable detailed logging for debugging (creates more log spam)");
OptimizeStringAllocations = ((BaseUnityPlugin)this).Config.Bind<bool>("Strings", "OptimizeStringAllocations", true, "Use StringBuilder for string formatting to reduce allocations");
CacheRepeatedLookups = ((BaseUnityPlugin)this).Config.Bind<bool>("Caching", "CacheRepeatedLookups", true, "Cache NetworkObject lookups during enemy and scrap spawning");
OptimizeShipItemCollection = ((BaseUnityPlugin)this).Config.Bind<bool>("Optimization", "OptimizeShipItemCollection", true, "Use HashSet instead of List.Contains() for O(1) scrap collection lookups");
}
}
public static class PluginInfo
{
public const string PLUGIN_GUID = "mrbub.microoptimizer";
public const string PLUGIN_NAME = "MicroOptimizer";
public const string PLUGIN_VERSION = "1.0.4";
}
}
namespace MicroOptimizer.Patches
{
[HarmonyPatch]
internal class CollisionCachePatches
{
private static readonly Dictionary<GameObject, PlayerControllerB> playerControllerCache = new Dictionary<GameObject, PlayerControllerB>();
public static PlayerControllerB GetCachedPlayerController(GameObject gameObject)
{
if ((Object)(object)gameObject == (Object)null)
{
return null;
}
if (!playerControllerCache.TryGetValue(gameObject, out var value))
{
value = gameObject.GetComponent<PlayerControllerB>();
if ((Object)(object)value != (Object)null)
{
playerControllerCache[gameObject] = value;
if (Plugin.EnableDebugLogging.Value)
{
Plugin.Logger.LogDebug((object)("Cached new PlayerControllerB for " + ((Object)gameObject).name));
}
}
}
else
{
if ((Object)(object)value == (Object)null)
{
playerControllerCache.Remove(gameObject);
if (Plugin.EnableDebugLogging.Value)
{
Plugin.Logger.LogDebug((object)("Removed destroyed PlayerControllerB from cache for " + ((Object)gameObject).name));
}
return null;
}
if (Plugin.EnableDebugLogging.Value)
{
Plugin.Logger.LogDebug((object)("Retrieved cached PlayerControllerB for " + ((Object)gameObject).name));
}
}
return value;
}
[HarmonyPatch(typeof(QuicksandTrigger), "OnTriggerStay")]
[HarmonyTranspiler]
private static IEnumerable<CodeInstruction> QuicksandTriggerStayTranspiler(IEnumerable<CodeInstruction> instructions)
{
//IL_008a: Unknown result type (might be due to invalid IL or missing references)
//IL_0094: Expected O, but got Unknown
List<CodeInstruction> list = new List<CodeInstruction>(instructions);
MethodInfo methodInfo = AccessTools.Method(typeof(GameObject), "GetComponent", (Type[])null, new Type[1] { typeof(PlayerControllerB) });
MethodInfo methodInfo2 = AccessTools.Method(typeof(CollisionCachePatches), "GetCachedPlayerController", (Type[])null, (Type[])null);
if (methodInfo == null || methodInfo2 == null)
{
Plugin.Logger.LogWarning((object)"Could not find methods for PlayerControllerB caching in OnTriggerStay");
return list;
}
int num = 0;
for (int i = 0; i < list.Count; i++)
{
if (CodeInstructionExtensions.Calls(list[i], methodInfo))
{
list[i] = new CodeInstruction(OpCodes.Call, (object)methodInfo2);
num++;
}
}
if (num > 0)
{
Plugin.Logger.LogInfo((object)$"Replaced {num} GetComponent<PlayerControllerB> calls in OnTriggerStay");
}
else if (Plugin.EnableDebugLogging.Value)
{
Plugin.Logger.LogWarning((object)"No GetComponent<PlayerControllerB> calls found in OnTriggerStay to replace");
}
return list;
}
[HarmonyPatch(typeof(QuicksandTrigger), "OnTriggerExit")]
[HarmonyTranspiler]
private static IEnumerable<CodeInstruction> QuicksandTriggerExitTranspiler(IEnumerable<CodeInstruction> instructions)
{
//IL_008a: Unknown result type (might be due to invalid IL or missing references)
//IL_0094: Expected O, but got Unknown
List<CodeInstruction> list = new List<CodeInstruction>(instructions);
MethodInfo methodInfo = AccessTools.Method(typeof(GameObject), "GetComponent", (Type[])null, new Type[1] { typeof(PlayerControllerB) });
MethodInfo methodInfo2 = AccessTools.Method(typeof(CollisionCachePatches), "GetCachedPlayerController", (Type[])null, (Type[])null);
if (methodInfo == null || methodInfo2 == null)
{
Plugin.Logger.LogWarning((object)"Could not find methods for PlayerControllerB caching in OnTriggerExit");
return list;
}
int num = 0;
for (int i = 0; i < list.Count; i++)
{
if (CodeInstructionExtensions.Calls(list[i], methodInfo))
{
list[i] = new CodeInstruction(OpCodes.Call, (object)methodInfo2);
num++;
}
}
if (num > 0)
{
Plugin.Logger.LogInfo((object)$"Replaced {num} GetComponent<PlayerControllerB> calls in OnTriggerExit");
}
else if (Plugin.EnableDebugLogging.Value)
{
Plugin.Logger.LogWarning((object)"No GetComponent<PlayerControllerB> calls found in OnTriggerExit to replace");
}
return list;
}
[HarmonyPatch(typeof(RoundManager), "LoadNewLevel")]
[HarmonyPostfix]
private static void ClearCacheOnLevelChange()
{
int count = playerControllerCache.Count;
playerControllerCache.Clear();
if (Plugin.EnableDebugLogging.Value)
{
Plugin.Logger.LogDebug((object)$"Cleared {count} PlayerControllerB cache entries on level change");
}
}
[HarmonyPatch(typeof(StartOfRound), "ResetShip")]
[HarmonyPostfix]
private static void ClearCacheOnShipReset()
{
int count = playerControllerCache.Count;
playerControllerCache.Clear();
if (Plugin.EnableDebugLogging.Value)
{
Plugin.Logger.LogDebug((object)$"Cleared {count} PlayerControllerB cache entries on ship reset");
}
}
}
[HarmonyPatch]
internal class ComponentLookupPatches
{
private static readonly Dictionary<GameObject, NetworkObject> networkObjectCache = new Dictionary<GameObject, NetworkObject>();
public static NetworkObject GetCachedNetworkObject(GameObject gameObject)
{
if ((Object)(object)gameObject == (Object)null)
{
return null;
}
if (!networkObjectCache.TryGetValue(gameObject, out var value))
{
value = gameObject.GetComponent<NetworkObject>();
if ((Object)(object)value != (Object)null)
{
networkObjectCache[gameObject] = value;
if (Plugin.EnableDebugLogging.Value)
{
Plugin.Logger.LogDebug((object)("Cached new NetworkObject for " + ((Object)gameObject).name));
}
}
}
else
{
if ((Object)(object)value == (Object)null)
{
networkObjectCache.Remove(gameObject);
if (Plugin.EnableDebugLogging.Value)
{
Plugin.Logger.LogDebug((object)("Removed destroyed NetworkObject from cache for " + ((Object)gameObject).name));
}
return null;
}
if (Plugin.EnableDebugLogging.Value)
{
Plugin.Logger.LogDebug((object)("Retrieved cached NetworkObject for " + ((Object)gameObject).name));
}
}
return value;
}
public static NetworkObject GetCachedNetworkObjectInChildren(GameObject gameObject)
{
if ((Object)(object)gameObject == (Object)null)
{
return null;
}
NetworkObject cachedNetworkObject = GetCachedNetworkObject(gameObject);
if ((Object)(object)cachedNetworkObject != (Object)null)
{
return cachedNetworkObject;
}
cachedNetworkObject = gameObject.GetComponentInChildren<NetworkObject>();
if ((Object)(object)cachedNetworkObject != (Object)null)
{
networkObjectCache[gameObject] = cachedNetworkObject;
if (Plugin.EnableDebugLogging.Value)
{
Plugin.Logger.LogDebug((object)("Cached new NetworkObject (from children) for " + ((Object)gameObject).name));
}
}
return cachedNetworkObject;
}
[HarmonyPatch(typeof(RoundManager), "SpawnScrapInLevel")]
[HarmonyTranspiler]
private static IEnumerable<CodeInstruction> OptimizeNetworkObjectLookups(IEnumerable<CodeInstruction> instructions)
{
//IL_008a: Unknown result type (might be due to invalid IL or missing references)
//IL_0094: Expected O, but got Unknown
List<CodeInstruction> list = new List<CodeInstruction>(instructions);
MethodInfo methodInfo = AccessTools.Method(typeof(GameObject), "GetComponent", (Type[])null, new Type[1] { typeof(NetworkObject) });
MethodInfo methodInfo2 = AccessTools.Method(typeof(ComponentLookupPatches), "GetCachedNetworkObject", (Type[])null, (Type[])null);
if (methodInfo == null || methodInfo2 == null)
{
Plugin.Logger.LogWarning((object)"Could not find methods for NetworkObject caching in SpawnScrapInLevel");
return list;
}
int num = 0;
for (int i = 0; i < list.Count; i++)
{
if (CodeInstructionExtensions.Calls(list[i], methodInfo))
{
list[i] = new CodeInstruction(OpCodes.Call, (object)methodInfo2);
num++;
}
}
if (num > 0)
{
Plugin.Logger.LogInfo((object)$"Replaced {num} GetComponent<NetworkObject> calls in SpawnScrapInLevel");
}
else if (Plugin.EnableDebugLogging.Value)
{
Plugin.Logger.LogWarning((object)"No GetComponent<NetworkObject> calls found in SpawnScrapInLevel to replace");
}
return list;
}
[HarmonyPatch(typeof(RoundManager), "SpawnEnemyOnServer")]
[HarmonyTranspiler]
private static IEnumerable<CodeInstruction> OptimizeEnemySpawnLookups(IEnumerable<CodeInstruction> instructions)
{
//IL_008a: Unknown result type (might be due to invalid IL or missing references)
//IL_0094: Expected O, but got Unknown
List<CodeInstruction> list = new List<CodeInstruction>(instructions);
MethodInfo methodInfo = AccessTools.Method(typeof(GameObject), "GetComponentInChildren", (Type[])null, new Type[1] { typeof(NetworkObject) });
MethodInfo methodInfo2 = AccessTools.Method(typeof(ComponentLookupPatches), "GetCachedNetworkObjectInChildren", (Type[])null, (Type[])null);
if (methodInfo == null || methodInfo2 == null)
{
Plugin.Logger.LogWarning((object)"Could not find methods for NetworkObject caching in SpawnEnemyOnServer");
return list;
}
int num = 0;
for (int i = 0; i < list.Count; i++)
{
if (CodeInstructionExtensions.Calls(list[i], methodInfo))
{
list[i] = new CodeInstruction(OpCodes.Call, (object)methodInfo2);
num++;
}
}
if (num > 0)
{
Plugin.Logger.LogInfo((object)$"Replaced {num} GetComponentInChildren<NetworkObject> calls in SpawnEnemyOnServer");
}
else if (Plugin.EnableDebugLogging.Value)
{
Plugin.Logger.LogWarning((object)"No GetComponentInChildren<NetworkObject> calls found in SpawnEnemyOnServer to replace");
}
return list;
}
[HarmonyPatch(typeof(RoundManager), "DespawnPropsAtEndOfRound")]
[HarmonyPostfix]
private static void ClearCacheOnRoundEnd()
{
int count = networkObjectCache.Count;
networkObjectCache.Clear();
if (Plugin.EnableDebugLogging.Value)
{
Plugin.Logger.LogDebug((object)$"Cleared {count} NetworkObject cache entries on round end");
}
}
[HarmonyPatch(typeof(StartOfRound), "ResetShip")]
[HarmonyPostfix]
private static void ClearCacheOnShipReset()
{
int count = networkObjectCache.Count;
networkObjectCache.Clear();
if (Plugin.EnableDebugLogging.Value)
{
Plugin.Logger.LogDebug((object)$"Cleared {count} NetworkObject cache entries on ship reset");
}
}
}
[HarmonyPatch]
internal class DebugLogPatches
{
[HarmonyPatch(typeof(RoundManager), "SpawnScrapInLevel")]
[HarmonyTranspiler]
private static IEnumerable<CodeInstruction> RemoveDebugLogsFromSpawnScrap(IEnumerable<CodeInstruction> instructions)
{
List<CodeInstruction> list = new List<CodeInstruction>(instructions);
MethodInfo methodInfo = AccessTools.Method(typeof(Debug), "Log", new Type[1] { typeof(object) }, (Type[])null);
if (methodInfo == null)
{
Plugin.Logger.LogWarning((object)"Could not find Debug.Log method, skipping transpiler");
return list;
}
int num = 0;
for (int num2 = list.Count - 1; num2 >= 0; num2--)
{
if (CodeInstructionExtensions.Calls(list[num2], methodInfo))
{
int num3 = 1;
int num4 = num2 - 1;
while (num4 >= 0 && num3 < 10 && (list[num4].opcode == OpCodes.Ldstr || list[num4].opcode == OpCodes.Ldarg || list[num4].opcode == OpCodes.Ldloc))
{
num3++;
num4--;
}
for (int i = 0; i < num3 && num2 - i >= 0; i++)
{
list[num2 - i].opcode = OpCodes.Nop;
}
num++;
}
}
if (num > 0)
{
Plugin.Logger.LogInfo((object)$"Removed {num} Debug.Log calls from SpawnScrapInLevel");
}
return list;
}
}
[HarmonyPatch]
internal class ShipItemOptimizationPatches
{
private static readonly HashSet<GrabbableObject> scrapCollectedSet = new HashSet<GrabbableObject>();
private static bool setInitialized = false;
[HarmonyPatch(typeof(RoundManager), "CollectNewScrapForThisRound")]
[HarmonyPrefix]
private static bool CollectNewScrapPrefix(RoundManager __instance, GrabbableObject scrapObject)
{
try
{
if (Plugin.EnableDebugLogging.Value)
{
Plugin.Logger.LogDebug((object)("CollectNewScrap called for " + (scrapObject?.itemProperties?.itemName ?? "null")));
}
if (!scrapObject.itemProperties.isScrap)
{
if (Plugin.EnableDebugLogging.Value)
{
Plugin.Logger.LogDebug((object)("Item " + scrapObject.itemProperties.itemName + " is not scrap, skipping"));
}
return false;
}
if (!setInitialized && __instance.scrapCollectedThisRound != null)
{
scrapCollectedSet.Clear();
foreach (GrabbableObject item in __instance.scrapCollectedThisRound)
{
if ((Object)(object)item != (Object)null)
{
scrapCollectedSet.Add(item);
}
}
setInitialized = true;
if (Plugin.EnableDebugLogging.Value)
{
Plugin.Logger.LogDebug((object)$"Initialized scrap set with {scrapCollectedSet.Count} items");
}
}
if (scrapCollectedSet.Contains(scrapObject))
{
if (Plugin.EnableDebugLogging.Value)
{
Plugin.Logger.LogDebug((object)("Scrap " + scrapObject.itemProperties.itemName + " already collected, skipping"));
}
return false;
}
if (scrapObject.scrapPersistedThroughRounds)
{
if (Plugin.EnableDebugLogging.Value)
{
Plugin.Logger.LogDebug((object)("Scrap " + scrapObject.itemProperties.itemName + " persisted through rounds, skipping"));
}
return false;
}
__instance.scrapCollectedThisRound.Add(scrapObject);
scrapCollectedSet.Add(scrapObject);
HUDManager.Instance.AddNewScrapFoundToDisplay(scrapObject);
if (Plugin.EnableDebugLogging.Value)
{
Plugin.Logger.LogDebug((object)$"Added scrap {scrapObject.itemProperties.itemName} to collection (total: {scrapCollectedSet.Count})");
}
return false;
}
catch (Exception ex)
{
Plugin.Logger.LogError((object)("Error in CollectNewScrapForThisRound patch: " + ex.Message));
return true;
}
}
[HarmonyPatch(typeof(RoundManager), "DespawnPropsAtEndOfRound")]
[HarmonyPostfix]
private static void ClearScrapSetOnRoundEnd()
{
int count = scrapCollectedSet.Count;
scrapCollectedSet.Clear();
setInitialized = false;
if (Plugin.EnableDebugLogging.Value)
{
Plugin.Logger.LogDebug((object)$"Cleared {count} scrap items from HashSet on round end");
}
}
[HarmonyPatch(typeof(StartOfRound), "ResetShip")]
[HarmonyPostfix]
private static void ClearScrapSetOnShipReset()
{
int count = scrapCollectedSet.Count;
scrapCollectedSet.Clear();
setInitialized = false;
if (Plugin.EnableDebugLogging.Value)
{
Plugin.Logger.LogDebug((object)$"Cleared {count} scrap items from HashSet on ship reset");
}
}
}
[HarmonyPatch]
internal class StringOptimizationPatches
{
private static readonly StringBuilder stringBuilder = new StringBuilder(256);
[HarmonyPatch(typeof(GrabbableObject), "SetScrapValue")]
[HarmonyPrefix]
private static bool OptimizeSetScrapValue(GrabbableObject __instance, int setValueTo)
{
try
{
if (Plugin.EnableDebugLogging.Value)
{
Plugin.Logger.LogDebug((object)string.Format("SetScrapValue called for {0} with value {1}", __instance?.itemProperties?.itemName ?? "null", setValueTo));
}
__instance.scrapValue = setValueTo;
ScanNodeProperties componentInChildren = ((Component)__instance).gameObject.GetComponentInChildren<ScanNodeProperties>();
if ((Object)(object)componentInChildren == (Object)null)
{
if (Plugin.EnableDebugLogging.Value)
{
Plugin.Logger.LogDebug((object)("No ScanNodeProperties found for " + __instance.itemProperties.itemName));
}
return true;
}
stringBuilder.Clear();
stringBuilder.Append("Value: $");
stringBuilder.Append(setValueTo);
componentInChildren.subText = stringBuilder.ToString();
componentInChildren.scrapValue = setValueTo;
if (Plugin.EnableDebugLogging.Value)
{
Plugin.Logger.LogDebug((object)("Set scrap value text to '" + componentInChildren.subText + "' for " + __instance.itemProperties.itemName));
}
return false;
}
catch (Exception ex)
{
Plugin.Logger.LogError((object)("Error in SetScrapValue patch: " + ex.Message));
return true;
}
}
}
}
