using System;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using HarmonyLib;
using MelonLoader;
using SledBigLobbies;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("SledBigLobbies")]
[assembly: AssemblyFileVersion("0.1.0")]
[assembly: MelonInfo(typeof(Mod), "SledBigLobbies", "0.1.0", "Natebag", null)]
[assembly: MelonGame("The Sledding Corporation", "Sledding Game")]
[assembly: MelonColor(255, 255, 200, 80)]
[assembly: MelonAuthorColor(255, 80, 160, 255)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = "")]
[assembly: AssemblyVersion("0.1.0.0")]
namespace SledBigLobbies;
public sealed class Mod : MelonMod
{
public const string Name = "SledBigLobbies";
public const string Version = "0.1.0";
public const string Author = "Natebag";
internal const int MaxPlayers = 60;
internal const int MinPlayers = 1;
internal const bool ForceCrossplay = true;
private static float _nextEnforce;
private static Type _lsmType;
private static MethodInfo _lsmGetInstance;
private static MethodInfo _lsmGetSettings;
private static bool _enforceLogged;
private static int _enforceCount;
private static float _enforceLogAt;
private static bool _uiSliderWarned;
private static bool _crossplayLogged;
private const int AttrTypeMaxPlayers = 9;
private static MethodInfo _objectOpImplicitFromInt;
private static MethodInfo _int32OpImplicitFromInt;
private static bool _boxLookupAttempted;
private static bool _shapeLogged;
private static bool _lobbyMutLogged;
private static bool _lsLoggedShape;
public override void OnUpdate()
{
EnforceLobbyCap();
}
private static void EnforceLobbyCap()
{
if (Time.time < _nextEnforce)
{
return;
}
_nextEnforce = Time.time + 0.5f;
try
{
if (_lsmType == null)
{
_lsmType = FindTypeByShortName("LobbySettingsManager");
if (_lsmType == null)
{
return;
}
_lsmGetInstance = _lsmType.GetMethod("get_Instance", BindingFlags.Static | BindingFlags.Public);
_lsmGetSettings = _lsmType.GetMethod("GetLobbySettings", BindingFlags.Instance | BindingFlags.Public);
}
if (_lsmGetInstance == null || _lsmGetSettings == null)
{
return;
}
object obj = _lsmGetInstance.Invoke(null, null);
if (obj == null)
{
return;
}
object obj2 = _lsmGetSettings.Invoke(obj, null);
if (obj2 == null)
{
return;
}
Type type = obj2.GetType();
int num = 60;
PropertyInfo property = type.GetProperty("maxPlayers", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (property != null && property.CanRead && property.CanWrite)
{
int num2 = (int)(property.GetValue(obj2) ?? ((object)0));
if (num2 < num)
{
property.SetValue(obj2, num);
LogEnforce($"enforce prop {num2}->{num}");
}
return;
}
FieldInfo field = type.GetField("maxPlayers", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (field != null)
{
int num3 = (int)(field.GetValue(obj2) ?? ((object)0));
if (num3 < num)
{
field.SetValue(obj2, num);
LogEnforce($"enforce field {num3}->{num}");
}
}
else if (!_enforceLogged)
{
_enforceLogged = true;
string value = string.Join(",", (from x in type.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
select "p:" + x.Name).Concat(from x in type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
select "f:" + x.Name));
MelonLogger.Msg($"[SledBigLobbies] enforce: no maxPlayers member found on {type.FullName}; members=[{value}]");
}
}
catch (Exception ex)
{
LogEnforce("enforce error: " + ex.Message);
}
}
private static void LogEnforce(string msg)
{
_enforceCount++;
if (_enforceCount <= 3 || Time.time > _enforceLogAt + 1f)
{
_enforceLogAt = Time.time;
MelonLogger.Msg($"[SledBigLobbies] {msg} (#{_enforceCount})");
}
}
public override void OnInitializeMelon()
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_000b: Expected O, but got Unknown
//IL_0093: Unknown result type (might be due to invalid IL or missing references)
//IL_00a1: Expected O, but got Unknown
//IL_012b: Unknown result type (might be due to invalid IL or missing references)
//IL_0139: Expected O, but got Unknown
//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
//IL_01d4: Expected O, but got Unknown
//IL_023c: Unknown result type (might be due to invalid IL or missing references)
//IL_024a: Expected O, but got Unknown
//IL_0298: Unknown result type (might be due to invalid IL or missing references)
//IL_02a6: Expected O, but got Unknown
//IL_03af: Unknown result type (might be due to invalid IL or missing references)
//IL_03bc: Expected O, but got Unknown
//IL_032a: Unknown result type (might be due to invalid IL or missing references)
//IL_0338: Expected O, but got Unknown
//IL_045f: Unknown result type (might be due to invalid IL or missing references)
//IL_046c: Expected O, but got Unknown
try
{
Harmony val = new Harmony("Natebag.SledBigLobbies");
int num = 0;
Type type = FindType("Assembly-CSharp", "_Scripts.Managers.LobbyManager") ?? FindType("Assembly-CSharp", "LobbyManager");
if (type == null)
{
((MelonBase)this).LoggerInstance.Warning("LobbyManager type not found — lobby cap won't be raised");
}
else
{
MethodInfo method = type.GetMethod("CreateLobby", BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public);
if (method == null)
{
((MelonBase)this).LoggerInstance.Warning("LobbyManager.CreateLobby method not found");
}
else
{
MethodInfo method2 = typeof(Mod).GetMethod("CreateLobby_Prefix", BindingFlags.Static | BindingFlags.NonPublic);
val.Patch((MethodBase)method, new HarmonyMethod(method2), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
num++;
}
}
Type type2 = FindType("Il2CppFishyEOS", "FishNet.Transporting.FishyEOSPlugin.FishyEOS") ?? FindType("Fishnet.Plugins.FishyEOS", "FishNet.Transporting.FishyEOSPlugin.FishyEOS") ?? FindTypeByShortName("FishyEOS");
if (type2 != null)
{
MethodInfo method3 = type2.GetMethod("SetMaximumClients", BindingFlags.Instance | BindingFlags.Public, null, new Type[1] { typeof(int) }, null);
if (method3 != null)
{
MethodInfo method4 = typeof(Mod).GetMethod("SetMaximumClients_Prefix", BindingFlags.Static | BindingFlags.NonPublic);
val.Patch((MethodBase)method3, new HarmonyMethod(method4), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
num++;
}
}
Type type3 = FindType("Il2CppFishNet.Runtime", "FishNet.Transporting.Tugboat.Tugboat") ?? FindType("FishNet.Runtime", "FishNet.Transporting.Tugboat.Tugboat") ?? FindTypeByShortName("Tugboat");
if (type3 != null)
{
MethodInfo method5 = type3.GetMethod("SetMaximumClients", BindingFlags.Instance | BindingFlags.Public, null, new Type[1] { typeof(int) }, null);
if (method5 != null)
{
MethodInfo method6 = typeof(Mod).GetMethod("SetMaximumClients_Prefix", BindingFlags.Static | BindingFlags.NonPublic);
val.Patch((MethodBase)method5, new HarmonyMethod(method6), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
num++;
}
}
Type type4 = FindType("com.rlabrecque.steamworks.net", "Steamworks.SteamMatchmaking") ?? FindTypeByShortName("SteamMatchmaking");
if (type4 != null)
{
MethodInfo method7 = type4.GetMethod("CreateLobby", BindingFlags.Static | BindingFlags.Public);
if (method7 != null)
{
MethodInfo method8 = typeof(Mod).GetMethod("Steam_CreateLobby_Prefix", BindingFlags.Static | BindingFlags.NonPublic);
val.Patch((MethodBase)method7, new HarmonyMethod(method8), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
num++;
}
else
{
((MelonBase)this).LoggerInstance.Warning("SteamMatchmaking.CreateLobby not found");
}
MethodInfo method9 = type4.GetMethod("SetLobbyMemberLimit", BindingFlags.Static | BindingFlags.Public);
if (method9 != null)
{
MethodInfo method10 = typeof(Mod).GetMethod("Steam_SetLobbyMemberLimit_Prefix", BindingFlags.Static | BindingFlags.NonPublic);
val.Patch((MethodBase)method9, new HarmonyMethod(method10), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
num++;
}
else
{
((MelonBase)this).LoggerInstance.Warning("SteamMatchmaking.SetLobbyMemberLimit not found");
}
}
else
{
((MelonBase)this).LoggerInstance.Warning("SteamMatchmaking type not found — Steam lobby cap won't be raised");
}
if (type != null)
{
MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
foreach (MethodInfo methodInfo in methods)
{
if (!(methodInfo.Name != "AddAttribute") && methodInfo.GetParameters().Length >= 3)
{
MethodInfo method11 = typeof(Mod).GetMethod("AddAttribute_Prefix", BindingFlags.Static | BindingFlags.NonPublic);
val.Patch((MethodBase)methodInfo, new HarmonyMethod(method11), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
num++;
break;
}
}
}
Type type5 = FindType("Assembly-CSharp", "LobbySettings");
if (type5 != null)
{
int num2 = 0;
ConstructorInfo[] constructors = type5.GetConstructors(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
foreach (ConstructorInfo constructorInfo in constructors)
{
if (constructorInfo.GetParameters().Length >= 5)
{
MethodInfo method12 = typeof(Mod).GetMethod("LobbySettings_Ctor_Postfix", BindingFlags.Static | BindingFlags.NonPublic);
val.Patch((MethodBase)constructorInfo, (HarmonyMethod)null, new HarmonyMethod(method12), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
num2++;
}
}
if (num2 > 0)
{
num++;
}
else
{
((MelonBase)this).LoggerInstance.Warning("LobbySettings ctor with maxPlayers param not found");
}
}
else
{
((MelonBase)this).LoggerInstance.Warning("LobbySettings type not found");
}
Type type6 = FindType("Assembly-CSharp", "_Scripts.UI.Pre_Game.UICreateLobby") ?? FindTypeByShortName("UICreateLobby");
if (type6 != null)
{
MethodInfo method13 = type6.GetMethod("ShowPanel", BindingFlags.Instance | BindingFlags.Public);
if (method13 != null)
{
MethodInfo method14 = typeof(Mod).GetMethod("UICreateLobby_ShowPanel_Postfix", BindingFlags.Static | BindingFlags.NonPublic);
val.Patch((MethodBase)method13, (HarmonyMethod)null, new HarmonyMethod(method14), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
num++;
}
else
{
((MelonBase)this).LoggerInstance.Warning("UICreateLobby.ShowPanel not found — vanilla slider stays capped");
}
}
else
{
((MelonBase)this).LoggerInstance.Warning("UICreateLobby type not found — vanilla slider stays capped");
}
((MelonBase)this).LoggerInstance.Msg($"SledBigLobbies v{"0.1.0"} ready — host cap = {60}, {num} patches installed.");
if (num == 0)
{
((MelonBase)this).LoggerInstance.Warning("No patches installed — game may have updated; mod is no-op until updated.");
}
}
catch (Exception value)
{
((MelonBase)this).LoggerInstance.Error($"SledBigLobbies init failed: {value}");
}
}
private static void CreateLobby_Prefix(ref int maxPlayers)
{
try
{
int value = maxPlayers;
if (maxPlayers < 60)
{
maxPlayers = 60;
}
MelonLogger.Msg($"[SledBigLobbies] CreateLobby: maxPlayers {value}->{maxPlayers}");
}
catch
{
}
}
private static void UICreateLobby_ShowPanel_Postfix(object __instance)
{
try
{
object obj = ReadMember(__instance, "maxPlayersSlider");
if (obj == null)
{
if (!_uiSliderWarned)
{
MelonLogger.Warning("[SledBigLobbies] maxPlayersSlider not readable on UICreateLobby");
_uiSliderWarned = true;
}
return;
}
object obj2 = ReadMember(obj, "slider");
if (obj2 == null)
{
if (!_uiSliderWarned)
{
MelonLogger.Warning("[SledBigLobbies] inner slider not readable on MySliderUI");
_uiSliderWarned = true;
}
return;
}
PropertyInfo property = obj2.GetType().GetProperty("maxValue", BindingFlags.Instance | BindingFlags.Public);
PropertyInfo property2 = obj2.GetType().GetProperty("minValue", BindingFlags.Instance | BindingFlags.Public);
if (property == null)
{
if (!_uiSliderWarned)
{
MelonLogger.Warning("[SledBigLobbies] Slider.maxValue property missing");
_uiSliderWarned = true;
}
return;
}
float num = (float)(property.GetValue(obj2) ?? ((object)0f));
if (num < 60f)
{
property.SetValue(obj2, 60f);
MelonLogger.Msg($"[SledBigLobbies] UICreateLobby slider max: {num} -> {60}");
}
if (property2 != null)
{
float num2 = (float)(property2.GetValue(obj2) ?? ((object)0f));
if (num2 > 1f)
{
property2.SetValue(obj2, 1f);
MelonLogger.Msg($"[SledBigLobbies] UICreateLobby slider min: {num2} -> {1}");
}
}
TryForceCrossplay(__instance);
}
catch (Exception ex)
{
if (!_uiSliderWarned)
{
MelonLogger.Warning("[SledBigLobbies] UICreateLobby_ShowPanel_Postfix: " + ex.Message);
_uiSliderWarned = true;
}
}
}
private static void TryForceCrossplay(object createLobbyUI)
{
try
{
Type type = createLobbyUI.GetType();
bool value = false;
PropertyInfo property = type.GetProperty("_hasCrossplayPrivilege", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (property != null && property.CanWrite)
{
property.SetValue(createLobbyUI, true);
value = true;
}
else
{
FieldInfo field = type.GetField("_hasCrossplayPrivilege", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (field != null)
{
field.SetValue(createLobbyUI, true);
value = true;
}
}
object obj = null;
PropertyInfo property2 = type.GetProperty("crossplayToggle", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (property2 != null && property2.CanRead)
{
obj = property2.GetValue(createLobbyUI);
}
if (obj == null)
{
FieldInfo field2 = type.GetField("crossplayToggle", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (field2 != null)
{
obj = field2.GetValue(createLobbyUI);
}
}
bool value2 = false;
bool value3 = false;
if (obj != null)
{
object obj2 = obj.GetType().GetProperty("gameObject", BindingFlags.Instance | BindingFlags.Public)?.GetValue(obj);
if (obj2 != null)
{
MethodInfo method = obj2.GetType().GetMethod("SetActive", new Type[1] { typeof(bool) });
if (method != null)
{
method.Invoke(obj2, new object[1] { true });
value2 = true;
}
}
PropertyInfo property3 = obj.GetType().GetProperty("interactable", BindingFlags.Instance | BindingFlags.Public);
if (property3 != null && property3.CanWrite)
{
property3.SetValue(obj, true);
value3 = true;
}
}
if (!_crossplayLogged)
{
_crossplayLogged = true;
MelonLogger.Msg($"[SledBigLobbies] crossplay force: privilege={value} go.SetActive={value2} interactable={value3} (toggle={((obj != null) ? "found" : "null")})");
}
}
catch (Exception ex)
{
if (!_crossplayLogged)
{
_crossplayLogged = true;
MelonLogger.Warning("[SledBigLobbies] TryForceCrossplay: " + ex.Message);
}
}
}
private static object ReadMember(object owner, string name)
{
if (owner == null)
{
return null;
}
Type type = owner.GetType();
try
{
PropertyInfo property = type.GetProperty(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (property != null && property.CanRead)
{
return property.GetValue(owner);
}
}
catch
{
}
try
{
FieldInfo field = type.GetField(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (field != null)
{
return field.GetValue(owner);
}
}
catch
{
}
return null;
}
private static void SetMaximumClients_Prefix(ref int value)
{
try
{
int num = 60;
int value2 = value;
if (value < num)
{
value = num;
}
MelonLogger.Msg($"[SledBigLobbies] SetMaximumClients: vanilla wanted {value2}, rewrote to {value}");
}
catch
{
}
}
private static void Steam_CreateLobby_Prefix(ref int cMaxMembers)
{
try
{
int num = 60;
int value = cMaxMembers;
if (cMaxMembers < num)
{
cMaxMembers = num;
}
MelonLogger.Msg($"[SledBigLobbies] Steam CreateLobby: vanilla wanted cMaxMembers={value}, rewrote to {cMaxMembers}");
}
catch
{
}
}
private static void Steam_SetLobbyMemberLimit_Prefix(ref int cMaxMembers)
{
try
{
int num = 60;
int value = cMaxMembers;
if (cMaxMembers < num)
{
cMaxMembers = num;
}
MelonLogger.Msg($"[SledBigLobbies] Steam SetLobbyMemberLimit: vanilla wanted {value}, rewrote to {cMaxMembers}");
}
catch
{
}
}
private static void AddAttribute_Prefix(object lobby, object type, ref object value)
{
try
{
int num;
try
{
num = Convert.ToInt32(type);
}
catch
{
return;
}
if (num == 9)
{
EnsureBoxLookup();
MethodInfo methodInfo = _objectOpImplicitFromInt ?? _int32OpImplicitFromInt;
if (!(methodInfo == null))
{
int num2 = 60;
string value2 = value?.GetType().FullName ?? "(null)";
object obj2 = methodInfo.Invoke(null, new object[1] { num2 });
value = obj2;
MelonLogger.Msg($"[SledBigLobbies] AddAttribute MAXPLAYERS: replaced ({value2}) -> {methodInfo.DeclaringType?.Name}({num2})");
TryForceLobbyMaxMembers(lobby, (uint)num2);
}
}
}
catch (Exception ex)
{
MelonLogger.Warning("[SledBigLobbies] AddAttribute_Prefix: " + ex.Message);
}
}
private static void TryForceLobbyMaxMembers(object lobby, uint target)
{
if (lobby == null)
{
return;
}
try
{
Type type = lobby.GetType();
PropertyInfo property = type.GetProperty("MaxNumLobbyMembers", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (property != null && property.CanWrite)
{
property.SetValue(lobby, target);
if (!_lobbyMutLogged)
{
_lobbyMutLogged = true;
MelonLogger.Msg($"[SledBigLobbies] Lobby.MaxNumLobbyMembers <- {target} via property");
}
return;
}
FieldInfo field = type.GetField("MaxNumLobbyMembers", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (field != null)
{
field.SetValue(lobby, target);
if (!_lobbyMutLogged)
{
_lobbyMutLogged = true;
MelonLogger.Msg($"[SledBigLobbies] Lobby.MaxNumLobbyMembers <- {target} via field");
}
}
else if (!_lobbyMutLogged)
{
_lobbyMutLogged = true;
string value = string.Join(",", (from x in type.GetProperties(BindingFlags.Instance | BindingFlags.Public)
select "p:" + x.Name).Concat(from x in type.GetFields(BindingFlags.Instance | BindingFlags.Public)
select "f:" + x.Name));
MelonLogger.Msg($"[SledBigLobbies] no MaxNumLobbyMembers on Lobby type={type.FullName} members=[{value}]");
}
}
catch (Exception ex)
{
MelonLogger.Warning("[SledBigLobbies] TryForceLobbyMaxMembers: " + ex.Message);
}
}
private static void EnsureBoxLookup()
{
if (_boxLookupAttempted)
{
return;
}
_boxLookupAttempted = true;
try
{
Type type = null;
Type type2 = null;
Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
foreach (Assembly assembly in assemblies)
{
if (type == null)
{
try
{
type = assembly.GetType("Il2CppSystem.Object");
}
catch
{
}
}
if (type2 == null)
{
try
{
type2 = assembly.GetType("Il2CppSystem.Int32");
}
catch
{
}
}
if (type != null && type2 != null)
{
break;
}
}
_objectOpImplicitFromInt = FindOpImplicitFromInt(type);
_int32OpImplicitFromInt = FindOpImplicitFromInt(type2);
if (_shapeLogged)
{
return;
}
_shapeLogged = true;
MelonLogger.Msg("[SledBigLobbies] box lookup: ObjectType=" + (type?.FullName ?? "null") + " Int32Type=" + (type2?.FullName ?? "null"));
MelonLogger.Msg($"[SledBigLobbies] box paths: Object.op_Implicit(int)={_objectOpImplicitFromInt != null}, Int32.op_Implicit(int)={_int32OpImplicitFromInt != null}");
if (!(_objectOpImplicitFromInt == null) || !(_int32OpImplicitFromInt == null) || !(type != null))
{
return;
}
string text = string.Join(",", from m in type.GetMethods(BindingFlags.Static | BindingFlags.Public)
where m.Name.StartsWith("op_")
select $"{m.Name}({string.Join(",", from p in m.GetParameters()
select p.ParameterType.Name)})->{m.ReturnType.Name}");
MelonLogger.Msg("[SledBigLobbies] Object op_* methods: [" + text + "]");
}
catch (Exception ex)
{
MelonLogger.Warning("[SledBigLobbies] EnsureBoxLookup: " + ex.Message);
}
}
private static void LobbySettings_Ctor_Postfix(object __instance)
{
try
{
if (__instance == null)
{
return;
}
Type type = __instance.GetType();
int num = 60;
int? value = null;
object obj = null;
PropertyInfo property = type.GetProperty("maxPlayers", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (property != null && property.CanRead && property.CanWrite)
{
try
{
value = (int)(property.GetValue(__instance) ?? ((object)0));
obj = property;
}
catch
{
}
}
if (obj == null)
{
FieldInfo field = type.GetField("maxPlayers", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (field != null)
{
try
{
value = (int)(field.GetValue(__instance) ?? ((object)0));
obj = field;
}
catch
{
}
}
}
if (!_lsLoggedShape)
{
_lsLoggedShape = true;
MelonLogger.Msg($"[SledBigLobbies] LobbySettings ctor: type={type.FullName} writeVia={obj?.GetType().Name ?? "(null)"} current={value}");
}
if (obj != null && value.HasValue && value.Value < num)
{
if (obj is PropertyInfo propertyInfo)
{
propertyInfo.SetValue(__instance, num);
}
else if (obj is FieldInfo fieldInfo)
{
fieldInfo.SetValue(__instance, num);
}
MelonLogger.Msg($"[SledBigLobbies] LobbySettings.maxPlayers: {value} -> {num}");
}
}
catch (Exception ex)
{
MelonLogger.Warning("[SledBigLobbies] LobbySettings_Ctor_Postfix: " + ex.Message);
}
}
private static MethodInfo FindOpImplicitFromInt(Type onType)
{
if (onType == null)
{
return null;
}
MethodInfo[] methods = onType.GetMethods(BindingFlags.Static | BindingFlags.Public);
foreach (MethodInfo methodInfo in methods)
{
if (!(methodInfo.Name != "op_Implicit"))
{
ParameterInfo[] parameters = methodInfo.GetParameters();
if (parameters.Length == 1 && parameters[0].ParameterType == typeof(int))
{
return methodInfo;
}
}
}
return null;
}
private static Type FindType(string asmHint, string fullName)
{
try
{
string[] array = new string[3]
{
fullName,
"Il2Cpp." + fullName,
"Il2Cpp" + fullName
};
Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
foreach (Assembly assembly in assemblies)
{
string[] array2 = array;
foreach (string name in array2)
{
Type type;
try
{
type = assembly.GetType(name);
}
catch
{
continue;
}
if (type != null)
{
return type;
}
}
}
int num = fullName.LastIndexOf('.');
string text = ((num >= 0) ? fullName.Substring(num + 1) : fullName);
assemblies = AppDomain.CurrentDomain.GetAssemblies();
foreach (Assembly assembly2 in assemblies)
{
Type[] types;
try
{
types = assembly2.GetTypes();
}
catch (ReflectionTypeLoadException ex)
{
types = ex.Types;
}
catch
{
continue;
}
Type[] array3 = types;
foreach (Type type2 in array3)
{
if (!(type2 == null) && !(type2.Name != text) && type2.FullName != null && (type2.FullName.EndsWith("." + fullName) || type2.FullName.EndsWith(fullName) || type2.FullName == fullName))
{
return type2;
}
}
}
}
catch
{
}
return null;
}
private static Type FindTypeByShortName(string shortName)
{
try
{
Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
foreach (Assembly assembly in assemblies)
{
Type[] types;
try
{
types = assembly.GetTypes();
}
catch (ReflectionTypeLoadException ex)
{
types = ex.Types;
}
catch
{
continue;
}
Type[] array = types;
foreach (Type type in array)
{
if (!(type == null) && type.Name == shortName)
{
return type;
}
}
}
}
catch
{
}
return null;
}
}
