using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Core.Logging.Interpolation;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using Fusion;
using HarmonyLib;
using Il2CppSystem;
using Il2CppSystem.Collections.Generic;
using Microsoft.CodeAnalysis;
using Steamworks;
using TMPro;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("ShiftAtMidnightMorePlayers")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("ShiftAtMidnightMorePlayers")]
[assembly: AssemblyTitle("ShiftAtMidnightMorePlayers")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[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 ShiftAtMidnightMorePlayers
{
[BepInPlugin("dev.fuzs.shiftatmidnight.moreplayers", "Shift At Midnight More Players", "1.0.3")]
public sealed class Plugin : BasePlugin
{
public const string PluginGuid = "dev.fuzs.shiftatmidnight.moreplayers";
public const string PluginName = "Shift At Midnight More Players";
public const string PluginVersion = "1.0.3";
internal static ManualLogSource Logger;
internal static readonly int[] AllowedPlayerCounts = new int[6] { 1, 2, 3, 6, 8, 16 };
internal static int DesiredLobbyMax = 3;
public const int HardMaxPlayers = 16;
public override void Load()
{
//IL_0055: Unknown result type (might be due to invalid IL or missing references)
//IL_005b: Expected O, but got Unknown
Logger = ((BasePlugin)this).Log;
try
{
DesiredLobbyMax = 3;
ApplyHardCap();
Harmony.CreateAndPatchAll(typeof(Plugin).Assembly, "dev.fuzs.shiftatmidnight.moreplayers");
((BasePlugin)this).Log.LogInfo((object)"Shift At Midnight More Players v1.0.3 carregado! Opções: 1, 2, 3, 6, 8 e 16.");
}
catch (Exception ex)
{
ManualLogSource log = ((BasePlugin)this).Log;
bool flag = default(bool);
BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(27, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Erro ao carregar o plugin:\n");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<Exception>(ex);
}
log.LogError(val);
}
}
internal static void ApplyHardCap()
{
try
{
PlatformManager.s_MAXPLAYERS = 16;
ManualLogSource logger = Logger;
if (logger != null)
{
logger.LogInfo((object)("PlatformManager.s_MAXPLAYERS=" + 16));
}
}
catch (Exception ex)
{
ManualLogSource logger2 = Logger;
if (logger2 != null)
{
logger2.LogWarning((object)("Não foi possível alterar PlatformManager.s_MAXPLAYERS ainda: " + ex.Message));
}
}
}
internal static bool IsAllowedPlayerCount(int value)
{
for (int i = 0; i < AllowedPlayerCounts.Length; i++)
{
if (AllowedPlayerCounts[i] == value)
{
return true;
}
}
return false;
}
internal static int ResolveLobbyMaxPlayers(int requested)
{
if (IsAllowedPlayerCount(requested))
{
return requested;
}
if (requested <= 1)
{
return 1;
}
if (requested <= 2)
{
return 2;
}
if (requested <= 3)
{
return 3;
}
if (requested <= 6)
{
return 6;
}
if (requested <= 8)
{
return 8;
}
return 16;
}
internal static void SetDesiredLobbyMax(int requested)
{
DesiredLobbyMax = ResolveLobbyMaxPlayers(requested);
}
internal static void ForcePendingLobbyMax(string reason)
{
//IL_009d: Unknown result type (might be due to invalid IL or missing references)
//IL_00a4: Expected O, but got Unknown
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: Expected O, but got Unknown
bool flag = default(bool);
try
{
ApplyHardCap();
int num = (PendingLobbySettings.maxPlayers = (DesiredLobbyMax = ResolveLobbyMaxPlayers(DesiredLobbyMax)));
PlatformManager.s_MAXPLAYERS = 16;
ManualLogSource logger = Logger;
if (logger != null)
{
BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(24, 2, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("ForcePendingLobbyMax=");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(num);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" ");
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("(");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(reason);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(")");
}
logger.LogInfo(val);
}
}
catch (Exception ex)
{
ManualLogSource logger2 = Logger;
if (logger2 != null)
{
BepInExErrorLogInterpolatedStringHandler val2 = new BepInExErrorLogInterpolatedStringHandler(32, 2, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("ForcePendingLobbyMax falhou ");
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("(");
((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(reason);
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("): ");
((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<Exception>(ex);
}
logger2.LogError(val2);
}
}
}
internal static int GetEffectiveLobbyMax()
{
int num = ResolveLobbyMaxPlayers(DesiredLobbyMax);
try
{
int maxPlayers = PendingLobbySettings.maxPlayers;
if (IsAllowedPlayerCount(maxPlayers) && maxPlayers > num)
{
return maxPlayers;
}
}
catch
{
}
return num;
}
}
}
namespace ShiftAtMidnightMorePlayers.Patches
{
[HarmonyPatch(typeof(CreateLobbySettings))]
internal static class CreateLobbySettingsPatches
{
[HarmonyPostfix]
[HarmonyPatch("OnEnable")]
private static void OnEnablePostfix(CreateLobbySettings __instance)
{
try
{
Plugin.ApplyHardCap();
RebuildMaxPlayersDropdown(__instance);
}
catch (Exception value)
{
Plugin.Logger.LogError((object)("Patch de CreateLobbySettings.OnEnable " + $"falhou: {value}"));
}
}
[HarmonyPostfix]
[HarmonyPatch("UpdateDropdownLanguage")]
private static void UpdateDropdownLanguagePostfix(CreateLobbySettings __instance)
{
try
{
RebuildMaxPlayersDropdown(__instance);
}
catch (Exception ex)
{
Plugin.Logger.LogError((object)("Patch de UpdateDropdownLanguage falhou: " + ex));
}
}
[HarmonyPrefix]
[HarmonyPatch("ChangeMaxPlayers")]
private static bool ChangeMaxPlayersPrefix(CreateLobbySettings __instance, int players)
{
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_0023: Expected O, but got Unknown
try
{
int num = ResolveFromDropdownOrArg(__instance, players);
ApplyLobbyMax(__instance, num);
ManualLogSource logger = Plugin.Logger;
bool flag = default(bool);
BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(43, 2, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("ChangeMaxPlayers: índice/valor=");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(players);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(", ");
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("resolvido=");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(num);
}
logger.LogInfo(val);
}
catch (Exception ex)
{
Plugin.Logger.LogError((object)("Patch de ChangeMaxPlayers falhou: " + ex));
}
return false;
}
[HarmonyPrefix]
[HarmonyPatch("StartLobby")]
private static void StartLobbyPrefix(CreateLobbySettings __instance)
{
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Expected O, but got Unknown
try
{
int num = ResolveFromDropdownOrArg(__instance, __instance.maxPlayers);
ApplyLobbyMax(__instance, num);
ManualLogSource logger = Plugin.Logger;
bool flag = default(bool);
BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(29, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("StartLobby prefix maxPlayers=");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(num);
}
logger.LogInfo(val);
}
catch (Exception ex)
{
Plugin.Logger.LogError((object)("StartLobby prefix falhou: " + ex));
}
}
[HarmonyPostfix]
[HarmonyPatch("StartLobby")]
private static void StartLobbyPostfix(CreateLobbySettings __instance)
{
try
{
int maxPlayers = ResolveFromDropdownOrArg(__instance, Plugin.DesiredLobbyMax);
ApplyLobbyMax(__instance, maxPlayers);
Plugin.ForcePendingLobbyMax("CreateLobbySettings.StartLobby postfix");
}
catch (Exception ex)
{
Plugin.Logger.LogError((object)("StartLobby postfix falhou: " + ex));
}
}
private static int ResolveFromDropdownOrArg(CreateLobbySettings instance, int players)
{
TMP_Dropdown maxPlayersDropdown = instance.maxPlayersDropdown;
if ((Object)(object)maxPlayersDropdown != (Object)null && maxPlayersDropdown.options != null && maxPlayersDropdown.options.Count > 0)
{
int value = maxPlayersDropdown.value;
if (value >= 0 && value < maxPlayersDropdown.options.Count)
{
string text = maxPlayersDropdown.options[value].text;
if (int.TryParse(text, out var result) && Plugin.IsAllowedPlayerCount(result))
{
return result;
}
if (value >= 0 && value < Plugin.AllowedPlayerCounts.Length)
{
return Plugin.AllowedPlayerCounts[value];
}
}
}
return Plugin.ResolveLobbyMaxPlayers(players);
}
private static void ApplyLobbyMax(CreateLobbySettings instance, int maxPlayers)
{
Plugin.SetDesiredLobbyMax(maxPlayers);
instance.maxPlayers = Plugin.DesiredLobbyMax;
PendingLobbySettings.maxPlayers = Plugin.DesiredLobbyMax;
PlatformManager.s_MAXPLAYERS = 16;
}
private static void RebuildMaxPlayersDropdown(CreateLobbySettings instance)
{
TMP_Dropdown maxPlayersDropdown = instance.maxPlayersDropdown;
if ((Object)(object)maxPlayersDropdown == (Object)null)
{
return;
}
int num = instance.maxPlayers;
if (!Plugin.IsAllowedPlayerCount(num))
{
num = Plugin.DesiredLobbyMax;
}
if (!Plugin.IsAllowedPlayerCount(num))
{
num = 3;
}
maxPlayersDropdown.ClearOptions();
List<string> val = new List<string>();
for (int i = 0; i < Plugin.AllowedPlayerCounts.Length; i++)
{
val.Add(Plugin.AllowedPlayerCounts[i].ToString());
}
maxPlayersDropdown.AddOptions(val);
int num2 = 2;
for (int j = 0; j < Plugin.AllowedPlayerCounts.Length; j++)
{
if (Plugin.AllowedPlayerCounts[j] == num)
{
num2 = j;
break;
}
}
maxPlayersDropdown.SetValueWithoutNotify(num2);
maxPlayersDropdown.RefreshShownValue();
int num3 = Plugin.AllowedPlayerCounts[num2];
ApplyLobbyMax(instance, num3);
Plugin.Logger.LogInfo((object)("Dropdown reconstruído: 1, 2, 3, 8 e 16. " + $"Selecionado={num3}"));
}
}
[HarmonyPatch(typeof(NetworkRunner))]
internal static class NetworkRunnerPatches
{
[HarmonyPrefix]
[HarmonyPatch("StartGame")]
private static void StartGamePrefix(ref StartGameArgs args)
{
//IL_0004: Unknown result type (might be due to invalid IL or missing references)
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: Invalid comparison between Unknown and I4
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
//IL_0048: Expected O, but got Unknown
//IL_0071: Unknown result type (might be due to invalid IL or missing references)
try
{
GameMode gameMode = args.GameMode;
if ((int)gameMode != 5)
{
Plugin.ForcePendingLobbyMax("NetworkRunner.StartGame");
int effectiveLobbyMax = Plugin.GetEffectiveLobbyMax();
args.PlayerCount = new Nullable<int>(effectiveLobbyMax);
ManualLogSource logger = Plugin.Logger;
bool flag = default(bool);
BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(44, 2, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("NetworkRunner.StartGame PlayerCount=");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(effectiveLobbyMax);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" (mode=");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<GameMode>(gameMode);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(")");
}
logger.LogInfo(val);
}
}
catch (Exception ex)
{
Plugin.Logger.LogError((object)("NetworkRunner.StartGame patch falhou: " + ex));
}
}
}
[HarmonyPatch(typeof(FusionNetworkManager))]
internal static class FusionNetworkManagerPatches
{
[HarmonyPrefix]
[HarmonyPatch("StartAsHost")]
private static void StartAsHostPrefix()
{
Plugin.ForcePendingLobbyMax("FusionNetworkManager.StartAsHost");
Plugin.Logger.LogInfo((object)("StartAsHost pending maxPlayers=" + Plugin.GetEffectiveLobbyMax()));
}
}
[HarmonyPatch(typeof(PlatformManager))]
internal static class PlatformManagerHostPatches
{
[HarmonyPrefix]
[HarmonyPatch("HostLobby")]
private static void HostLobbyPrefix()
{
Plugin.ForcePendingLobbyMax("PlatformManager.HostLobby");
}
}
[HarmonyPatch(typeof(PlatformManager_Steam))]
internal static class PlatformManagerSteamHostPatches
{
[HarmonyPrefix]
[HarmonyPatch("HostLobby")]
private static void HostLobbyPrefix()
{
Plugin.ForcePendingLobbyMax("PlatformManager_Steam.HostLobby prefix");
}
[HarmonyPostfix]
[HarmonyPatch("HostLobby")]
private static void HostLobbyPostfix()
{
Plugin.ForcePendingLobbyMax("PlatformManager_Steam.HostLobby postfix");
}
}
[HarmonyPatch(typeof(LobbyUIManager))]
internal static class LobbyUIManagerHostPatches
{
[HarmonyPrefix]
[HarmonyPatch("HostLobby")]
private static void HostLobbyPrefix()
{
Plugin.ForcePendingLobbyMax("LobbyUIManager.HostLobby");
}
}
[HarmonyPatch(typeof(SteamMatchmaking))]
internal static class SteamMatchmakingPatches
{
[HarmonyPrefix]
[HarmonyPatch("CreateLobby")]
private static void CreateLobbyPrefix(ref ELobbyType eLobbyType, ref int cMaxMembers)
{
int effectiveLobbyMax = Plugin.GetEffectiveLobbyMax();
Plugin.Logger.LogInfo((object)("SteamMatchmaking.CreateLobby cMaxMembers " + $"{cMaxMembers} -> {effectiveLobbyMax}"));
cMaxMembers = effectiveLobbyMax;
Plugin.ForcePendingLobbyMax("SteamMatchmaking.CreateLobby");
}
[HarmonyPrefix]
[HarmonyPatch("SetLobbyMemberLimit")]
private static void SetLobbyMemberLimitPrefix(CSteamID steamIDLobby, ref int cMaxMembers)
{
int effectiveLobbyMax = Plugin.GetEffectiveLobbyMax();
if (cMaxMembers != effectiveLobbyMax)
{
Plugin.Logger.LogInfo((object)("SteamMatchmaking.SetLobbyMemberLimit " + $"{cMaxMembers} -> {effectiveLobbyMax}"));
cMaxMembers = effectiveLobbyMax;
}
}
[HarmonyPrefix]
[HarmonyPatch("SetLobbyData")]
private static void SetLobbyDataPrefix(CSteamID steamIDLobby, string pchKey, ref string pchValue)
{
//IL_0064: Unknown result type (might be due to invalid IL or missing references)
//IL_006b: Expected O, but got Unknown
try
{
string maxPlayersKey = PlatformManager_Steam._maxPlayersKey;
if (string.IsNullOrEmpty(maxPlayersKey) || pchKey == null || !string.Equals(pchKey, maxPlayersKey, StringComparison.Ordinal))
{
return;
}
string text = Plugin.GetEffectiveLobbyMax().ToString();
if (!(pchValue == text))
{
ManualLogSource logger = Plugin.Logger;
bool flag = default(bool);
BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(29, 3, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Steam SetLobbyData ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(pchKey);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(": ");
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("'");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(pchValue);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("' -> '");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(text);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("'");
}
logger.LogInfo(val);
pchValue = text;
}
}
catch (Exception ex)
{
Plugin.Logger.LogWarning((object)("SetLobbyData patch falhou: " + ex.Message));
}
}
}
[HarmonyPatch(typeof(PlatformManager))]
internal static class PlatformManagerPatches
{
[HarmonyPostfix]
[HarmonyPatch("Awake")]
private static void AwakePostfix()
{
Plugin.ApplyHardCap();
}
[HarmonyPostfix]
[HarmonyPatch("Init")]
private static void InitPostfix()
{
Plugin.ApplyHardCap();
}
}
}
