using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Core.Logging.Interpolation;
using BepInEx.IL2CPP;
using BepInEx.IL2CPP.Utils.Collections;
using BepInEx.Logging;
using ChatCommands;
using CrabDevKit.Utilities;
using HarmonyLib;
using LobbyPlus.Systems;
using Microsoft.CodeAnalysis;
using SteamworksNative;
using TMPro;
using UnhollowerBaseLib;
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: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.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 LobbyPlus
{
public class ReadyCommand : BaseCommand
{
public ReadyCommand()
{
//IL_004b: Unknown result type (might be due to invalid IL or missing references)
//IL_0050: Unknown result type (might be due to invalid IL or missing references)
//IL_0055: 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)
base.id = "ready";
base.description = "Makes given player(s) ready up.";
base.args = new CommandArguments((CommandArgument[])(object)new CommandArgument[1]
{
new CommandArgument(new Type[2]
{
typeof(OnlineClientId[]),
typeof(OnlineClientId)
}, "player(s)", true)
});
}
public override BaseCommandResponse Execute(BaseExecutionMethod executionMethod, object executorDetails, string args, bool ignorePermissions = false)
{
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: Expected O, but got Unknown
//IL_0107: Unknown result type (might be due to invalid IL or missing references)
//IL_010c: Unknown result type (might be due to invalid IL or missing references)
//IL_010d: Unknown result type (might be due to invalid IL or missing references)
//IL_005f: Unknown result type (might be due to invalid IL or missing references)
//IL_0065: Expected O, but got Unknown
//IL_0148: Unknown result type (might be due to invalid IL or missing references)
//IL_014d: Unknown result type (might be due to invalid IL or missing references)
//IL_014e: Unknown result type (might be due to invalid IL or missing references)
//IL_0115: Unknown result type (might be due to invalid IL or missing references)
//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
//IL_0101: Expected O, but got Unknown
//IL_0092: Unknown result type (might be due to invalid IL or missing references)
//IL_0098: Expected O, but got Unknown
//IL_0178: Unknown result type (might be due to invalid IL or missing references)
//IL_017e: Expected O, but got Unknown
//IL_0156: Unknown result type (might be due to invalid IL or missing references)
//IL_0157: Unknown result type (might be due to invalid IL or missing references)
//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
//IL_00da: Expected O, but got Unknown
//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
//IL_0205: Expected O, but got Unknown
if (!((Object)(object)MonoBehaviourPublicDi2UIObacspDi2UIObUnique.Instance == (Object)null) && !((Object)(object)MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.Instance.gameMode != (Object)(object)MonoBehaviourPublicGadealGaLi1pralObInUnique.Instance.defaultMode))
{
if (args.Length == 0)
{
if (executionMethod is ChatExecutionMethod)
{
ulong num = (ulong)executorDetails;
if (!MonoBehaviourPublicDi2UIObacspDi2UIObUnique.Instance.activePlayers[num].waitingReady)
{
MonoBehaviourPublicDi2UIObacspDi2UIObUnique.Instance.activePlayers[num].waitingReady = true;
MonoBehaviourPublicInInUnique.SendPlayerReady(num, true);
if (MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.Instance.map.id == 6)
{
MonoBehaviourPublicInInUnique.Interact(num, 4);
}
return (BaseCommandResponse)new BasicCommandResponse(Array.Empty<string>(), (CommandResponseType)1);
}
return (BaseCommandResponse)new BasicCommandResponse(new string[1] { "You are already ready." }, (CommandResponseType)1);
}
return (BaseCommandResponse)new BasicCommandResponse(new string[1] { "A player selector or player is required for the first argument." }, (CommandResponseType)1);
}
if (!ignorePermissions && !executionMethod.HasPermission(executorDetails, "command.ready.others"))
{
return (BaseCommandResponse)new BasicCommandResponse(new string[1] { "You don't have sufficient permission to make other players ready up." }, (CommandResponseType)1);
}
ParsedResult<OnlineClientId[]> val = Api.CommandArgumentParser.Parse<OnlineClientId[]>(args);
IEnumerable<ulong> enumerable;
if (val.successful)
{
enumerable = val.result.Select((OnlineClientId clientId) => OnlineClientId.op_Implicit(clientId));
}
else
{
ParsedResult<OnlineClientId> val2 = Api.CommandArgumentParser.Parse<OnlineClientId>(args);
if (!val2.successful)
{
return (BaseCommandResponse)new BasicCommandResponse(new string[1] { "You did not select any players." }, (CommandResponseType)1);
}
enumerable = new <>z__ReadOnlySingleElementList<ulong>(OnlineClientId.op_Implicit(val2.result));
}
foreach (ulong item in enumerable)
{
if (!MonoBehaviourPublicDi2UIObacspDi2UIObUnique.Instance.activePlayers[item].waitingReady)
{
MonoBehaviourPublicDi2UIObacspDi2UIObUnique.Instance.activePlayers[item].waitingReady = true;
MonoBehaviourPublicInInUnique.SendPlayerReady(item, true);
if (MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.Instance.map.id == 6)
{
MonoBehaviourPublicInInUnique.Interact(item, 4);
}
}
}
return (BaseCommandResponse)new BasicCommandResponse(Array.Empty<string>(), (CommandResponseType)1);
}
return (BaseCommandResponse)new BasicCommandResponse(new string[1] { "You cannot make players ready up right now." }, (CommandResponseType)1);
}
}
public class UnreadyCommand : BaseCommand
{
public UnreadyCommand()
{
//IL_004b: Unknown result type (might be due to invalid IL or missing references)
//IL_0050: Unknown result type (might be due to invalid IL or missing references)
//IL_0055: 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)
base.id = "unready";
base.description = "Makes given player(s) unready.";
base.args = new CommandArguments((CommandArgument[])(object)new CommandArgument[1]
{
new CommandArgument(new Type[2]
{
typeof(OnlineClientId[]),
typeof(OnlineClientId)
}, "player(s)", true)
});
}
public override BaseCommandResponse Execute(BaseExecutionMethod executionMethod, object executorDetails, string args, bool ignorePermissions = false)
{
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: Expected O, but got Unknown
//IL_0107: Unknown result type (might be due to invalid IL or missing references)
//IL_010c: Unknown result type (might be due to invalid IL or missing references)
//IL_010d: Unknown result type (might be due to invalid IL or missing references)
//IL_005f: Unknown result type (might be due to invalid IL or missing references)
//IL_0065: Expected O, but got Unknown
//IL_0148: Unknown result type (might be due to invalid IL or missing references)
//IL_014d: Unknown result type (might be due to invalid IL or missing references)
//IL_014e: Unknown result type (might be due to invalid IL or missing references)
//IL_0115: Unknown result type (might be due to invalid IL or missing references)
//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
//IL_0101: Expected O, but got Unknown
//IL_0092: Unknown result type (might be due to invalid IL or missing references)
//IL_0098: Expected O, but got Unknown
//IL_0178: Unknown result type (might be due to invalid IL or missing references)
//IL_017e: Expected O, but got Unknown
//IL_0156: Unknown result type (might be due to invalid IL or missing references)
//IL_0157: Unknown result type (might be due to invalid IL or missing references)
//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
//IL_00da: Expected O, but got Unknown
//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
//IL_0205: Expected O, but got Unknown
if (!((Object)(object)MonoBehaviourPublicDi2UIObacspDi2UIObUnique.Instance == (Object)null) && !((Object)(object)MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.Instance.gameMode != (Object)(object)MonoBehaviourPublicGadealGaLi1pralObInUnique.Instance.defaultMode))
{
if (args.Length == 0)
{
if (executionMethod is ChatExecutionMethod)
{
ulong num = (ulong)executorDetails;
if (MonoBehaviourPublicDi2UIObacspDi2UIObUnique.Instance.activePlayers[num].waitingReady)
{
MonoBehaviourPublicDi2UIObacspDi2UIObUnique.Instance.activePlayers[num].waitingReady = false;
MonoBehaviourPublicInInUnique.SendPlayerReady(num, false);
if (MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.Instance.map.id == 6)
{
MonoBehaviourPublicInInUnique.Interact(num, 4);
}
return (BaseCommandResponse)new BasicCommandResponse(Array.Empty<string>(), (CommandResponseType)1);
}
return (BaseCommandResponse)new BasicCommandResponse(new string[1] { "You are already unreadied." }, (CommandResponseType)1);
}
return (BaseCommandResponse)new BasicCommandResponse(new string[1] { "A player selector or player is required for the first argument." }, (CommandResponseType)1);
}
if (!ignorePermissions && !executionMethod.HasPermission(executorDetails, "command.unready.others"))
{
return (BaseCommandResponse)new BasicCommandResponse(new string[1] { "You don't have sufficient permission to make other players unready." }, (CommandResponseType)1);
}
ParsedResult<OnlineClientId[]> val = Api.CommandArgumentParser.Parse<OnlineClientId[]>(args);
IEnumerable<ulong> enumerable;
if (val.successful)
{
enumerable = val.result.Select((OnlineClientId clientId) => OnlineClientId.op_Implicit(clientId));
}
else
{
ParsedResult<OnlineClientId> val2 = Api.CommandArgumentParser.Parse<OnlineClientId>(args);
if (!val2.successful)
{
return (BaseCommandResponse)new BasicCommandResponse(new string[1] { "You did not select any players." }, (CommandResponseType)1);
}
enumerable = new <>z__ReadOnlySingleElementList<ulong>(OnlineClientId.op_Implicit(val2.result));
}
foreach (ulong item in enumerable)
{
if (MonoBehaviourPublicDi2UIObacspDi2UIObUnique.Instance.activePlayers[item].waitingReady)
{
MonoBehaviourPublicDi2UIObacspDi2UIObUnique.Instance.activePlayers[item].waitingReady = false;
MonoBehaviourPublicInInUnique.SendPlayerReady(item, false);
if (MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.Instance.map.id == 6)
{
MonoBehaviourPublicInInUnique.Interact(item, 4);
}
}
}
return (BaseCommandResponse)new BasicCommandResponse(Array.Empty<string>(), (CommandResponseType)1);
}
return (BaseCommandResponse)new BasicCommandResponse(new string[1] { "You cannot make players unready right now." }, (CommandResponseType)1);
}
}
public class LoadLobbyCommand : BaseCommand
{
public LoadLobbyCommand()
{
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
//IL_0048: Unknown result type (might be due to invalid IL or missing references)
//IL_004d: Unknown result type (might be due to invalid IL or missing references)
base.id = "loadlobby";
base.description = "Loads the given Lobby+ lobby config.";
base.args = new CommandArguments((CommandArgument[])(object)new CommandArgument[1]
{
new CommandArgument(new Type[1] { typeof(string) }, "config", false)
});
}
public override BaseCommandResponse Execute(BaseExecutionMethod executionMethod, object executorDetails, string args, bool ignorePermissions = false)
{
//IL_0023: 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_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
//IL_001d: Expected O, but got Unknown
//IL_004b: Unknown result type (might be due to invalid IL or missing references)
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
//IL_007b: Unknown result type (might be due to invalid IL or missing references)
//IL_0081: Expected O, but got Unknown
//IL_0040: Unknown result type (might be due to invalid IL or missing references)
//IL_0046: Expected O, but got Unknown
if (args.Length != 0)
{
ParsedResult<string> val = Api.CommandArgumentParser.Parse<string>(args);
if (val.successful)
{
LobbyPlus.Instance.LoadConfig(val.result);
return (BaseCommandResponse)new StyledCommandResponse("Lobby+", new string[1] { "Loaded the '" + val.result + "' lobby config." }, (CommandResponseType)0, true);
}
return (BaseCommandResponse)new BasicCommandResponse(new string[1] { "You didn't specify a valid config to load." }, (CommandResponseType)1);
}
return (BaseCommandResponse)new BasicCommandResponse(new string[1] { "You didn't specify a config to load." }, (CommandResponseType)1);
}
}
public class ReloadLobbyCommand : BaseCommand
{
public ReloadLobbyCommand()
{
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
base.id = "reloadlobby";
base.description = "Reloads the current Lobby+ lobby config.";
base.args = new CommandArguments(Array.Empty<CommandArgument>());
}
public override BaseCommandResponse Execute(BaseExecutionMethod executionMethod, object executorDetails, string args, bool ignorePermissions = false)
{
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
//IL_0049: Expected O, but got Unknown
LobbyPlus.Instance.LoadConfig(LobbyPlus.LobbyConfig.Name);
return (BaseCommandResponse)new StyledCommandResponse("Lobby+", new string[1] { "Reloaded the '" + LobbyPlus.LobbyConfig.Name + "' lobby config." }, (CommandResponseType)0, true);
}
}
internal static class Patches
{
internal static bool isWaiting;
internal static bool callingPlayerDied;
internal static bool wasPractice;
internal static bool wasWaitingRoom;
[HarmonyPatch(typeof(MonoBehaviourPublicCSDi2UIInstObUIloDiUnique), "StartLobby")]
[HarmonyPatch(typeof(MonoBehaviourPublicCSDi2UIInstObUIloDiUnique), "StartPracticeLobby")]
[HarmonyPostfix]
internal static void PostLobbyManagerStartLobby()
{
MessageOfTheDay.Start();
ServerMessages.Start();
}
[HarmonyPatch(typeof(MonoBehaviourPublicCSDi2UIInstObUIloDiUnique), "CloseLobby")]
[HarmonyPostfix]
internal static void PostLobbyManagerCloseLobby()
{
MessageOfTheDay.Stop();
ServerMessages.Stop();
}
[HarmonyPatch(typeof(MonoBehaviourPublicObhpamObTeplcoTeloreUnique), "Awake")]
[HarmonyPostfix]
internal static void PostStatusUIAwake()
{
//IL_000f: 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)
((TMP_Text)MonoBehaviourPublicObhpamObTeplcoTeloreUnique.Instance.playerCount).rectTransform.anchorMax = Vector2.one;
((TMP_Text)MonoBehaviourPublicObhpamObTeplcoTeloreUnique.Instance.countdown).rectTransform.anchorMax = Vector2.one;
}
[HarmonyPatch(typeof(MonoBehaviourPublicObjomaOblogaTMObseprUnique), "Start")]
[HarmonyPostfix]
internal static void PostMenuUiCreateLobbySettingsStart(MonoBehaviourPublicObjomaOblogaTMObseprUnique __instance)
{
LobbyGameSettings.lobbySettings = __instance;
GameObject val = Object.Instantiate<GameObject>(((Component)__instance.lobbyType).gameObject, ((Component)__instance.lobbyType).transform.parent);
((Object)val).name = "LobbyPlusConfig";
val.transform.SetSiblingIndex(0);
((TMP_Text)((Component)val.transform.GetChild(0).GetChild(0)).GetComponent<TextMeshProUGUI>()).text = "Lobby+ Config";
List<string> list = (from file in Directory.GetFiles(Path.Combine(new string[2]
{
Paths.ConfigPath,
"lammas123.LobbyPlus"
}))
select Path.GetFileNameWithoutExtension(Path.GetFileName(file))).ToList();
if (!list.Contains(LobbyPlus.LobbyConfig.Name))
{
list.Add(LobbyPlus.LobbyConfig.Name);
}
int num = Math.Max(0, list.IndexOf(LobbyPlus.LobbyConfig.Name)) + 1;
list.Insert(0, string.Empty);
LobbyGameSettings.lobbyConfigScroll = val.GetComponent<MonoBehaviour1PublicTeseStRascRascUnique>();
LobbyGameSettings.lobbyConfigScroll.SetSettings(Il2CppStringArray.op_Implicit(list.ToArray()), num);
LobbyPlus.Instance.LoadConfig(((Il2CppArrayBase<string>)(object)LobbyGameSettings.lobbyConfigScroll.field_Private_ArrayOf_0)[num]);
}
[HarmonyPatch(typeof(MonoBehaviourPublicGamomaGaTrmoTrmaUnique), "Start")]
[HarmonyPostfix]
internal static void PostMenuUiCreateLobbyGameModesAndMapsStart(MonoBehaviourPublicGamomaGaTrmoTrmaUnique __instance)
{
LobbyGameSettings.lobbyGameModesAndMaps = __instance;
}
[HarmonyPatch(typeof(MonoBehaviour1PublicTeseStRascRascUnique), "Method_Private_Void_0")]
[HarmonyPrefix]
internal static void PreGeneralUiSettingsScrollSettingUpdated(MonoBehaviour1PublicTeseStRascRascUnique __instance)
{
if ((Object)(object)__instance == (Object)(object)LobbyGameSettings.lobbyConfigScroll)
{
List<string> list = (from file in Directory.GetFiles(Path.Combine(new string[2]
{
Paths.ConfigPath,
"lammas123.LobbyPlus"
}))
select Path.GetFileNameWithoutExtension(Path.GetFileName(file))).ToList();
if (!list.Contains(LobbyPlus.LobbyConfig.Name))
{
list.Add(LobbyPlus.LobbyConfig.Name);
}
list.Insert(0, string.Empty);
LobbyGameSettings.lobbyConfigScroll.field_Private_ArrayOf_0 = Il2CppStringArray.op_Implicit(list.ToArray());
((MonoBehaviourPublicIncuObm_ObUnique)LobbyGameSettings.lobbyConfigScroll).currentSetting = Math.Clamp(((MonoBehaviourPublicIncuObm_ObUnique)LobbyGameSettings.lobbyConfigScroll).currentSetting, 1, ((Il2CppArrayBase<string>)(object)LobbyGameSettings.lobbyConfigScroll.field_Private_ArrayOf_0).Length - 1);
LobbyPlus.Instance.LoadConfig(((Il2CppArrayBase<string>)(object)LobbyGameSettings.lobbyConfigScroll.field_Private_ArrayOf_0)[((MonoBehaviourPublicIncuObm_ObUnique)LobbyGameSettings.lobbyConfigScroll).currentSetting]);
}
}
[HarmonyPatch(typeof(MonoBehaviourPublicCSDi2UIInstObUIloDiUnique), "Awake")]
[HarmonyPatch(typeof(MonoBehaviourPublicCSDi2UIInstObUIloDiUnique), "NewLobbySettings")]
[HarmonyPostfix]
internal static void PostLobbyManagerInitLobbySettings(MonoBehaviourPublicCSDi2UIInstObUIloDiUnique __instance)
{
if ((Object)(object)__instance == (Object)(object)MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.Instance)
{
LobbyGameSettings.UpdateSettings();
}
}
[HarmonyPatch(typeof(MonoBehaviourPublicGadealGaLi1pralObInUnique), "Awake")]
[HarmonyPostfix]
internal static void PostGameModeManagerAwake(MonoBehaviourPublicGadealGaLi1pralObInUnique __instance)
{
if ((Object)(object)__instance == (Object)(object)MonoBehaviourPublicGadealGaLi1pralObInUnique.Instance)
{
LobbyGameSettings.UpdateGameModeSettings();
}
}
[HarmonyPatch(typeof(MonoBehaviourPublicObInMamaLi1plMadeMaUnique), "Awake")]
[HarmonyPostfix]
internal static void PostMapManagerAwake(MonoBehaviourPublicObInMamaLi1plMadeMaUnique __instance)
{
if ((Object)(object)__instance == (Object)(object)MonoBehaviourPublicObInMamaLi1plMadeMaUnique.Instance)
{
LobbyGameSettings.UpdateMapSettings();
}
}
[HarmonyPatch(typeof(MonoBehaviourPublicInInUnique), "LoadMap", new Type[]
{
typeof(int),
typeof(int)
})]
[HarmonyPostfix]
internal static void PostServerSendLoadMap()
{
ServerMessages.lastAttackers.Clear();
}
[HarmonyPatch(typeof(MonoBehaviourPublicInInUnique), "PunchPlayer")]
[HarmonyPostfix]
internal static void PostServerSendPunchPlayer(ulong param_0, ulong param_1)
{
if (MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.IsLobbyOwner() && param_1 > 1 && param_0 != param_1)
{
ServerMessages.lastAttackers[param_1] = param_0;
}
}
[HarmonyPatch(typeof(MonoBehaviourPublicInInUnique), "PlayerDamage")]
[HarmonyPostfix]
internal static void PostServerSendPlayerDamage(ulong param_0, ulong param_1)
{
if (MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.IsLobbyOwner() && param_1 > 1 && param_0 != param_1)
{
ServerMessages.lastAttackers[param_1] = param_0;
}
}
[HarmonyPatch(typeof(MonoBehaviourPublicInInUnique), "PlayerDied")]
[HarmonyPrefix]
internal static void PreServerSendPlayerDied(ulong param_0, ulong param_1)
{
if (MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.IsLobbyOwner() && MonoBehaviourPublicDi2UIObacspDi2UIObUnique.Instance.activePlayers.ContainsKey(param_0) && !MonoBehaviourPublicDi2UIObacspDi2UIObUnique.Instance.activePlayers[param_0].dead)
{
if (param_1 > 1 && param_0 != param_1)
{
ServerMessages.lastAttackers[param_0] = param_1;
}
if (ServerMessages.lastAttackers.TryGetValue(param_0, out var value))
{
ServerMessages.SendKillMessage(param_0, value);
}
else
{
ServerMessages.SendDeathMessage(param_0);
}
ServerMessages.lastAttackers.Remove(param_0);
}
}
[HarmonyPatch(typeof(MonoBehaviourPublicInInUnique), "GameOver")]
[HarmonyPostfix]
internal static void PostServerSendGameOver(ulong param_0)
{
if (MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.IsLobbyOwner() && param_0 != 0L)
{
ServerMessages.SendWinMessage(param_0);
WinnerItemSpam.Start(param_0);
}
}
[HarmonyPatch(typeof(GameModeWaiting), "Update")]
[HarmonyPostfix]
internal static void PostGameModeWaitingUpdate()
{
if (MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.IsLobbyOwner() && !MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.Instance.started)
{
AutoStart.Update();
}
}
[HarmonyPatch(typeof(MonoBehaviourPublicObInLi1GagasmLi1GaUnique), "RestartLobby")]
[HarmonyPrefix]
internal static bool PreGameLoopRestartLobby()
{
if (MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.IsLobbyOwner() && LobbyPlus.LobbyConfig.autoStartMinPlayers.Value != 0 && MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.steamIdToUID.Count >= LobbyPlus.LobbyConfig.autoStartMinPlayers.Value)
{
AutoStart.skippingLobby = true;
MonoBehaviourPublicObInLi1GagasmLi1GaUnique.Instance.StartGames();
AutoStart.skippingLobby = false;
return false;
}
return true;
}
[HarmonyPatch(typeof(MonoBehaviourPublicObInLi1GagasmLi1GaUnique), "Method_Private_Void_0")]
[HarmonyPrefix]
internal static bool PreGameLoopEliminatePlayersThatAreParticipatingButNotLoaded()
{
return !AutoStart.skippingLobby;
}
[HarmonyPatch(typeof(MonoBehaviourPublicDi2UIObacspDi2UIObUnique), "GetPlayersAlive")]
[HarmonyPrefix]
internal static bool PreGameManagerGetPlayersAlive(ref int __result)
{
if (!AutoStart.skippingLobby)
{
return true;
}
__result = MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.steamIdToUID.Count;
return false;
}
[HarmonyPatch(typeof(MonoBehaviourPublicInInUnique), "SendWinner")]
[HarmonyPrefix]
internal static void PreServerSendSendWinner()
{
if (LobbyPlus.LobbyConfig.winScreenTime.Value == 0)
{
((MonoBehaviour)MonoBehaviourPublicObInLi1GagasmLi1GaUnique.Instance).Invoke("RestartLobby", 0.25f);
}
}
[HarmonyPatch(typeof(MonoBehaviourPublicTenaprTeotplUITeStprUnique), "Start")]
[HarmonyPostfix]
internal static void PostWinManagerStart(MonoBehaviourPublicTenaprTeotplUITeStprUnique __instance)
{
if (MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.IsLobbyOwner())
{
((MonoBehaviour)__instance).CancelInvoke("Continue");
((MonoBehaviour)__instance).Invoke("Continue", (float)LobbyPlus.LobbyConfig.winScreenTime.Value);
}
}
[HarmonyPatch(typeof(MonoBehaviourPublicObInLi1GagasmLi1GaUnique), "StartGames")]
[HarmonyPrefix]
internal static void PreGameLoopStartGames()
{
LobbyGameSettings.shouldPlayRound = true;
}
[HarmonyPatch(typeof(MonoBehaviourPublicObInLi1GagasmLi1GaUnique), "NextGame")]
[HarmonyPrefix]
internal static bool PreGameLoopNextGame()
{
if (LobbyGameSettings.shouldPlayRound)
{
return true;
}
LobbyGameSettings.shouldPlayRound = true;
MonoBehaviourPublicObInLi1GagasmLi1GaUnique.Instance.RestartLobby();
return false;
}
[HarmonyPatch(typeof(MonoBehaviourPublicObInLi1GagasmLi1GaUnique), "StartGames")]
[HarmonyPostfix]
internal static void PostGameLoopStartGames()
{
if (LobbyPlus.LobbyConfig.onlyOneRound.Value)
{
LobbyGameSettings.shouldPlayRound = false;
}
}
[HarmonyPatch(typeof(MonoBehaviourPublicSiObSiInSiUnique), "Update")]
[HarmonyPrefix]
internal static void PreServerClockUpdate()
{
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
if ((int)MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.Instance.gameMode.type == 0)
{
MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.Instance.gameMode.type = (EnumNPublicSealedvaWaReBaStTaHiBoLiFaUnique)14;
isWaiting = true;
}
}
[HarmonyPatch(typeof(MonoBehaviourPublicSiObSiInSiUnique), "Update")]
[HarmonyPostfix]
internal static void PostServerClockUpdate()
{
if (isWaiting)
{
MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.Instance.gameMode.type = (EnumNPublicSealedvaWaReBaStTaHiBoLiFaUnique)0;
isWaiting = false;
}
}
[HarmonyPatch(typeof(MonoBehaviourPublicSicofoSimuupInSiboVeUnique), "OnCollisionEnter")]
[HarmonyPrefix]
internal static void PreBouncePlayerOnCollisionEnter()
{
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
if ((int)MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.Instance.gameMode.type == 0)
{
MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.Instance.gameMode.type = (EnumNPublicSealedvaWaReBaStTaHiBoLiFaUnique)14;
isWaiting = true;
}
}
[HarmonyPatch(typeof(MonoBehaviourPublicSicofoSimuupInSiboVeUnique), "OnCollisionEnter")]
[HarmonyPostfix]
internal static void PostBouncePlayerOnCollisionEnter()
{
if (isWaiting)
{
MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.Instance.gameMode.type = (EnumNPublicSealedvaWaReBaStTaHiBoLiFaUnique)0;
isWaiting = false;
}
}
[HarmonyPatch(typeof(MonoBehaviourPublicVeaxSispRiVeofSiBoUnique), "FixedUpdate")]
[HarmonyPrefix]
internal static void PreRotationObjectFixedUpdate()
{
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
if ((int)MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.Instance.gameMode.type == 0)
{
MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.Instance.gameMode.type = (EnumNPublicSealedvaWaReBaStTaHiBoLiFaUnique)14;
isWaiting = true;
}
}
[HarmonyPatch(typeof(MonoBehaviourPublicVeaxSispRiVeofSiBoUnique), "FixedUpdate")]
[HarmonyPostfix]
internal static void PostRotationObjectFixedUpdate()
{
if (isWaiting)
{
MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.Instance.gameMode.type = (EnumNPublicSealedvaWaReBaStTaHiBoLiFaUnique)0;
isWaiting = false;
}
}
[HarmonyPatch(typeof(MonoBehaviourPublicDi2UIObacspDi2UIObUnique), "PlayerDied")]
[HarmonyPrefix]
internal static void PreGameManagerPlayerDied()
{
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0017: Invalid comparison between Unknown and I4
callingPlayerDied = true;
if ((int)MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.Instance.gameMode.type == 14)
{
MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.Instance.gameMode.type = (EnumNPublicSealedvaWaReBaStTaHiBoLiFaUnique)0;
wasPractice = true;
}
}
[HarmonyPatch(typeof(MonoBehaviourPublicObInLi1GagasmLi1GaUnique), "CheckGameOver")]
[HarmonyPrefix]
internal static void PreGameLoopCheckGameOver()
{
if (callingPlayerDied && wasPractice)
{
MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.Instance.gameMode.type = (EnumNPublicSealedvaWaReBaStTaHiBoLiFaUnique)14;
wasPractice = false;
}
}
[HarmonyPatch(typeof(MonoBehaviourPublicObInLi1GagasmLi1GaUnique), "CheckGameOver")]
[HarmonyPostfix]
internal static void PostGameLoopCheckGameOver()
{
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
if (callingPlayerDied && (int)MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.Instance.gameMode.type == 0)
{
MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.Instance.gameMode.type = (EnumNPublicSealedvaWaReBaStTaHiBoLiFaUnique)14;
wasWaitingRoom = true;
}
}
[HarmonyPatch(typeof(MonoBehaviourPublicDi2UIObacspDi2UIObUnique), "PlayerDied")]
[HarmonyPostfix]
internal static void PostGameManagerPlayerDied()
{
if (callingPlayerDied && wasWaitingRoom)
{
MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.Instance.gameMode.type = (EnumNPublicSealedvaWaReBaStTaHiBoLiFaUnique)0;
wasWaitingRoom = false;
}
callingPlayerDied = false;
}
}
[BepInPlugin("lammas123.LobbyPlus", "LobbyPlus", "1.1.1")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public sealed class LobbyPlus : BasePlugin
{
public delegate void LobbyConfigLoaded();
public static LobbyConfigLoaded onLobbyConfigLoaded;
internal readonly string[] MotdsDefault = new string[3] { "Crab Gaming", "This lobby's name keeps changing!!!", "Powered by Lobby+" };
internal readonly string[] GameModesAndMapsDefault = new string[1] { "*" };
internal readonly string[] ServerMessagesDefault = new string[3] { "W", "This lobby is powered by Lobby+!", "I like Turtles" };
internal readonly string[] ServerDeathMessagesDefault = new string[10] { "{PLAYER} died", "{PLAYER} fell off", "{PLAYER} got mucked", "{PLAYER} failed us", "{PLAYER} didn't try hard enough", "{PLAYER} threw", "{PLAYER} couldn't take the pressure", "{PLAYER} croaked", "{PLAYER} needs a gaming chair", "{PLAYER}'s brother was playing" };
internal readonly string[] ServerKillMessagesDefault = new string[10] { "{KILLER} killed {PLAYER}", "{KILLER} murdered {PLAYER}", "{KILLER} obliterated {PLAYER}", "{KILLER} destroyed {PLAYER}", "{KILLER} deleted {PLAYER}", "{KILLER} curb stomped {PLAYER}", "{KILLER} drop kicked {PLAYER}", "{KILLER} blasted {PLAYER}", "{KILLER} unalived {PLAYER}", "{KILLER} mucked {PLAYER}" };
internal readonly string[] ServerWinMessagesDefault = new string[3] { "{PLAYER} won!", "{PLAYER} got the W!", "{PLAYER} mucked everyone else! Ayo?" };
internal readonly int[] WinnerItemSpamItems = new int[14]
{
0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
10, 11, 12, 13
};
internal static LobbyPlus Instance { get; private set; }
public static LobbyConfig LobbyConfig { get; internal set; }
public static ConfigEntry<int> MaxPlayersSlider { get; internal set; }
public override void Load()
{
//IL_0049: Unknown result type (might be due to invalid IL or missing references)
//IL_004e: Unknown result type (might be due to invalid IL or missing references)
//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
//IL_00be: Unknown result type (might be due to invalid IL or missing references)
//IL_0073: Unknown result type (might be due to invalid IL or missing references)
//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
//IL_009d: Expected O, but got Unknown
//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
//IL_01fa: Expected O, but got Unknown
//IL_010d: Expected O, but got Unknown
CultureInfo.CurrentCulture = CultureInfo.InvariantCulture;
CultureInfo.CurrentUICulture = CultureInfo.InvariantCulture;
CultureInfo.DefaultThreadCurrentCulture = CultureInfo.InvariantCulture;
CultureInfo.DefaultThreadCurrentUICulture = CultureInfo.InvariantCulture;
Instance = this;
if (!TomlTypeConverter.CanConvert(typeof(string[])))
{
TomlTypeConverter.AddConverter(typeof(string[]), new TypeConverter
{
ConvertToString = delegate(object obj, Type type)
{
string[] obj2 = (string[])obj;
List<string> list2 = new List<string>();
string[] array = obj2;
for (int j = 0; j < array.Length; j++)
{
string text3 = Escape(array[j].Trim());
if (text3.Length != 0)
{
list2.Add(text3);
}
}
return string.Join(", ", list2);
},
ConvertToObject = delegate(string str, Type type)
{
List<string> list = new List<string>();
int num = -1;
while (num + 1 < str.Length)
{
num = str.IndexOf(',', num + 1);
if (num == -1)
{
list.Add(str);
break;
}
if (num > 0 && str[num - 1] == '\\')
{
int i;
for (i = 1; num - i >= 0 && str[num - i] == '\\'; i++)
{
}
if (i % 2 == 1)
{
continue;
}
}
if (num != 0)
{
string text = str.Substring(0, num).TrimEnd();
list.Add(Regex.IsMatch(text, "^\"?\\w:\\\\(?!\\\\)(?!.+\\\\\\\\)") ? text : Unescape(text));
}
string text2 = str;
int num2 = num + 1;
str = text2.Substring(num2, text2.Length - num2).TrimStart();
num = -1;
}
return list.ToArray();
}
});
}
if (!TomlTypeConverter.CanConvert(typeof(int[])))
{
TomlTypeConverter.AddConverter(typeof(int[]), new TypeConverter
{
ConvertToString = (object obj, Type type) => string.Join(", ", (int[])obj),
ConvertToObject = (string str, Type type) => (from s in str.Split(',')
select int.Parse(s.Trim())).ToArray()
});
}
LoadConfig(((BasePlugin)this).Config.Bind<string>("Lobby+", "DefaultLobbyConfig", "Default", "The name of the lobby config to load by default.").Value);
MaxPlayersSlider = ((BasePlugin)this).Config.Bind<int>("Lobby+", "MaxPlayersSlider", 40, "The highest the max players slider can go to, must be set between 40 and 250.");
if (MaxPlayersSlider.Value < 40)
{
MaxPlayersSlider.Value = 40;
}
else if (MaxPlayersSlider.Value > 250)
{
MaxPlayersSlider.Value = 250;
}
MessageOfTheDay.Init();
LobbyGameSettings.Init();
ServerMessages.Init();
Api.RegisterCommand((BaseCommand)(object)new ReadyCommand());
Api.RegisterCommand((BaseCommand)(object)new UnreadyCommand());
Api.RegisterCommand((BaseCommand)(object)new LoadLobbyCommand());
Api.RegisterCommand((BaseCommand)(object)new ReloadLobbyCommand());
new Harmony("LobbyPlus").PatchAll(typeof(Patches));
ManualLogSource log = ((BasePlugin)this).Log;
bool flag = default(bool);
BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(15, 2, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Initialized [");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("LobbyPlus");
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("1.1.1");
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("]");
}
log.LogInfo(val);
}
internal void LoadConfig(string name)
{
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Expected O, but got Unknown
ConfigFile val = new ConfigFile(Path.Combine(new string[3]
{
Paths.ConfigPath,
"lammas123.LobbyPlus",
name + ".cfg"
}), true);
LobbyConfig lobbyConfig = default(LobbyConfig);
lobbyConfig.Name = name;
lobbyConfig.config = val;
lobbyConfig.motdCycleTime = val.Bind<int>("MOTD", "MOTDCycleTime", 60, "The cycling time between MOTDs in seconds, setting to 0 will disable cycling.");
lobbyConfig.motds = val.Bind<string[]>("MOTD", "MOTDs", MotdsDefault.ToArray(), "The motds (messages of the day) to cycle through over time.");
lobbyConfig.type = val.Bind<int>("Lobby Settings", "Type", 2, "The type of lobby. 2=Public, 1=Friends Only, 0=Code Only");
lobbyConfig.voiceChatEnabled = val.Bind<bool>("Lobby Settings", "VoiceChatEnabled", true, "If voice chat should be enabled in your lobby.");
lobbyConfig.maxPlayers = val.Bind<int>("Lobby Settings", "MaxPlayers", 15, "The max number of players that can join your lobby, must be set between 2 and 250.");
lobbyConfig.enabledGameModes = val.Bind<string[]>("Lobby Settings", "EnabledGameModes", GameModesAndMapsDefault.ToArray(), "The names of the game modes you want to have enabled, or '*' to enable them all.");
lobbyConfig.enabledMaps = val.Bind<string[]>("Lobby Settings", "EnabledMaps", GameModesAndMapsDefault.ToArray(), "The names of the maps you want to have enabled, or '*' to enable them all.");
lobbyConfig.lobbyMap = val.Bind<string>("Lobby Settings", "LobbyMap", "Dorm", "The name of the map you want to use as the lobby. If it is not set to Dorm, then the only way players can ready up is via the !ready command.");
lobbyConfig.serverMessageCycleTime = val.Bind<int>("Server Messages", "ServerMessageCycleTime", 45, "The cycling time between server messages in seconds, setting to 0 will disable cycling and not show any server messages.");
lobbyConfig.serverMessages = val.Bind<string[]>("Server Messages", "ServerMessages", ServerMessagesDefault.ToArray(), "The server messages to cycle through over time in a random order.");
lobbyConfig.serverDeathMessages = val.Bind<string[]>("Server Messages", "ServerDeathMessages", ServerDeathMessagesDefault.ToArray(), "The server death messages to show when someone dies, leave empty to not show death messages.");
lobbyConfig.serverKillMessages = val.Bind<string[]>("Server Messages", "ServerKillMessages", ServerKillMessagesDefault.ToArray(), "The server kill messages to show when someone kills another player, leave empty to not show kill messages.");
lobbyConfig.serverWinMessages = val.Bind<string[]>("Server Messages", "ServerWinMessages", ServerWinMessagesDefault.ToArray(), "The server win messages to show when someone wins, leave empty to not show win messages.");
lobbyConfig.autoStartCountdownMinPlayers = val.Bind<int>("Auto Start", "AutoStartCountdownMinPlayers", 0, "The minimum number of players to start the auto start countdown, set to 0 to disable.");
lobbyConfig.autoStartCountdownTime = val.Bind<int>("Auto Start", "AutoStartCountdownLength", 5, "The length of the auto start countdown in seconds, must be 5 seconds or higher.");
lobbyConfig.autoStartMinPlayers = val.Bind<int>("Auto Start", "AutoStartMinPlayers", 0, "The minimum number of players to automatically start, set to 0 to disable. The lobby will be skipped if there are enough players at the end of the previous games.");
lobbyConfig.winnerItemSpamItems = val.Bind<int[]>("Extra Settings", "WinnerItemSpamItems", WinnerItemSpamItems.ToArray(), "The ids of the items you want to have spammed when a player wins, item ids are between 0 and 13 inclusive.");
lobbyConfig.freezePhaseTime = val.Bind<int>("Extra Settings", "FreezePhaseTime", 11, "The length of the freeze phase in seconds, must be 5 seconds or higher.");
lobbyConfig.roundOverPhaseTime = val.Bind<int>("Extra Settings", "RoundOverPhaseTime", 7, "The length of the round over phase in seconds, must be 3 seconds or higher.");
lobbyConfig.gameOverPhaseTime = val.Bind<int>("Extra Settings", "GameOverPhaseTime", 7, "The length of the game over phase in seconds, must be 3 seconds or higher.");
lobbyConfig.winScreenTime = val.Bind<int>("Extra Settings", "WinScreenTime", 11, "The length of the win screen in seconds, set to 0 to skip.");
lobbyConfig.onlyOneRound = val.Bind<bool>("Extra Settings", "OnlyOneRound", false, "When enabled, only one round will be played before sending everyone back to the lobby (or to the win screen if it isn't to be skipped and only 1 player is alive). This can be paired with AutoStartMinPlayers to play round after round of custom game modes like Infection and Manhunt.");
LobbyConfig = lobbyConfig;
if (LobbyConfig.motdCycleTime.Value < 0)
{
LobbyConfig.motdCycleTime.Value = 0;
}
if (LobbyConfig.motds.Value.Length == 0)
{
LobbyConfig.motds.Value = MotdsDefault.ToArray();
}
if (LobbyConfig.type.Value < 0 || LobbyConfig.type.Value > 2)
{
LobbyConfig.type.Value = 2;
}
if (LobbyConfig.maxPlayers.Value < 2)
{
LobbyConfig.maxPlayers.Value = 2;
}
else if (LobbyConfig.maxPlayers.Value > 250)
{
LobbyConfig.maxPlayers.Value = 250;
}
if (LobbyConfig.enabledGameModes.Value.Length == 0)
{
LobbyConfig.enabledGameModes.Value = GameModesAndMapsDefault.ToArray();
}
if (LobbyConfig.enabledMaps.Value.Length == 0)
{
LobbyConfig.enabledMaps.Value = GameModesAndMapsDefault.ToArray();
}
if (LobbyConfig.serverMessageCycleTime.Value < 0)
{
LobbyConfig.serverMessageCycleTime.Value = 0;
}
if (LobbyConfig.serverMessages.Value.Length == 0)
{
LobbyConfig.serverMessages.Value = ServerMessagesDefault.ToArray();
}
if (LobbyConfig.autoStartCountdownMinPlayers.Value < 0)
{
LobbyConfig.autoStartCountdownMinPlayers.Value = 0;
}
if (LobbyConfig.autoStartCountdownTime.Value < 5)
{
LobbyConfig.autoStartCountdownTime.Value = 5;
}
if (LobbyConfig.autoStartMinPlayers.Value < 0)
{
LobbyConfig.autoStartMinPlayers.Value = 0;
}
LobbyConfig.winnerItemSpamItems.Value = LobbyConfig.winnerItemSpamItems.Value.Where((int itemId) => itemId >= 0).ToArray();
if (LobbyConfig.freezePhaseTime.Value < 5)
{
LobbyConfig.freezePhaseTime.Value = 5;
}
if (LobbyConfig.roundOverPhaseTime.Value < 3)
{
LobbyConfig.roundOverPhaseTime.Value = 3;
}
if (LobbyConfig.gameOverPhaseTime.Value < 3)
{
LobbyConfig.gameOverPhaseTime.Value = 3;
}
if (LobbyConfig.winScreenTime.Value < 0)
{
LobbyConfig.winScreenTime.Value = 0;
}
onLobbyConfigLoaded?.Invoke();
}
private static string Escape(string str)
{
if (!string.IsNullOrEmpty(str))
{
return str.Replace("\\", "\\\\").Replace("\n", "\\n").Replace("\r", "\\r")
.Replace(",", "\\,");
}
return string.Empty;
}
private static string Unescape(string str)
{
if (!string.IsNullOrEmpty(str))
{
return str.Replace("\\\\", "\\").Replace("\\n", "\n").Replace("\\r", "\r")
.Replace("\\,", ",");
}
return string.Empty;
}
}
public struct LobbyConfig
{
internal ConfigFile config;
internal ConfigEntry<int> motdCycleTime;
internal ConfigEntry<string[]> motds;
internal ConfigEntry<int> type;
internal ConfigEntry<bool> voiceChatEnabled;
internal ConfigEntry<int> maxPlayers;
internal ConfigEntry<string[]> enabledGameModes;
internal ConfigEntry<string[]> enabledMaps;
internal ConfigEntry<string> lobbyMap;
internal ConfigEntry<int[]> winnerItemSpamItems;
internal ConfigEntry<int> serverMessageCycleTime;
internal ConfigEntry<string[]> serverMessages;
internal ConfigEntry<string[]> serverDeathMessages;
internal ConfigEntry<string[]> serverKillMessages;
internal ConfigEntry<string[]> serverWinMessages;
internal ConfigEntry<int> autoStartCountdownMinPlayers;
internal ConfigEntry<int> autoStartCountdownTime;
internal ConfigEntry<int> autoStartMinPlayers;
internal ConfigEntry<int> freezePhaseTime;
internal ConfigEntry<int> roundOverPhaseTime;
internal ConfigEntry<int> gameOverPhaseTime;
internal ConfigEntry<int> winScreenTime;
internal ConfigEntry<bool> onlyOneRound;
public string Name { get; internal set; }
}
public static class MyPluginInfo
{
public const string PLUGIN_GUID = "lammas123.LobbyPlus";
public const string PLUGIN_NAME = "LobbyPlus";
public const string PLUGIN_VERSION = "1.1.1";
}
}
namespace LobbyPlus.Systems
{
internal static class AutoStart
{
internal static bool skippingLobby = false;
internal static float timer = float.MaxValue;
internal static void Update()
{
int count = MonoBehaviourPublicDi2UIObacspDi2UIObUnique.Instance.activePlayers.Count;
if (LobbyPlus.LobbyConfig.autoStartMinPlayers.Value != 0 && count >= LobbyPlus.LobbyConfig.autoStartMinPlayers.Value)
{
timer = float.MaxValue;
MonoBehaviourPublicObInLi1GagasmLi1GaUnique.Instance.StartGames();
}
else
{
if (LobbyPlus.LobbyConfig.autoStartCountdownMinPlayers.Value == 0)
{
return;
}
if (timer != float.MaxValue && count < LobbyPlus.LobbyConfig.autoStartCountdownMinPlayers.Value)
{
timer = float.MaxValue;
ChatUtil.SendMessage($"Player count fell below {LobbyPlus.LobbyConfig.autoStartCountdownMinPlayers.Value}, cancelling countdown", (MessageType)2, "AutoStart", (IEnumerable<ulong>)null);
}
else if (count >= LobbyPlus.LobbyConfig.autoStartCountdownMinPlayers.Value)
{
if (timer == float.MaxValue)
{
timer = LobbyPlus.LobbyConfig.autoStartCountdownTime.Value;
ChatUtil.SendMessage($"Starting games in {LobbyPlus.LobbyConfig.autoStartCountdownTime.Value} seconds", (MessageType)2, "AutoStart", (IEnumerable<ulong>)null);
}
if (!((timer -= Time.deltaTime) > 0f))
{
timer = float.MaxValue;
MonoBehaviourPublicObInLi1GagasmLi1GaUnique.Instance.StartGames();
}
}
}
}
}
internal static class LobbyGameSettings
{
internal static MonoBehaviourPublicObjomaOblogaTMObseprUnique lobbySettings;
internal static MonoBehaviourPublicGamomaGaTrmoTrmaUnique lobbyGameModesAndMaps;
internal static MonoBehaviour1PublicTeseStRascRascUnique lobbyConfigScroll;
internal static bool shouldPlayRound = true;
internal static void Init()
{
LobbyPlus.onLobbyConfigLoaded = (LobbyPlus.LobbyConfigLoaded)Delegate.Combine(LobbyPlus.onLobbyConfigLoaded, new LobbyPlus.LobbyConfigLoaded(LobbyConfigLoaded));
}
internal static void LobbyConfigLoaded()
{
//IL_002e: Unknown result type (might be due to invalid IL or missing references)
//IL_0063: Unknown result type (might be due to invalid IL or missing references)
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
//IL_0069: Unknown result type (might be due to invalid IL or missing references)
//IL_007b: Expected I4, but got Unknown
//IL_0082: 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_00a6: Unknown result type (might be due to invalid IL or missing references)
//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
//IL_0118: Unknown result type (might be due to invalid IL or missing references)
//IL_0137: Unknown result type (might be due to invalid IL or missing references)
UpdateSettings();
if ((Object)(object)lobbySettings != (Object)null)
{
UpdateLobbySettings();
}
if ((Object)(object)lobbyGameModesAndMaps != (Object)null)
{
UpdateLobbyGameModesAndMaps();
}
if (MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.currentLobby.m_SteamID != 0L && MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.IsLobbyOwner())
{
MonoBehaviourPublicInInUnique.LobbySettingsUpdate(MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.Instance.gameSettings, 69uL);
EnumNPublicSealedvaLoFrPu4vUnique field_Public_EnumNPublicSealedvaLoFrPu4vUnique_ = MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.Instance.gameSettings.field_Public_EnumNPublicSealedvaLoFrPu4vUnique_0;
switch ((int)field_Public_EnumNPublicSealedvaLoFrPu4vUnique_)
{
case 0:
SteamMatchmaking.SetLobbyType(MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.currentLobby, (ELobbyType)3);
SteamMatchmaking.SetLobbyType(MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.currentLobby, (ELobbyType)0);
break;
case 1:
SteamMatchmaking.SetLobbyType(MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.currentLobby, (ELobbyType)1);
break;
case 2:
SteamMatchmaking.SetLobbyType(MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.currentLobby, (ELobbyType)2);
break;
}
SteamMatchmaking.SetLobbyData(MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.currentLobby, "Voice Chat", (MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.Instance.gameSettings.field_Public_Int32_3 == 1).ToString());
SteamMatchmaking.SetLobbyMemberLimit(MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.currentLobby, MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.Instance.gameSettings.field_Public_Int32_4);
SteamMatchmaking.SetLobbyData(MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.currentLobby, "Modes", MonoBehaviourPublicGadealGaLi1pralObInUnique.Instance.GetAvailableModesString());
SteamMatchmaking.SetLobbyData(MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.currentLobby, "Maps", MonoBehaviourPublicObInMamaLi1plMadeMaUnique.Instance.GetAvailableMapsString());
if ((Object)(object)MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.Instance.gameMode == (Object)(object)MonoBehaviourPublicGadealGaLi1pralObInUnique.Instance.defaultMode && (Object)(object)MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.Instance.map != (Object)(object)MonoBehaviourPublicObInMamaLi1plMadeMaUnique.Instance.defaultMap)
{
MonoBehaviourPublicInInUnique.LoadMap(MonoBehaviourPublicObInMamaLi1plMadeMaUnique.Instance.defaultMap.id, MonoBehaviourPublicGadealGaLi1pralObInUnique.Instance.defaultMode.id);
}
}
}
internal static void UpdateSettings()
{
MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.Instance.gameSettings.field_Public_EnumNPublicSealedvaLoFrPu4vUnique_0 = (EnumNPublicSealedvaLoFrPu4vUnique)LobbyPlus.LobbyConfig.type.Value;
MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.Instance.gameSettings.field_Public_Int32_3 = (LobbyPlus.LobbyConfig.voiceChatEnabled.Value ? 1 : 0);
MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.Instance.gameSettings.field_Public_Int32_4 = LobbyPlus.LobbyConfig.maxPlayers.Value;
if ((Object)(object)MonoBehaviourPublicGadealGaLi1pralObInUnique.Instance != (Object)null)
{
UpdateGameModeSettings();
}
if ((Object)(object)MonoBehaviourPublicObInMamaLi1plMadeMaUnique.Instance != (Object)null)
{
UpdateMapSettings();
}
ObjectPublicInSiInInInInInInInInUnique.field_Public_Static_Int32_5 = LobbyPlus.LobbyConfig.freezePhaseTime.Value;
ObjectPublicInSiInInInInInInInInUnique.field_Public_Static_Int32_7 = LobbyPlus.LobbyConfig.roundOverPhaseTime.Value;
ObjectPublicInSiInInInInInInInInUnique.field_Public_Static_Int32_8 = LobbyPlus.LobbyConfig.gameOverPhaseTime.Value;
}
internal static void UpdateGameModeSettings()
{
MonoBehaviourPublicGadealGaLi1pralObInUnique.Instance.allPlayableGameModes.Clear();
if (LobbyPlus.LobbyConfig.enabledGameModes.Value[0] == "*")
{
foreach (GameModeData item in (Il2CppArrayBase<GameModeData>)(object)MonoBehaviourPublicGadealGaLi1pralObInUnique.Instance.allGameModes)
{
if (!item.skipAsString && item.isPlayable)
{
MonoBehaviourPublicGadealGaLi1pralObInUnique.Instance.allPlayableGameModes.Add(item);
}
}
return;
}
IEnumerable<string> source = LobbyPlus.LobbyConfig.enabledGameModes.Value.Select((string gameMode) => gameMode.Replace(" ", "").ToLower());
foreach (GameModeData item2 in (Il2CppArrayBase<GameModeData>)(object)MonoBehaviourPublicGadealGaLi1pralObInUnique.Instance.allGameModes)
{
if (!item2.skipAsString && item2.isPlayable && source.Contains(item2.modeName.Replace(" ", "").ToLower()))
{
MonoBehaviourPublicGadealGaLi1pralObInUnique.Instance.allPlayableGameModes.Add(item2);
}
}
}
internal static void UpdateMapSettings()
{
MonoBehaviourPublicObInMamaLi1plMadeMaUnique.Instance.playableMaps.Clear();
if (LobbyPlus.LobbyConfig.enabledMaps.Value[0] == "*")
{
foreach (Map item in (Il2CppArrayBase<Map>)(object)MonoBehaviourPublicObInMamaLi1plMadeMaUnique.Instance.maps)
{
MonoBehaviourPublicObInMamaLi1plMadeMaUnique.Instance.playableMaps.Add(item);
}
}
else
{
IEnumerable<string> source = LobbyPlus.LobbyConfig.enabledMaps.Value.Select((string map) => map.Replace(" ", "").ToLower());
foreach (Map item2 in (Il2CppArrayBase<Map>)(object)MonoBehaviourPublicObInMamaLi1plMadeMaUnique.Instance.maps)
{
if (source.Contains(item2.mapName.Replace(" ", "").ToLower()))
{
MonoBehaviourPublicObInMamaLi1plMadeMaUnique.Instance.playableMaps.Add(item2);
}
}
}
MonoBehaviourPublicObInMamaLi1plMadeMaUnique.Instance.defaultMap = null;
foreach (Map item3 in (Il2CppArrayBase<Map>)(object)MonoBehaviourPublicObInMamaLi1plMadeMaUnique.Instance.maps)
{
if (LobbyPlus.LobbyConfig.lobbyMap.Value.Replace(" ", "").ToLower() == item3.mapName.Replace(" ", "").ToLower())
{
MonoBehaviourPublicObInMamaLi1plMadeMaUnique.Instance.defaultMap = item3;
}
}
if ((Object)(object)MonoBehaviourPublicObInMamaLi1plMadeMaUnique.Instance.defaultMap == (Object)null)
{
MonoBehaviourPublicObInMamaLi1plMadeMaUnique.Instance.defaultMap = ((Il2CppArrayBase<Map>)(object)MonoBehaviourPublicObInMamaLi1plMadeMaUnique.Instance.maps)[6];
}
}
internal static void UpdateLobbySettings()
{
((BasePlugin)LobbyPlus.Instance).Config.Reload();
if (LobbyPlus.MaxPlayersSlider.Value < 40)
{
LobbyPlus.MaxPlayersSlider.Value = 40;
}
ObjectPublicInSiInInInInInInInInUnique.field_Public_Static_Int32_0 = LobbyPlus.MaxPlayersSlider.Value;
lobbySettings.maxPlayers.slider.maxValue = ObjectPublicInSiInInInInInInInInUnique.field_Public_Static_Int32_0;
lobbySettings.serverNameField.text = LobbyPlus.LobbyConfig.motds.Value[0];
lobbySettings.UpdateServerName();
lobbySettings.lobbyType.SetSettings(Il2CppStringArray.op_Implicit(Enum.GetNames(typeof(EnumNPublicSealedvaLoFrPu4vUnique))), LobbyPlus.LobbyConfig.type.Value);
lobbySettings.proximityChat.SetSetting(LobbyPlus.LobbyConfig.voiceChatEnabled.Value);
lobbySettings.maxPlayers.SetSettings(LobbyPlus.LobbyConfig.maxPlayers.Value);
}
internal static void UpdateLobbyGameModesAndMaps()
{
for (int num = lobbyGameModesAndMaps.modeContainer.childCount - 1; num >= 0; num--)
{
Object.Destroy((Object)(object)((Component)lobbyGameModesAndMaps.modeContainer.GetChild(num)).gameObject);
}
for (int num2 = lobbyGameModesAndMaps.mapContainer.childCount - 1; num2 >= 0; num2--)
{
Object.Destroy((Object)(object)((Component)lobbyGameModesAndMaps.mapContainer.GetChild(num2)).gameObject);
}
lobbyGameModesAndMaps.Start();
}
}
internal static class MessageOfTheDay
{
[CompilerGenerated]
private sealed class <Loop>d__5 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <Loop>d__5(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_0047: Unknown result type (might be due to invalid IL or missing references)
//IL_0051: Expected O, but got Unknown
int num = <>1__state;
if (num != 0)
{
if (num != 1)
{
return false;
}
<>1__state = -1;
}
else
{
<>1__state = -1;
}
SteamMatchmaking.SetLobbyData(MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.currentLobby, "LobbyName", motds.Dequeue());
<>2__current = (object)new WaitForSeconds((float)LobbyPlus.LobbyConfig.motdCycleTime.Value);
<>1__state = 1;
return true;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
internal static RandomEndlessQueue<string> motds;
internal static Coroutine loop;
internal static void Init()
{
LobbyPlus.onLobbyConfigLoaded = (LobbyPlus.LobbyConfigLoaded)Delegate.Combine(LobbyPlus.onLobbyConfigLoaded, new LobbyPlus.LobbyConfigLoaded(LobbyConfigLoaded));
}
internal static void LobbyConfigLoaded()
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
if (MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.currentLobby.m_SteamID != 0L && MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.IsLobbyOwner())
{
Stop();
Start();
}
}
internal static void Start()
{
if (LobbyPlus.LobbyConfig.motdCycleTime.Value != 0)
{
motds = new RandomEndlessQueue<string>(LobbyPlus.LobbyConfig.motds.Value);
loop = ((MonoBehaviour)MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.Instance).StartCoroutine(CollectionExtensions.WrapToIl2Cpp(Loop()));
}
}
[IteratorStateMachine(typeof(<Loop>d__5))]
internal static IEnumerator Loop()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <Loop>d__5(0);
}
internal static void Stop()
{
if (loop != null)
{
((MonoBehaviour)MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.Instance).StopCoroutine(loop);
loop = null;
}
motds = null;
}
}
public class RandomEndlessQueue<T>
{
private readonly Random random = new Random();
private readonly T[] items = items.ToArray();
private List<T> queue = items.ToList();
private T lastItem;
public RandomEndlessQueue(IEnumerable<T> items)
{
}
public T Dequeue()
{
if (items.Length == 0)
{
return default(T);
}
if (items.Length == 1)
{
return items[0];
}
bool flag = queue.Count == 0;
if (flag)
{
queue = items.ToList();
}
int num = (flag ? queue.IndexOf(lastItem) : queue.Count);
int num2 = random.Next(flag ? (queue.Count - 1) : queue.Count);
if (num2 >= num)
{
num2++;
}
lastItem = queue[num2];
queue.RemoveAt(num2);
return lastItem;
}
}
internal static class ServerMessages
{
[CompilerGenerated]
private sealed class <Loop>d__9 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <Loop>d__9(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
//IL_0032: Expected O, but got Unknown
int num = <>1__state;
if (num != 0)
{
if (num != 1)
{
return false;
}
<>1__state = -1;
ChatUtil.SendMessage(serverMessages.Dequeue(), (MessageType)1, (string)null, (IEnumerable<ulong>)null);
}
else
{
<>1__state = -1;
}
<>2__current = (object)new WaitForSeconds((float)LobbyPlus.LobbyConfig.serverMessageCycleTime.Value);
<>1__state = 1;
return true;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
internal static RandomEndlessQueue<string> serverMessages;
internal static Coroutine loop;
internal static RandomEndlessQueue<string> serverDeathMessages;
internal static RandomEndlessQueue<string> serverKillMessages;
internal static RandomEndlessQueue<string> serverWinMessages;
internal static Dictionary<ulong, ulong> lastAttackers = new Dictionary<ulong, ulong>();
internal static void Init()
{
LobbyPlus.onLobbyConfigLoaded = (LobbyPlus.LobbyConfigLoaded)Delegate.Combine(LobbyPlus.onLobbyConfigLoaded, new LobbyPlus.LobbyConfigLoaded(LobbyConfigLoaded));
}
internal static void LobbyConfigLoaded()
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
if (MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.currentLobby.m_SteamID != 0L && MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.IsLobbyOwner())
{
Stop();
Start();
}
}
internal static void Start()
{
if (LobbyPlus.LobbyConfig.serverMessageCycleTime.Value != 0)
{
serverMessages = new RandomEndlessQueue<string>(LobbyPlus.LobbyConfig.serverMessages.Value);
loop = ((MonoBehaviour)MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.Instance).StartCoroutine(CollectionExtensions.WrapToIl2Cpp(Loop()));
}
serverDeathMessages = new RandomEndlessQueue<string>(LobbyPlus.LobbyConfig.serverDeathMessages.Value);
serverKillMessages = new RandomEndlessQueue<string>(LobbyPlus.LobbyConfig.serverKillMessages.Value);
serverWinMessages = new RandomEndlessQueue<string>(LobbyPlus.LobbyConfig.serverWinMessages.Value);
}
[IteratorStateMachine(typeof(<Loop>d__9))]
internal static IEnumerator Loop()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <Loop>d__9(0);
}
internal static void SendDeathMessage(ulong clientId)
{
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
if (LobbyPlus.LobbyConfig.serverDeathMessages.Value.Length != 0)
{
ChatUtil.SendMessage(serverDeathMessages.Dequeue().Replace("{PLAYER}", SteamFriends.GetFriendPersonaName(new CSteamID(clientId))), (MessageType)1, (string)null, (IEnumerable<ulong>)null);
}
}
internal static void SendKillMessage(ulong clientId, ulong killerClientId)
{
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
if (LobbyPlus.LobbyConfig.serverKillMessages.Value.Length != 0)
{
ChatUtil.SendMessage(serverKillMessages.Dequeue().Replace("{KILLER}", SteamFriends.GetFriendPersonaName(new CSteamID(killerClientId))).Replace("{PLAYER}", SteamFriends.GetFriendPersonaName(new CSteamID(clientId))), (MessageType)1, (string)null, (IEnumerable<ulong>)null);
}
}
internal static void SendWinMessage(ulong clientId)
{
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
if (LobbyPlus.LobbyConfig.serverWinMessages.Value.Length != 0)
{
ChatUtil.SendMessage(serverWinMessages.Dequeue().Replace("{PLAYER}", SteamFriends.GetFriendPersonaName(new CSteamID(clientId))), (MessageType)1, (string)null, (IEnumerable<ulong>)null);
}
}
internal static void Stop()
{
if (loop != null)
{
((MonoBehaviour)MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.Instance).StopCoroutine(loop);
loop = null;
}
serverMessages = null;
serverDeathMessages = null;
serverKillMessages = null;
serverWinMessages = null;
}
}
internal static class WinnerItemSpam
{
[CompilerGenerated]
private sealed class <Coroutine>d__1 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public ulong clientId;
private Random <random>5__2;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <Coroutine>d__1(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<random>5__2 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
//IL_00ab: Expected O, but got Unknown
int num = <>1__state;
if (num != 0)
{
if (num != 1)
{
return false;
}
<>1__state = -1;
}
else
{
<>1__state = -1;
<random>5__2 = new Random();
}
if (!MonoBehaviourPublicDi2UIObacspDi2UIObUnique.Instance.activePlayers.ContainsKey(clientId) || MonoBehaviourPublicDi2UIObacspDi2UIObUnique.Instance.activePlayers[clientId].dead)
{
return false;
}
MonoBehaviourPublicInInUnique.DropItem(clientId, LobbyPlus.LobbyConfig.winnerItemSpamItems.Value[<random>5__2.Next(LobbyPlus.LobbyConfig.winnerItemSpamItems.Value.Length)], MonoBehaviourPublicDi2InObInObInUnique.Instance.GetNextId(), int.MaxValue);
<>2__current = (object)new WaitForEndOfFrame();
<>1__state = 1;
return true;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
internal static void Start(ulong clientId)
{
if (LobbyPlus.LobbyConfig.winnerItemSpamItems.Value.Length != 0)
{
((MonoBehaviour)MonoBehaviourPublicDi2UIObacspDi2UIObUnique.Instance).StartCoroutine(CollectionExtensions.WrapToIl2Cpp(Coroutine(clientId)));
}
}
[IteratorStateMachine(typeof(<Coroutine>d__1))]
internal static IEnumerator Coroutine(ulong clientId)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <Coroutine>d__1(0)
{
clientId = clientId
};
}
}
}
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
internal sealed class IgnoresAccessChecksToAttribute : Attribute
{
public IgnoresAccessChecksToAttribute(string assemblyName)
{
}
}
}
[CompilerGenerated]
internal sealed class <>z__ReadOnlySingleElementList<T> : IEnumerable, ICollection, IList, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, ICollection<T>, IList<T>
{
private sealed class Enumerator : IDisposable, IEnumerator, IEnumerator<T>
{
object IEnumerator.Current => _item;
T IEnumerator<T>.Current => _item;
public Enumerator(T item)
{
_item = item;
}
bool IEnumerator.MoveNext()
{
if (!_moveNextCalled)
{
return _moveNextCalled = true;
}
return false;
}
void IEnumerator.Reset()
{
_moveNextCalled = false;
}
void IDisposable.Dispose()
{
}
}
int ICollection.Count => 1;
bool ICollection.IsSynchronized => false;
object ICollection.SyncRoot => this;
object IList.this[int index]
{
get
{
if (index != 0)
{
throw new IndexOutOfRangeException();
}
return _item;
}
set
{
throw new NotSupportedException();
}
}
bool IList.IsFixedSize => true;
bool IList.IsReadOnly => true;
int IReadOnlyCollection<T>.Count => 1;
T IReadOnlyList<T>.this[int index]
{
get
{
if (index != 0)
{
throw new IndexOutOfRangeException();
}
return _item;
}
}
int ICollection<T>.Count => 1;
bool ICollection<T>.IsReadOnly => true;
T IList<T>.this[int index]
{
get
{
if (index != 0)
{
throw new IndexOutOfRangeException();
}
return _item;
}
set
{
throw new NotSupportedException();
}
}
public <>z__ReadOnlySingleElementList(T item)
{
_item = item;
}
IEnumerator IEnumerable.GetEnumerator()
{
return new Enumerator(_item);
}
void ICollection.CopyTo(Array array, int index)
{
array.SetValue(_item, index);
}
int IList.Add(object value)
{
throw new NotSupportedException();
}
void IList.Clear()
{
throw new NotSupportedException();
}
bool IList.Contains(object value)
{
return EqualityComparer<T>.Default.Equals(_item, (T)value);
}
int IList.IndexOf(object value)
{
if (!EqualityComparer<T>.Default.Equals(_item, (T)value))
{
return -1;
}
return 0;
}
void IList.Insert(int index, object value)
{
throw new NotSupportedException();
}
void IList.Remove(object value)
{
throw new NotSupportedException();
}
void IList.RemoveAt(int index)
{
throw new NotSupportedException();
}
IEnumerator<T> IEnumerable<T>.GetEnumerator()
{
return new Enumerator(_item);
}
void ICollection<T>.Add(T item)
{
throw new NotSupportedException();
}
void ICollection<T>.Clear()
{
throw new NotSupportedException();
}
bool ICollection<T>.Contains(T item)
{
return EqualityComparer<T>.Default.Equals(_item, item);
}
void ICollection<T>.CopyTo(T[] array, int arrayIndex)
{
array[arrayIndex] = _item;
}
bool ICollection<T>.Remove(T item)
{
throw new NotSupportedException();
}
int IList<T>.IndexOf(T item)
{
if (!EqualityComparer<T>.Default.Equals(_item, item))
{
return -1;
}
return 0;
}
void IList<T>.Insert(int index, T item)
{
throw new NotSupportedException();
}
void IList<T>.RemoveAt(int index)
{
throw new NotSupportedException();
}
}
