using System;
using System.Collections.Generic;
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.Configuration;
using BepInEx.Logging;
using GoblinCleanupMorePlayers.Patches;
using HarmonyLib;
using I2.Loc;
using Microsoft.CodeAnalysis;
using Steamworks;
using TMPro;
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("GoblinCleanupMorePlayers")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+229564aa9c628763782faed15a74d94314182eaf")]
[assembly: AssemblyProduct("More Players")]
[assembly: AssemblyTitle("More Players")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[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]
[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;
}
}
[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 BepInEx
{
[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
[Conditional("CodeGeneration")]
[Embedded]
internal sealed class BepInAutoPluginAttribute : Attribute
{
public BepInAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
{
}
}
}
namespace BepInEx.Preloader.Core.Patching
{
[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
[Conditional("CodeGeneration")]
[Embedded]
internal sealed class PatcherAutoPluginAttribute : Attribute
{
public PatcherAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
{
}
}
}
namespace Microsoft.CodeAnalysis
{
[Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace GoblinCleanupMorePlayers
{
[BepInPlugin("GoblinCleanupMorePlayers", "More Players", "1.0.0")]
public class Plugin : BaseUnityPlugin
{
internal static ManualLogSource Logger;
internal static ConfigEntry<int> ConfigMaxPlayers;
internal static Harmony HarmonyInstance;
public const int VanillaMaxPlayers = 4;
public const string Id = "GoblinCleanupMorePlayers";
public static string Name => "More Players";
public static string Version => "1.0.0";
private void Awake()
{
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_001a: Expected O, but got Unknown
Logger = ((BaseUnityPlugin)this).Logger;
HarmonyInstance = new Harmony("GoblinCleanupMorePlayers");
ConfigMaxPlayers = ((BaseUnityPlugin)this).Config.Bind<int>("General", "MaxPlayers", 8, "Maximum number of players (including yourself). Steam lobbies support up to 250. Range: 1-250.");
if (ConfigMaxPlayers.Value < 1)
{
ConfigMaxPlayers.Value = 1;
}
if (ConfigMaxPlayers.Value > 250)
{
ConfigMaxPlayers.Value = 250;
}
Logger.LogInfo((object)string.Format("Plugin {0} loaded! Max players set to {1}", "GoblinCleanupMorePlayers", ConfigMaxPlayers.Value));
HarmonyInstance.PatchAll(typeof(SteamLobbyPatches));
HarmonyInstance.PatchAll(typeof(MenuManagerPatches));
HarmonyInstance.PatchAll(typeof(DungeonManagerPatches));
HarmonyInstance.PatchAll(typeof(DungeonPlayersPatches));
HarmonyInstance.PatchAll(typeof(LobbiesListManagerPatches));
HarmonyInstance.PatchAll(typeof(RewardsManagerPatches));
Logger.LogInfo((object)"All patches applied");
}
private void OnDestroy()
{
Harmony harmonyInstance = HarmonyInstance;
if (harmonyInstance != null)
{
harmonyInstance.UnpatchSelf();
}
Logger.LogInfo((object)"Plugin unloaded");
}
}
}
namespace GoblinCleanupMorePlayers.Patches
{
public static class DungeonManagerPatches
{
[HarmonyPatch(typeof(DungeonManager), "UpdatePlayerKickout")]
[HarmonyPrefix]
private static bool FixKickoutBounds(DungeonManager __instance)
{
for (int i = 0; i < __instance.kickoutPlayer.Count; i++)
{
__instance.kickoutPlayer[i].SetActive(false);
}
List<GoblinCharacterController> list = new List<GoblinCharacterController>();
foreach (GoblinCharacterController player in DungeonPlayers.instance.players)
{
if (Object.op_Implicit((Object)(object)player) && (Object)(object)player != (Object)(object)GoblinCharacterController.localPlayer)
{
list.Add(player);
}
}
for (int j = 0; j < list.Count; j++)
{
if (j < __instance.kickoutPlayer.Count)
{
__instance.kickoutPlayer[j].SetActive(true);
}
if (j < __instance.txtkickoutNames.Count)
{
((TMP_Text)__instance.txtkickoutNames[j]).text = ((TMP_Text)list[j].playerName).text;
}
}
return false;
}
}
[HarmonyPatch]
public static class DungeonPlayersPatches
{
[HarmonyPatch(typeof(DungeonPlayers), "GetPlayerDefaultSpawnPoint")]
[HarmonyPrefix]
private static bool AllSpawnAtHostRoom(ref Transform __result)
{
DungeonPlayers instance = DungeonPlayers.instance;
if (instance.RoomsspawnPoints.Length == 0)
{
__result = instance.staffRoomSpawnPoint;
}
else
{
__result = instance.RoomsspawnPoints[0];
}
return false;
}
[HarmonyPatch(typeof(DungeonPlayers), "OnStartClient")]
[HarmonyPostfix]
private static void InitSharedRoomState(DungeonPlayers __instance)
{
for (int i = 0; i < __instance.restoreColliders.Length; i++)
{
if ((Object)(object)__instance.restoreColliders[i] != (Object)null)
{
((Component)__instance.restoreColliders[i]).gameObject.SetActive(false);
}
}
for (int j = 1; j < __instance.RoomDoorObject.Length; j++)
{
if ((Object)(object)__instance.RoomDoorObject[j] != (Object)null)
{
__instance.RoomDoorObject[j].SetActive(true);
}
}
if (__instance.RoomDoorObject.Length != 0 && (Object)(object)__instance.RoomDoorObject[0] != (Object)null)
{
__instance.RoomDoorObject[0].SetActive(false);
}
if (__instance.playerFrames.Length != 0 && (Object)(object)__instance.playerFrames[0] != (Object)null)
{
__instance.playerFrames[0].SetDisconnectData("Shared Room", __instance.noAvatarImage);
}
for (int k = 1; k < __instance.playerFrames.Length; k++)
{
if ((Object)(object)__instance.playerFrames[k] != (Object)null)
{
__instance.playerFrames[k].SetDisconnectData("Out of Order", __instance.noAvatarImage);
}
}
}
[HarmonyPatch(typeof(DungeonPlayers), "SetRoomData")]
[HarmonyPrefix]
private static bool SuppressSetRoomData()
{
return false;
}
[HarmonyPatch(typeof(DungeonPlayers), "EnableRoomDoor")]
[HarmonyPrefix]
private static bool SkipNonHostRoomManagement(int playerIndex)
{
return playerIndex == 0;
}
}
public static class LobbiesListManagerPatches
{
[HarmonyPatch(typeof(LobbiesListManager), "UpdateLobbyEntry")]
[HarmonyPostfix]
private static void FixPlayerCountDisplay(LobbyDataEntry lobbyData, CSteamID lobbyID)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
//IL_0049: Unknown result type (might be due to invalid IL or missing references)
//IL_0054: Unknown result type (might be due to invalid IL or missing references)
string text = SteamMatchmaking.GetNumLobbyMembers(lobbyID) + "/" + SteamMatchmaking.GetLobbyMemberLimit(lobbyID);
lobbyData.SetLobbyData(SteamMatchmaking.GetLobbyData(lobbyID, "isFull") == "False", SteamMatchmaking.GetLobbyData(lobbyID, "password"), text, SteamMatchmaking.GetLobbyData(lobbyID, "Level"), SteamMatchmaking.GetLobbyData(lobbyID, "GameVersion") == Application.version);
}
}
public static class MenuManagerPatches
{
[HarmonyPatch(typeof(MenuManager), "OnClick_Host_Steam")]
[HarmonyPrefix]
private static void LogHostClick(MenuManager __instance)
{
Plugin.Logger.LogInfo((object)$"OnClick_Host_Steam: will use maxPlayers={Plugin.ConfigMaxPlayers.Value}");
}
}
public static class RewardsManagerPatches
{
private static T Field<T>(object obj, string name)
{
return (T)AccessTools.Field(obj.GetType(), name).GetValue(obj);
}
private static void SetField(object obj, string name, object value)
{
AccessTools.Field(obj.GetType(), name).SetValue(obj, value);
}
[HarmonyPatch(typeof(RewardsManager), "ShowStats")]
[HarmonyPrefix]
private static bool FixShowStats(RewardsManager __instance, ref Dictionary<CSteamID, PlayerStats> stats, float extraExpMultiplier, float extraTicketsMultiplier)
{
//IL_0067: Unknown result type (might be due to invalid IL or missing references)
//IL_005a: Unknown result type (might be due to invalid IL or missing references)
//IL_0114: Unknown result type (might be due to invalid IL or missing references)
//IL_017e: Unknown result type (might be due to invalid IL or missing references)
//IL_019f: Unknown result type (might be due to invalid IL or missing references)
//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
//IL_0205: Unknown result type (might be due to invalid IL or missing references)
//IL_0222: Unknown result type (might be due to invalid IL or missing references)
//IL_023f: Unknown result type (might be due to invalid IL or missing references)
//IL_025c: Unknown result type (might be due to invalid IL or missing references)
//IL_0279: Unknown result type (might be due to invalid IL or missing references)
//IL_0296: Unknown result type (might be due to invalid IL or missing references)
//IL_03c0: Unknown result type (might be due to invalid IL or missing references)
//IL_03df: Unknown result type (might be due to invalid IL or missing references)
//IL_0375: Unknown result type (might be due to invalid IL or missing references)
//IL_0385: Unknown result type (might be due to invalid IL or missing references)
//IL_03fc: Unknown result type (might be due to invalid IL or missing references)
//IL_0419: Unknown result type (might be due to invalid IL or missing references)
//IL_0443: Unknown result type (might be due to invalid IL or missing references)
//IL_0564: Unknown result type (might be due to invalid IL or missing references)
GameObject obj = Field<GameObject>(__instance, "panelHolder");
TextMeshProUGUI val = Field<TextMeshProUGUI>(__instance, "txtTime");
List<PlayerStatsCard> list = Field<List<PlayerStatsCard>>(__instance, "playerCards");
TextMeshProUGUI val2 = Field<TextMeshProUGUI>(__instance, "ticketsReward");
TextMeshProUGUI val3 = Field<TextMeshProUGUI>(__instance, "expReward");
obj.SetActive(true);
if (DungeonManager.dungeonInstance.GetTime() <= 30f)
{
__instance.taskCount = 0;
((TMP_Text)val).color = Color.red;
}
else
{
((TMP_Text)val).color = Color.white;
}
int num = Mathf.RoundToInt((float)__instance.taskCount * __instance.expMultiplier * extraExpMultiplier);
int num2 = Mathf.RoundToInt((float)__instance.taskCount * __instance.ticketsMultiplier * extraTicketsMultiplier);
SetField(__instance, "expRewardAmount", num);
SetField(__instance, "ticketsRewardAmount", num2);
ProgressionController.AddStackedTickets(num2);
ProgressionController.Instance.AddExpToClaim(num);
((TMP_Text)val2).text = ProgressionController.Instance.GetTicketsToClaim().ToString();
((TMP_Text)val3).text = ProgressionController.Instance.GetExpToClaim().ToString();
foreach (PlayerStatsCard item in list)
{
item.holder.SetActive(false);
}
List<CSteamID> list2 = new List<CSteamID>();
int num3 = -1;
int num4 = 0;
int num5 = 9999;
int num6 = -1;
int num7 = 0;
int num8 = -1;
int num9 = -1;
int num10 = 0;
foreach (KeyValuePair<CSteamID, PlayerStats> stat in stats)
{
if (DungeonPlayers.instance.IsPlayerInLobby(stat.Key))
{
if (num10 >= list.Count)
{
break;
}
PlayerStatsCard val4 = list[num10];
val4.holder.SetActive(true);
((TMP_Text)val4.txtName).text = SteamFriends.GetFriendPersonaName(stat.Key);
((TMP_Text)val4.txtDeaths).text = stat.Value.deads.ToString();
((TMP_Text)val4.txtRestorables).text = stat.Value.restorableObjects.ToString();
((TMP_Text)val4.txtBlood).text = stat.Value.bloodstains.ToString();
((TMP_Text)val4.txtOrganic).text = stat.Value.organicRemains.ToString();
((TMP_Text)val4.txtTraps).text = stat.Value.traps.ToString();
((TMP_Text)val4.txtMana).text = stat.Value.manaObjects.ToString();
((TMP_Text)val4.txtGoldenChests).text = stat.Value.chestsFilled.ToString();
((TMP_Text)val4.txtMonsters).text = stat.Value.monsters.ToString();
int num11 = stat.Value.bloodstains + stat.Value.organicRemains * 2 + stat.Value.restorableObjects * 3 + stat.Value.traps * 4 + stat.Value.manaObjects * 3 + stat.Value.chestsFilled * 5 + stat.Value.monsters * 10 - stat.Value.deads;
if (num11 > num4)
{
num4 = num11;
num3 = num10;
}
else if (num11 < num5)
{
num5 = num11;
num6 = num10;
}
else if (stat.Value.deads > num7)
{
num7 = stat.Value.deads;
num8 = num10;
}
else
{
num9 = num10;
}
list2.Add(stat.Key);
SetNomination(__instance, "lazy", val4.txtTitle);
num10++;
}
}
if (num10 <= 1)
{
SetNomination(__instance, "single", list[0].txtTitle);
return false;
}
if (num3 != -1)
{
SetNomination(__instance, "MVP", list[num3].txtTitle);
}
if (num6 != -1)
{
SetNomination(__instance, "lazy", list[num6].txtTitle);
}
if (num8 != -1)
{
SetNomination(__instance, "death", list[num8].txtTitle);
}
if (num9 != -1 && stats.Count >= 4)
{
PlayerStats val5 = stats[list2[num9]];
int restorableObjects = val5.restorableObjects;
int num12 = 0;
if (val5.bloodstains > restorableObjects)
{
restorableObjects = val5.bloodstains;
num12 = 1;
}
else if (val5.organicRemains > restorableObjects)
{
restorableObjects = val5.organicRemains;
num12 = 2;
}
else if (val5.traps > restorableObjects)
{
restorableObjects = val5.traps;
num12 = 3;
}
else if (val5.manaObjects > restorableObjects)
{
restorableObjects = val5.manaObjects;
num12 = 4;
}
else if (val5.chestsFilled > restorableObjects)
{
restorableObjects = val5.chestsFilled;
num12 = 5;
}
else if (val5.monsters > restorableObjects)
{
restorableObjects = val5.monsters;
num12 = 6;
}
SetNomination(__instance, num12 switch
{
0 => "objects",
1 => "blood",
2 => "organic",
3 => "traps",
4 => "mana",
5 => "chests",
6 => "monsters",
_ => "objects",
}, list[num9].txtTitle);
}
return false;
}
private static void SetNomination(RewardsManager instance, string find, TextMeshProUGUI txtTitle)
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
//IL_003f: Unknown result type (might be due to invalid IL or missing references)
foreach (Nominations item in Field<List<Nominations>>(instance, "nominations"))
{
if (item.id.ToUpper().Trim() == find.ToUpper().Trim())
{
((TMP_Text)txtTitle).text = LocalizedString.op_Implicit(item.localizatedTitle);
break;
}
}
}
}
public static class SteamLobbyPatches
{
[HarmonyPatch(typeof(SteamLobby), "HostLobby")]
[HarmonyPrefix]
private static void OverrideMaxPlayers(ref int maxPlayers, ref ELobbyType lobbyType)
{
Plugin.Logger.LogInfo((object)$"HostLobby: overriding maxPlayers {maxPlayers} -> {Plugin.ConfigMaxPlayers.Value}");
maxPlayers = Plugin.ConfigMaxPlayers.Value;
}
[HarmonyPatch(typeof(SteamLobby), "OnLobbyCreated")]
[HarmonyPostfix]
private static void FixLobbyCreatedMaxPlayers(SteamLobby __instance)
{
//IL_007b: Unknown result type (might be due to invalid IL or missing references)
//IL_008b: Unknown result type (might be due to invalid IL or missing references)
//IL_0093: Unknown result type (might be due to invalid IL or missing references)
//IL_009a: Unknown result type (might be due to invalid IL or missing references)
if (__instance.CurrentLobbyID != 0L)
{
FieldInfo field = typeof(SteamLobby).GetField("maxPlayers", BindingFlags.Instance | BindingFlags.NonPublic);
if (field != null)
{
int num = (int)field.GetValue(__instance);
field.SetValue(__instance, Plugin.ConfigMaxPlayers.Value);
Plugin.Logger.LogInfo((object)$"OnLobbyCreated: fixed maxPlayers {num} -> {Plugin.ConfigMaxPlayers.Value}");
}
CSteamID val = new CSteamID(__instance.CurrentLobbyID);
int value = Plugin.ConfigMaxPlayers.Value;
SteamMatchmaking.SetLobbyMemberLimit(val, value);
int numLobbyMembers = SteamMatchmaking.GetNumLobbyMembers(val);
SteamMatchmaking.SetLobbyData(val, "players", numLobbyMembers + " / " + value);
SteamMatchmaking.SetLobbyData(val, "isFull", (numLobbyMembers >= value).ToString());
Plugin.Logger.LogInfo((object)$"OnLobbyCreated: SetLobbyMemberLimit -> {value}, players={numLobbyMembers}/{value}");
}
}
}
}
