using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Core.Logging.Interpolation;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using Fusion;
using HarmonyLib;
using Il2CppSystem;
using Microsoft.CodeAnalysis;
using TMPro;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("ShiftMorePlayers")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.4.0.0")]
[assembly: AssemblyInformationalVersion("1.4.0+888776ba78582efc2803e8b6c2b2c159b02cec0c")]
[assembly: AssemblyProduct("ShiftMorePlayers")]
[assembly: AssemblyTitle("ShiftMorePlayers")]
[assembly: AssemblyVersion("1.4.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[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 ShiftMorePlayers
{
public static class Patches
{
[HarmonyPatch(typeof(NetworkRunner), "StartGame")]
public static class FusionStartGamePatch
{
public static void Prefix(StartGameArgs args)
{
//IL_004a: Unknown result type (might be due to invalid IL or missing references)
//IL_0051: Expected O, but got Unknown
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Expected O, but got Unknown
int selectedMaxPlayers = Plugin.SelectedMaxPlayers;
bool flag = default(bool);
try
{
args.PlayerCount = new Nullable<int>(selectedMaxPlayers);
ManualLogSource log = Plugin.Log;
BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(47, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[ShiftMorePlayers] StartGameArgs.PlayerCount = ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(selectedMaxPlayers);
}
log.LogInfo(val);
}
catch (Exception ex)
{
ManualLogSource log2 = Plugin.Log;
BepInExErrorLogInterpolatedStringHandler val2 = new BepInExErrorLogInterpolatedStringHandler(46, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("[ShiftMorePlayers] Failed to set PlayerCount: ");
((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(ex.Message);
}
log2.LogError(val2);
}
}
}
[HarmonyPatch]
public static class SteamCreateLobbyPatch
{
private static MethodBase _target;
public static bool Prepare()
{
_target = FindDeclaredMethod(FindLoadedType("Steamworks.SteamMatchmaking"), "CreateLobby", 2);
if (_target == null)
{
Plugin.Log.LogInfo((object)"[ShiftMorePlayers] Steam matchmaking is absent; skipping the Steam lobby limit patch.");
}
return _target != null;
}
public static MethodBase TargetMethod()
{
return _target;
}
public static void Prefix(ref int cMaxMembers)
{
cMaxMembers = Plugin.SelectedMaxPlayers;
}
}
[HarmonyPatch]
public static class PlatformHostLobbyPatch
{
public static IEnumerable<MethodBase> TargetMethods()
{
Type[] array = new Type[3]
{
typeof(PlatformManager),
GetGameType("PlatformManager_Steam"),
GetGameType("PlatformManager_Xbox")
};
HashSet<MethodBase> seen = new HashSet<MethodBase>();
Type[] array2 = array;
bool flag = default(bool);
foreach (Type type in array2)
{
MethodBase methodBase = FindDeclaredMethod(type, "HostLobby", 0);
if (methodBase != null && seen.Add(methodBase))
{
ManualLogSource log = Plugin.Log;
BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(38, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[ShiftMorePlayers] Patching ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(type.Name);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(".HostLobby");
}
log.LogInfo(val);
yield return methodBase;
}
}
}
public static void Prefix()
{
RestorePlatformPlayerLimit();
}
public static void Postfix()
{
RestorePlatformPlayerLimit();
}
}
[HarmonyPatch]
public static class XboxFullLobbyDirectJoinPatch
{
private static MethodBase _target;
private static PropertyInfo _sessionManagerProperty;
private static PropertyInfo _lastJoinFailedDueToFullProperty;
private static PropertyInfo _currentSessionHandleProperty;
private static bool _loggedArmed;
public static bool Prepare()
{
Type gameType = GetGameType("PlatformManager_Xbox");
Type type = FindLoadedType("HLG.Runtime.GameCore.GameCoreSessionManager");
_target = FindDeclaredMethod(gameType, "OnJoinSessionCompleted", 1);
_sessionManagerProperty = gameType?.GetProperty("gamecoreSessionManager", BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
_lastJoinFailedDueToFullProperty = type?.GetProperty("LastJoinFailedDueToSessionFull", BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
_currentSessionHandleProperty = type?.GetProperty("CurrentSessionHandle", BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (gameType == null)
{
Plugin.Log.LogInfo((object)"[ShiftMorePlayers] Xbox platform is absent; skipping the full-lobby direct join fallback.");
return false;
}
if (_target == null || _sessionManagerProperty == null || _lastJoinFailedDueToFullProperty == null || _currentSessionHandleProperty == null)
{
Plugin.Log.LogInfo((object)"[ShiftMorePlayers] Xbox full-lobby direct join fallback is not present on this build; skipping it.");
return false;
}
if (!_loggedArmed)
{
_loggedArmed = true;
Plugin.Log.LogInfo((object)"[ShiftMorePlayers] Xbox full-lobby direct join fallback armed.");
}
return true;
}
public static MethodBase TargetMethod()
{
return _target;
}
public static void Prefix(object __instance, ref bool success)
{
//IL_0059: Unknown result type (might be due to invalid IL or missing references)
//IL_005f: Expected O, but got Unknown
if (success)
{
return;
}
try
{
object value = _sessionManagerProperty.GetValue(__instance);
if (value != null)
{
bool num = Convert.ToBoolean(_lastJoinFailedDueToFullProperty.GetValue(value));
object value2 = _currentSessionHandleProperty.GetValue(value);
if (num && value2 != null)
{
success = true;
Plugin.Log.LogWarning((object)"[ShiftMorePlayers] Xbox MPSD lobby is full; bypassing its 3-member template and joining the Fusion room directly. Every Xbox player joining beyond the vanilla limit must have ShiftMorePlayers installed.");
}
}
}
catch (Exception ex)
{
ManualLogSource log = Plugin.Log;
bool flag = default(bool);
BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(64, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[ShiftMorePlayers] Xbox full-lobby direct join fallback failed: ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
}
log.LogError(val);
}
}
}
[HarmonyPatch]
public static class StartLobbyPatch
{
private static MethodBase _target;
public static bool Prepare()
{
if (MaxPlayersDropdownProperty == null)
{
Plugin.Log.LogInfo((object)"[ShiftMorePlayers] This platform has no lobby-size dropdown; skipping the dropdown selection patch.");
return false;
}
_target = FindDeclaredMethod(typeof(CreateLobbySettings), "StartLobby", 0);
return _target != null;
}
public static MethodBase TargetMethod()
{
return _target;
}
public static void Prefix(CreateLobbySettings __instance)
{
//IL_006d: Unknown result type (might be due to invalid IL or missing references)
//IL_0073: Expected O, but got Unknown
//IL_003b: Unknown result type (might be due to invalid IL or missing references)
//IL_0041: Expected O, but got Unknown
bool flag = default(bool);
try
{
Plugin.SelectedMaxPlayers = ReadSelectedMaxPlayers(__instance);
SetLobbyPlayerLimit(__instance, Plugin.SelectedMaxPlayers);
RestorePlatformPlayerLimit();
if (_lastLoggedSelectedMaxPlayers != Plugin.SelectedMaxPlayers)
{
_lastLoggedSelectedMaxPlayers = Plugin.SelectedMaxPlayers;
ManualLogSource log = Plugin.Log;
BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(47, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[ShiftMorePlayers] Host selected max players = ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(Plugin.SelectedMaxPlayers);
}
log.LogInfo(val);
}
}
catch (Exception ex)
{
ManualLogSource log2 = Plugin.Log;
BepInExErrorLogInterpolatedStringHandler val2 = new BepInExErrorLogInterpolatedStringHandler(56, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("[ShiftMorePlayers] Failed to read max players dropdown: ");
((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(ex.Message);
}
log2.LogError(val2);
}
}
}
[HarmonyPatch(typeof(FusionNetworkManager), "SpawnPlayerInGameScene")]
public static class SpawnPlayerLogPatch
{
public static void Postfix(PlayerRef player, int index)
{
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Expected O, but got Unknown
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
ManualLogSource log = Plugin.Log;
bool flag = default(bool);
BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(44, 2, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[ShiftMorePlayers] Spawned player ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<PlayerRef>(player);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" at index ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(index);
}
log.LogInfo(val);
}
}
[HarmonyPatch]
public static class ExtendMaxPlayersDropdownPatch
{
private static MethodBase _target;
public static bool Prepare()
{
if (MaxPlayersDropdownProperty == null)
{
Plugin.Log.LogInfo((object)"[ShiftMorePlayers] This platform has no lobby-size dropdown; skipping dropdown extension.");
return false;
}
_target = FindDeclaredMethod(typeof(CreateLobbySettings), "UpdateDropdownLanguage", 0) ?? FindDeclaredMethod(typeof(CreateLobbySettings), "OnEnable", 0);
if (_target == null)
{
Plugin.Log.LogWarning((object)"[ShiftMorePlayers] No lobby-menu refresh method was found; dropdown extension is unavailable.");
}
return _target != null;
}
public static MethodBase TargetMethod()
{
return _target;
}
public static void Postfix(CreateLobbySettings __instance)
{
//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
//IL_00d1: Expected O, but got Unknown
//IL_0067: Unknown result type (might be due to invalid IL or missing references)
//IL_0071: 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
bool flag = default(bool);
try
{
TMP_Dropdown val = FindMaxPlayersDropdown(__instance, forceRescan: true);
if ((Object)(object)val == (Object)null || val.options == null)
{
SetLobbyPlayerLimit(__instance, Plugin.MaxPlayers.Value);
return;
}
int value = Plugin.MaxPlayers.Value;
if (val.options.Count < value)
{
while (val.options.Count < value)
{
int num = val.options.Count + 1;
val.options.Add(new OptionData(num.ToString()));
}
val.RefreshShownValue();
ManualLogSource log = Plugin.Log;
BepInExInfoLogInterpolatedStringHandler val2 = new BepInExInfoLogInterpolatedStringHandler(60, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("[ShiftMorePlayers] Max players dropdown extended to ");
((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<int>(value);
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" options");
}
log.LogInfo(val2);
}
}
catch (Exception ex)
{
ManualLogSource log2 = Plugin.Log;
BepInExErrorLogInterpolatedStringHandler val3 = new BepInExErrorLogInterpolatedStringHandler(58, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val3).AppendLiteral("[ShiftMorePlayers] Failed to extend max players dropdown: ");
((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>(ex.Message);
}
log2.LogError(val3);
}
}
}
private const BindingFlags DeclaredInstanceMembers = BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
private const BindingFlags DeclaredStaticMembers = BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;
private static readonly PropertyInfo MaxPlayersDropdownProperty = typeof(CreateLobbySettings).GetProperty("maxPlayersDropdown", BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
private static readonly PropertyInfo LobbyMaxPlayersProperty = typeof(CreateLobbySettings).GetProperty("maxPlayers", BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
private static readonly PropertyInfo PlatformMaxPlayersProperty = typeof(PlatformManager).GetProperty("s_MAXPLAYERS", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
private static int _loggedDropdownInstanceId;
private static int _searchedDropdownOwnerId;
private static TMP_Dropdown _cachedDropdown;
private static bool _dropdownSearchCompleted;
private static bool _loggedDropdownFallback;
private static bool _loggedMissingLobbyLimit;
private static bool _loggedMissingPlatformLimit;
private static int _lastLoggedSelectedMaxPlayers = -1;
private static MethodInfo FindDeclaredMethod(Type type, string name, int parameterCount = -1)
{
if (type == null)
{
return null;
}
BindingFlags bindingAttr = BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;
MethodInfo[] methods = type.GetMethods(bindingAttr);
foreach (MethodInfo methodInfo in methods)
{
if (methodInfo.Name == name && (parameterCount < 0 || methodInfo.GetParameters().Length == parameterCount))
{
return methodInfo;
}
}
return null;
}
private static Type GetGameType(string name)
{
return typeof(PlatformManager).Assembly.GetType(name, throwOnError: false);
}
private static Type FindLoadedType(string fullName)
{
Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
for (int i = 0; i < assemblies.Length; i++)
{
Type type = assemblies[i].GetType(fullName, throwOnError: false);
if (type != null)
{
return type;
}
}
return null;
}
private static TMP_Dropdown FindMaxPlayersDropdown(CreateLobbySettings instance, bool forceRescan = false)
{
//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
//IL_01ef: Expected O, but got Unknown
if ((Object)(object)instance == (Object)null)
{
return null;
}
try
{
object? obj = MaxPlayersDropdownProperty?.GetValue(instance);
TMP_Dropdown val = (TMP_Dropdown)((obj is TMP_Dropdown) ? obj : null);
if (val != null && (Object)(object)val != (Object)null)
{
return val;
}
}
catch
{
}
int instanceID = ((Object)instance).GetInstanceID();
if (!forceRescan && _dropdownSearchCompleted && _searchedDropdownOwnerId == instanceID)
{
return _cachedDropdown;
}
TMP_Dropdown val2 = null;
int num = int.MinValue;
foreach (TMP_Dropdown componentsInChild in ((Component)instance).GetComponentsInChildren<TMP_Dropdown>(true))
{
if ((Object)(object)componentsInChild == (Object)null)
{
continue;
}
int num2 = 0;
GameObject gameObject = ((Component)componentsInChild).gameObject;
string obj3 = ((gameObject == null) ? null : ((Object)gameObject).name?.ToLowerInvariant()) ?? string.Empty;
if (obj3.Contains("max"))
{
num2 += 300;
}
if (obj3.Contains("player"))
{
num2 += 300;
}
if (obj3.Contains("type"))
{
num2 -= 200;
}
int num3 = componentsInChild.options?.Count ?? 0;
int num4 = 0;
for (int i = 0; i < num3; i++)
{
OptionData obj4 = componentsInChild.options[i];
if (int.TryParse((obj4 != null) ? obj4.text : null, out var _))
{
num4++;
}
}
num2 = ((num3 <= 0 || num4 != num3) ? (num2 + num4 * 20) : (num2 + (1000 + Math.Min(num3, 250))));
if (num2 > num)
{
num = num2;
val2 = componentsInChild;
}
}
if (num < 600)
{
val2 = null;
}
_searchedDropdownOwnerId = instanceID;
_dropdownSearchCompleted = true;
_cachedDropdown = val2;
if ((Object)(object)val2 != (Object)null)
{
int instanceID2 = ((Object)val2).GetInstanceID();
if (_loggedDropdownInstanceId != instanceID2)
{
_loggedDropdownInstanceId = instanceID2;
ManualLogSource log = Plugin.Log;
bool flag = default(bool);
BepInExInfoLogInterpolatedStringHandler val3 = new BepInExInfoLogInterpolatedStringHandler(68, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val3).AppendLiteral("[ShiftMorePlayers] Max players dropdown resolved from UI hierarchy: ");
GameObject gameObject2 = ((Component)val2).gameObject;
((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>((gameObject2 != null) ? ((Object)gameObject2).name : null);
}
log.LogInfo(val3);
}
}
return val2;
}
private static void SetLobbyPlayerLimit(CreateLobbySettings instance, int maxPlayers)
{
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
//IL_0055: Expected O, but got Unknown
try
{
PropertyInfo lobbyMaxPlayersProperty = LobbyMaxPlayersProperty;
if ((object)lobbyMaxPlayersProperty != null && lobbyMaxPlayersProperty.CanWrite)
{
LobbyMaxPlayersProperty.SetValue(instance, maxPlayers);
}
else if (!_loggedMissingLobbyLimit)
{
_loggedMissingLobbyLimit = true;
Plugin.Log.LogWarning((object)"[ShiftMorePlayers] CreateLobbySettings.maxPlayers is unavailable on this build.");
}
}
catch (Exception ex)
{
ManualLogSource log = Plugin.Log;
bool flag = default(bool);
BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(53, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[ShiftMorePlayers] Failed to set lobby player limit: ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
}
log.LogError(val);
}
}
private static int ReadSelectedMaxPlayers(CreateLobbySettings instance)
{
TMP_Dropdown val = FindMaxPlayersDropdown(instance);
if ((Object)(object)val != (Object)null)
{
return Math.Clamp(val.value + 1, 1, Plugin.MaxPlayers.Value);
}
if (!_loggedDropdownFallback)
{
_loggedDropdownFallback = true;
Plugin.Log.LogInfo((object)"[ShiftMorePlayers] This platform has no max players dropdown; using the configured limit.");
}
return Plugin.MaxPlayers.Value;
}
private static void RestorePlatformPlayerLimit()
{
//IL_0053: Unknown result type (might be due to invalid IL or missing references)
//IL_0059: Expected O, but got Unknown
try
{
PropertyInfo platformMaxPlayersProperty = PlatformMaxPlayersProperty;
if ((object)platformMaxPlayersProperty != null && platformMaxPlayersProperty.CanWrite)
{
PlatformMaxPlayersProperty.SetValue(null, Plugin.SelectedMaxPlayers);
}
else if (!_loggedMissingPlatformLimit)
{
_loggedMissingPlatformLimit = true;
Plugin.Log.LogWarning((object)"[ShiftMorePlayers] PlatformManager.s_MAXPLAYERS is unavailable on this build.");
}
}
catch (Exception ex)
{
ManualLogSource log = Plugin.Log;
bool flag = default(bool);
BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(60, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[ShiftMorePlayers] Failed to restore platform player limit: ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
}
log.LogError(val);
}
}
}
[BepInPlugin("com.tntcrafthim.shiftmoreplayers", "ShiftMorePlayers", "1.4.0")]
public class Plugin : BasePlugin
{
public const int DefaultMaxPlayers = 10;
public const int TheoreticalMaxPlayers = 250;
private const string CurrentConfigFileName = "com.tntcrafthim.shiftmoreplayers.cfg";
private const string LegacyConfigFileName = "com.tntcraft.shiftmoreplayers.cfg";
public static ConfigEntry<int> MaxPlayers;
public static ManualLogSource Log;
public static int SelectedMaxPlayers;
public override void Load()
{
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
//IL_0042: Expected O, but got Unknown
//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
//IL_00da: Expected O, but got Unknown
Log = ((BasePlugin)this).Log;
MigrateLegacyConfig();
MaxPlayers = ((BasePlugin)this).Config.Bind<int>("General", "MaxPlayers", 10, new ConfigDescription("Maximum players per session. Vanilla limit is 3. Steam only requires the host to install this mod. Xbox app / Game Pass players joining beyond the platform's 3-member lobby template must also install it. The configurable maximum is Steam's theoretical 250-member lobby ceiling. Values above 10 exceed known gameplay data structures and may break interactions or monster detection.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(2, 250), Array.Empty<object>()));
((BasePlugin)this).Config.Save();
SelectedMaxPlayers = MaxPlayers.Value;
TryPatch(typeof(Patches.FusionStartGamePatch));
TryPatch(typeof(Patches.SteamCreateLobbyPatch));
TryPatch(typeof(Patches.PlatformHostLobbyPatch));
TryPatch(typeof(Patches.XboxFullLobbyDirectJoinPatch));
TryPatch(typeof(Patches.StartLobbyPatch));
TryPatch(typeof(Patches.SpawnPlayerLogPatch));
TryPatch(typeof(Patches.ExtendMaxPlayersDropdownPatch));
ManualLogSource log = Log;
bool flag = default(bool);
BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(62, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("ShiftMorePlayers loaded. Player limit raised to ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(MaxPlayers.Value);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" (vanilla: 3).");
}
log.LogInfo(val);
}
private void MigrateLegacyConfig()
{
//IL_004d: Unknown result type (might be due to invalid IL or missing references)
//IL_0053: Expected O, but got Unknown
string text = Path.Combine(Paths.ConfigPath, "com.tntcrafthim.shiftmoreplayers.cfg");
string text2 = Path.Combine(Paths.ConfigPath, "com.tntcraft.shiftmoreplayers.cfg");
if (!File.Exists(text) && File.Exists(text2))
{
File.Copy(text2, text);
((BasePlugin)this).Config.Reload();
ManualLogSource log = Log;
bool flag = default(bool);
BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(62, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Migrated legacy config to ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("com.tntcrafthim.shiftmoreplayers.cfg");
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("; the old file was kept as a backup.");
}
log.LogInfo(val);
}
}
private static void TryPatch(Type patchClass)
{
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: Expected O, but got Unknown
//IL_0045: Unknown result type (might be due to invalid IL or missing references)
//IL_004b: Expected O, but got Unknown
bool flag = default(bool);
try
{
Harmony.CreateAndPatchAll(patchClass, (string)null);
ManualLogSource log = Log;
BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(10, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Patch OK: ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(patchClass.Name);
}
log.LogInfo(val);
}
catch (Exception ex)
{
ManualLogSource log2 = Log;
BepInExErrorLogInterpolatedStringHandler val2 = new BepInExErrorLogInterpolatedStringHandler(16, 2, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("Patch FAILED: ");
((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(patchClass.Name);
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(": ");
((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<Exception>(ex);
}
log2.LogError(val2);
}
}
}
}
