using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using ExitGames.Client.Photon;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Photon.Pun;
using Photon.Realtime;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("UpgradeLimiter")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.4.2.0")]
[assembly: AssemblyInformationalVersion("0.4.2")]
[assembly: AssemblyProduct("UpgradeLimiter")]
[assembly: AssemblyTitle("UpgradeLimiter")]
[assembly: AssemblyVersion("0.4.2.0")]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
internal sealed class NullableAttribute : Attribute
{
public readonly byte[] NullableFlags;
public NullableAttribute(byte P_0)
{
NullableFlags = new byte[1] { P_0 };
}
public NullableAttribute(byte[] P_0)
{
NullableFlags = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
internal sealed class NullableContextAttribute : Attribute
{
public readonly byte Flag;
public NullableContextAttribute(byte P_0)
{
Flag = P_0;
}
}
}
namespace UpgradeLimiter
{
internal class UpgradeEntry
{
public string Name = "";
public MethodInfo? Method;
public FieldInfo? CountField;
public ConfigEntry<bool> Enabled;
public ConfigEntry<int> MaxStacks;
public bool ActiveEnabled;
public int ActiveMax;
}
internal static class UpgradeRegistry
{
internal static readonly List<UpgradeEntry> Entries = new List<UpgradeEntry>();
internal static readonly Dictionary<MethodBase, UpgradeEntry> ByMethod = new Dictionary<MethodBase, UpgradeEntry>();
internal static readonly Dictionary<string, UpgradeEntry> ByDictName = new Dictionary<string, UpgradeEntry>(StringComparer.Ordinal);
private static readonly (string Name, string MethodName, string DictField)[] BaseMap = new(string, string, string)[13]
{
("Health", "UpgradePlayerHealth", "playerUpgradeHealth"),
("Energy", "UpgradePlayerEnergy", "playerUpgradeStamina"),
("ExtraJump", "UpgradePlayerExtraJump", "playerUpgradeExtraJump"),
("TumbleLaunch", "UpgradePlayerTumbleLaunch", "playerUpgradeLaunch"),
("TumbleClimb", "UpgradePlayerTumbleClimb", "playerUpgradeTumbleClimb"),
("TumbleWings", "UpgradePlayerTumbleWings", "playerUpgradeTumbleWings"),
("SprintSpeed", "UpgradePlayerSprintSpeed", "playerUpgradeSpeed"),
("CrouchRest", "UpgradePlayerCrouchRest", "playerUpgradeCrouchRest"),
("GrabStrength", "UpgradePlayerGrabStrength", "playerUpgradeStrength"),
("ThrowStrength", "UpgradePlayerThrowStrength", "playerUpgradeThrow"),
("GrabRange", "UpgradePlayerGrabRange", "playerUpgradeRange"),
("DeathHeadBattery", "UpgradeDeathHeadBattery", "playerUpgradeDeathHeadBattery"),
("MapPlayerCount", "UpgradeMapPlayerCount", "playerUpgradeMapPlayerCount")
};
public static void Discover()
{
Entries.Clear();
ByMethod.Clear();
ByDictName.Clear();
Type type = AccessTools.TypeByName("PunManager");
Type type2 = AccessTools.TypeByName("StatsManager");
if (type == null)
{
Plugin.Log.LogError((object)"[Discover] PunManager not found — base entries unenforceable.");
}
if (type2 == null)
{
Plugin.Log.LogError((object)"[Discover] StatsManager not found — base entries unenforceable.");
}
HashSet<MethodInfo> hashSet = new HashSet<MethodInfo>();
(string, string, string)[] baseMap = BaseMap;
for (int i = 0; i < baseMap.Length; i++)
{
(string, string, string) tuple = baseMap[i];
string item = tuple.Item1;
string item2 = tuple.Item2;
string item3 = tuple.Item3;
MethodInfo methodInfo = null;
FieldInfo fieldInfo = null;
if (type != null)
{
methodInfo = AccessTools.Method(type, item2, new Type[2]
{
typeof(string),
typeof(int)
}, (Type[])null);
}
if (type2 != null)
{
fieldInfo = AccessTools.Field(type2, item3);
}
if (methodInfo == null)
{
Plugin.Log.LogWarning((object)("[Discover] " + item2 + " not on PunManager — " + item + " cap won't enforce."));
}
if (fieldInfo == null)
{
Plugin.Log.LogWarning((object)("[Discover] " + item3 + " not on StatsManager — " + item + " cap won't enforce."));
}
UpgradeEntry upgradeEntry = new UpgradeEntry
{
Name = item,
Method = methodInfo,
CountField = fieldInfo
};
if (methodInfo != null && fieldInfo != null)
{
ByMethod[methodInfo] = upgradeEntry;
hashSet.Add(methodInfo);
Plugin.Log.LogInfo((object)("[Discover] " + item2 + " ↔ " + item3));
}
if (fieldInfo != null)
{
ByDictName[fieldInfo.Name] = upgradeEntry;
}
Entries.Add(upgradeEntry);
}
if (type2 != null)
{
ScanModded(type2, hashSet);
}
Plugin.Log.LogInfo((object)$"[Discover] {Entries.Count} entries total ({ByMethod.Count} enforceable).");
}
private static void ScanModded(Type statsManager, HashSet<MethodInfo> seen)
{
Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
foreach (Assembly assembly in assemblies)
{
Type[] array;
try
{
array = assembly.GetTypes();
}
catch (ReflectionTypeLoadException ex)
{
array = ex.Types ?? Array.Empty<Type>();
}
catch
{
continue;
}
Type[] array2 = array;
foreach (Type type in array2)
{
if (type == null)
{
continue;
}
MethodInfo[] methods;
try
{
methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
}
catch
{
continue;
}
MethodInfo[] array3 = methods;
foreach (MethodInfo methodInfo in array3)
{
if (seen.Contains(methodInfo) || !methodInfo.Name.StartsWith("Upgrade", StringComparison.Ordinal) || methodInfo.ReturnType != typeof(int))
{
continue;
}
ParameterInfo[] parameters = methodInfo.GetParameters();
if (parameters.Length != 2 || parameters[0].ParameterType != typeof(string) || parameters[1].ParameterType != typeof(int))
{
continue;
}
FieldInfo fieldInfo = FindDictField(methodInfo, statsManager);
if (!(fieldInfo == null))
{
string text = (methodInfo.Name.StartsWith("UpgradePlayer", StringComparison.Ordinal) ? methodInfo.Name.Substring("UpgradePlayer".Length) : methodInfo.Name.Substring("Upgrade".Length));
string name = text;
if (Entries.Exists((UpgradeEntry e) => e.Name == name))
{
name = type.Name + "_" + name;
}
UpgradeEntry upgradeEntry = new UpgradeEntry
{
Name = name,
Method = methodInfo,
CountField = fieldInfo
};
ByMethod[methodInfo] = upgradeEntry;
ByDictName[fieldInfo.Name] = upgradeEntry;
seen.Add(methodInfo);
Entries.Add(upgradeEntry);
Plugin.Log.LogInfo((object)("[Discover] Modded " + type.FullName + "." + methodInfo.Name + " ↔ " + fieldInfo.Name + " as " + name));
}
}
}
}
}
private static FieldInfo? FindDictField(MethodInfo method, Type statsManager)
{
MethodBody methodBody;
try
{
methodBody = method.GetMethodBody();
}
catch
{
return null;
}
if (methodBody == null)
{
return null;
}
byte[] iLAsByteArray = methodBody.GetILAsByteArray();
if (iLAsByteArray == null || iLAsByteArray.Length < 5)
{
return null;
}
Module module = method.Module;
Type typeFromHandle = typeof(Dictionary<string, int>);
Type[] genericTypeArguments = null;
Type[] genericMethodArguments = null;
try
{
Type? declaringType = method.DeclaringType;
if ((object)declaringType != null && declaringType.IsGenericType)
{
genericTypeArguments = method.DeclaringType.GetGenericArguments();
}
if (method.IsGenericMethod)
{
genericMethodArguments = method.GetGenericArguments();
}
}
catch
{
}
for (int i = 0; i <= iLAsByteArray.Length - 5; i++)
{
byte b = iLAsByteArray[i];
if (b == 123 || b == 124 || b == 125 || b == 126 || b == 128)
{
int metadataToken = BitConverter.ToInt32(iLAsByteArray, i + 1);
FieldInfo fieldInfo;
try
{
fieldInfo = module.ResolveField(metadataToken, genericTypeArguments, genericMethodArguments);
}
catch
{
continue;
}
if (!(fieldInfo == null) && !(fieldInfo.DeclaringType != statsManager) && !(fieldInfo.FieldType != typeFromHandle))
{
return fieldInfo;
}
}
}
return null;
}
}
[BepInPlugin("darkharasho.UpgradeLimiter", "UpgradeLimiter", "0.4.2")]
public class Plugin : BaseUnityPlugin
{
internal static ManualLogSource Log;
internal static ConfigEntry<bool> SyncToClients;
private void Awake()
{
//IL_0075: Unknown result type (might be due to invalid IL or missing references)
//IL_007b: Expected O, but got Unknown
//IL_0095: Unknown result type (might be due to invalid IL or missing references)
//IL_009b: Expected O, but got Unknown
//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
//IL_01e7: Expected O, but got Unknown
Log = ((BaseUnityPlugin)this).Logger;
SyncToClients = ((BaseUnityPlugin)this).Config.Bind<bool>("Sync", "SyncToClients", true, "Host-only. When true, the host pushes its limits to every client via Photon room properties. When false, the host never publishes; each client uses its own local config.");
UpgradeRegistry.Discover();
BindUpgradeConfigs();
ResetActiveToLocal();
((Component)this).gameObject.AddComponent<SettingsSyncer>();
SyncToClients.SettingChanged += delegate
{
SettingsSyncer.Instance?.PushHostSettingsExternal();
};
Harmony val = new Harmony("darkharasho.UpgradeLimiter");
val.PatchAll();
HarmonyMethod val2 = new HarmonyMethod(typeof(CapPrefix).GetMethod("Prefix"));
foreach (UpgradeEntry entry in UpgradeRegistry.Entries)
{
if (!(entry.Method == null))
{
try
{
val.Patch((MethodBase)entry.Method, val2, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
Log.LogInfo((object)("[Patch] Installed cap prefix on " + entry.Method.Name));
}
catch (Exception ex)
{
Log.LogError((object)("[Patch] Failed to patch " + entry.Method.Name + ": " + ex.GetType().Name + " " + ex.Message));
}
}
}
Type type = AccessTools.TypeByName("StatsManager");
MethodInfo methodInfo = ((type != null) ? AccessTools.Method(type, "DictionaryUpdateValue", new Type[3]
{
typeof(string),
typeof(string),
typeof(int)
}, (Type[])null) : null);
if (methodInfo != null)
{
try
{
HarmonyMethod val3 = new HarmonyMethod(typeof(DictUpdateClampPrefix).GetMethod("Prefix"));
val.Patch((MethodBase)methodInfo, val3, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
Log.LogInfo((object)"[Patch] Installed clamp prefix on StatsManager.DictionaryUpdateValue");
}
catch (Exception ex2)
{
Log.LogError((object)("[Patch] Failed to patch DictionaryUpdateValue: " + ex2.GetType().Name + " " + ex2.Message));
}
}
else
{
Log.LogWarning((object)"[Patch] StatsManager.DictionaryUpdateValue not found — shared/RPC clamp disabled.");
}
Log.LogInfo((object)"UpgradeLimiter v0.4.2 loaded.");
}
private void BindUpgradeConfigs()
{
//IL_0087: Unknown result type (might be due to invalid IL or missing references)
//IL_0091: Expected O, but got Unknown
AcceptableValueRange<int> val = new AcceptableValueRange<int>(0, 99);
foreach (UpgradeEntry entry2 in UpgradeRegistry.Entries)
{
string name = entry2.Name;
entry2.Enabled = ((BaseUnityPlugin)this).Config.Bind<bool>(name, "Enabled", false, "Enable the cap for the " + entry2.Name + " upgrade. When false, the upgrade behaves vanilla.");
entry2.MaxStacks = ((BaseUnityPlugin)this).Config.Bind<int>(name, "MaxStacks", 5, new ConfigDescription("Maximum number of " + entry2.Name + " upgrades a single player may stack. 0 means no further upgrades can be picked up.", (AcceptableValueBase)(object)val, Array.Empty<object>()));
UpgradeEntry entry = entry2;
entry.Enabled.SettingChanged += delegate
{
if (!PhotonNetwork.InRoom || PhotonNetwork.IsMasterClient)
{
entry.ActiveEnabled = entry.Enabled.Value;
if (PhotonNetwork.InRoom && PhotonNetwork.IsMasterClient)
{
SettingsSyncer.Instance?.PushHostSettingsExternal();
}
}
};
entry.MaxStacks.SettingChanged += delegate
{
if (!PhotonNetwork.InRoom || PhotonNetwork.IsMasterClient)
{
entry.ActiveMax = entry.MaxStacks.Value;
if (PhotonNetwork.InRoom && PhotonNetwork.IsMasterClient)
{
SettingsSyncer.Instance?.PushHostSettingsExternal();
}
}
};
}
}
internal static void ResetActiveToLocal()
{
foreach (UpgradeEntry entry in UpgradeRegistry.Entries)
{
entry.ActiveEnabled = entry.Enabled.Value;
entry.ActiveMax = entry.MaxStacks.Value;
}
}
}
internal class SettingsSyncer : MonoBehaviour
{
internal static SettingsSyncer? Instance;
private bool _wasInRoom;
private bool _wasMaster;
private float _pollDelay;
private readonly Dictionary<string, (bool en, int max)> _lastPushed = new Dictionary<string, (bool, int)>();
private void Awake()
{
Instance = this;
}
private void Start()
{
Plugin.Log.LogInfo((object)"[Sync] SettingsSyncer ready (polling mode)");
}
private void Update()
{
bool inRoom = PhotonNetwork.InRoom;
bool flag = inRoom && PhotonNetwork.IsMasterClient;
if (inRoom && !_wasInRoom)
{
if (flag)
{
PushHostSettings();
}
else
{
PullHostSettings();
}
}
else if (!inRoom && _wasInRoom)
{
Plugin.ResetActiveToLocal();
Plugin.Log.LogInfo((object)"[Sync] Left room — reset to local config");
}
else if (inRoom && flag && !_wasMaster)
{
PushHostSettings();
}
else if (inRoom && !flag)
{
_pollDelay -= Time.unscaledDeltaTime;
if (_pollDelay <= 0f)
{
_pollDelay = 1f;
PullHostSettings();
}
}
_wasInRoom = inRoom;
_wasMaster = flag;
}
internal void PushHostSettingsExternal()
{
if (PhotonNetwork.InRoom && PhotonNetwork.IsMasterClient)
{
PushHostSettings();
}
}
private void PushHostSettings()
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Expected O, but got Unknown
if (PhotonNetwork.CurrentRoom == null || !Plugin.SyncToClients.Value)
{
return;
}
Hashtable val = new Hashtable();
bool flag = false;
foreach (UpgradeEntry entry in UpgradeRegistry.Entries)
{
bool value = entry.Enabled.Value;
int value2 = entry.MaxStacks.Value;
if (!_lastPushed.TryGetValue(entry.Name, out (bool, int) value3) || value3.Item1 != value || value3.Item2 != value2)
{
_lastPushed[entry.Name] = (value, value2);
val[(object)("UL_" + entry.Name + "_E")] = value;
val[(object)("UL_" + entry.Name + "_M")] = value2;
flag = true;
}
}
if (flag)
{
PhotonNetwork.CurrentRoom.SetCustomProperties(val, (Hashtable)null, (WebFlags)null);
Plugin.Log.LogInfo((object)$"[Sync] Host pushed {((Dictionary<object, object>)(object)val).Count / 2} upgrade limit settings");
}
}
private void PullHostSettings()
{
Room currentRoom = PhotonNetwork.CurrentRoom;
Hashtable val = ((currentRoom != null) ? ((RoomInfo)currentRoom).CustomProperties : null);
if (val == null)
{
return;
}
bool flag = false;
foreach (UpgradeEntry entry in UpgradeRegistry.Entries)
{
string text = "UL_" + entry.Name + "_E";
string text2 = "UL_" + entry.Name + "_M";
if (((Dictionary<object, object>)(object)val).ContainsKey((object)text) && val[(object)text] is bool activeEnabled)
{
entry.ActiveEnabled = activeEnabled;
flag = true;
}
if (((Dictionary<object, object>)(object)val).ContainsKey((object)text2) && val[(object)text2] is int activeMax)
{
entry.ActiveMax = activeMax;
flag = true;
}
}
if (flag)
{
Plugin.Log.LogInfo((object)"[Sync] Pulled host upgrade-limit settings from room properties");
}
}
}
internal static class DictUpdateClampPrefix
{
public static void Prefix(string dictionaryName, string key, ref int value)
{
if (UpgradeRegistry.ByDictName.TryGetValue(dictionaryName, out UpgradeEntry value2) && value2.ActiveEnabled && value > value2.ActiveMax)
{
Plugin.Log.LogDebug((object)$"[Cap] {value2.Name} for {key} clamped {value} → {value2.ActiveMax} (DictionaryUpdateValue)");
value = value2.ActiveMax;
}
}
}
internal static class CapPrefix
{
public static bool Prefix(string _steamID, int value, MethodBase __originalMethod)
{
if (!UpgradeRegistry.ByMethod.TryGetValue(__originalMethod, out UpgradeEntry value2))
{
return true;
}
if (!value2.ActiveEnabled)
{
return true;
}
if (value2.CountField == null)
{
return true;
}
if (value <= 0)
{
return true;
}
Type type = AccessTools.TypeByName("StatsManager");
object obj = ((type != null) ? AccessTools.Field(type, "instance") : null)?.GetValue(null);
if (obj == null)
{
return true;
}
if (!(value2.CountField.GetValue(obj) is IDictionary<string, int> dictionary))
{
return true;
}
if (!dictionary.TryGetValue(_steamID, out var value3))
{
value3 = 0;
}
if (value3 + value > value2.ActiveMax)
{
Plugin.Log.LogDebug((object)$"[Cap] {value2.Name} for {_steamID} blocked: {value3}+{value} > {value2.ActiveMax}");
return false;
}
return true;
}
}
public static class PluginInfo
{
public const string PLUGIN_GUID = "darkharasho.UpgradeLimiter";
public const string PLUGIN_NAME = "UpgradeLimiter";
public const string PLUGIN_VERSION = "0.4.2";
}
}
