using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BiggerLobbies;
using BiggerLobbies.Integrations;
using HarmonyLib;
using Il2Cpp;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppScheduleOne.DevUtilities;
using Il2CppScheduleOne.Networking;
using Il2CppScheduleOne.UI.Multiplayer;
using Il2CppSteamworks;
using Il2CppSystem;
using Il2CppTMPro;
using MelonLoader;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.UI;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: MelonInfo(typeof(Core), "BiggerLobbies", "1.0.0", "Bars", null)]
[assembly: MelonGame("TVGS", "Schedule I")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("BiggerLobbies_Il2cpp")]
[assembly: AssemblyConfiguration("Il2cpp")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("BiggerLobbies_Il2cpp")]
[assembly: AssemblyTitle("BiggerLobbies_Il2cpp")]
[assembly: NeutralResourcesLanguage("en-US")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.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.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]
[Microsoft.CodeAnalysis.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]
[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 BiggerLobbies
{
public class Core : MelonMod
{
public static Core? Instance { get; private set; }
public override void OnInitializeMelon()
{
Instance = this;
HarmonyPatches.SetModInstance(this);
}
public override void OnApplicationQuit()
{
Instance = null;
}
}
}
namespace BiggerLobbies.Utils
{
public static class Constants
{
public static class Game
{
public const string GAME_STUDIO = "TVGS";
public const string GAME_NAME = "Schedule I";
}
public const string MOD_NAME = "BiggerLobbies";
public const string MOD_VERSION = "1.0.0";
public const string MOD_AUTHOR = "Bars";
public const int MAX_PLAYERS = 20;
}
}
namespace BiggerLobbies.Integrations
{
[HarmonyPatch]
public static class HarmonyPatches
{
[CompilerGenerated]
private sealed class <WaitForLobby>d__7 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public LobbyInterface lobbyInterface;
private Lobby <lobby>5__1;
private GridLayoutGroup <gridGroup>5__2;
private Transform <entries>5__3;
private int <slotCount>5__4;
private RectTransform[] <newSlots>5__5;
private CSteamID[] <newPlayers>5__6;
private int <copyLength>5__7;
private Transform <template>5__8;
private int <slotsToAdd>5__9;
private int <i>5__10;
private GameObject <newEntry>5__11;
private int <newIndex>5__12;
private int <j>5__13;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <WaitForLobby>d__7(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<lobby>5__1 = null;
<gridGroup>5__2 = null;
<entries>5__3 = null;
<newSlots>5__5 = null;
<newPlayers>5__6 = null;
<template>5__8 = null;
<newEntry>5__11 = null;
<>1__state = -2;
}
private bool MoveNext()
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
break;
case 1:
<>1__state = -1;
break;
}
if ((Object)(object)Singleton<Lobby>.Instance == (Object)null)
{
<>2__current = null;
<>1__state = 1;
return true;
}
<lobby>5__1 = Singleton<Lobby>.Instance;
if (((Il2CppArrayBase<CSteamID>)(object)<lobby>5__1.Players).Length != 20)
{
<newPlayers>5__6 = (CSteamID[])(object)new CSteamID[20];
<copyLength>5__7 = Math.Min(((Il2CppArrayBase<CSteamID>)(object)<lobby>5__1.Players).Length, 20);
Array.Copy(Il2CppArrayBase<CSteamID>.op_Implicit((Il2CppArrayBase<CSteamID>)(object)<lobby>5__1.Players), <newPlayers>5__6, <copyLength>5__7);
<lobby>5__1.Players = Il2CppStructArray<CSteamID>.op_Implicit(<newPlayers>5__6);
<newPlayers>5__6 = null;
}
if (!SteamManager.Initialized)
{
((Component)lobbyInterface).gameObject.SetActive(false);
return false;
}
<gridGroup>5__2 = ((Component)lobbyInterface).GetComponentInChildren<GridLayoutGroup>();
if ((Object)(object)<gridGroup>5__2 == (Object)null)
{
MelonLogger.Error("Could not find GridLayoutGroup in LobbyInterface");
return false;
}
<entries>5__3 = ((Component)<gridGroup>5__2).transform;
if (<entries>5__3.childCount > 1)
{
<template>5__8 = <entries>5__3.GetChild(1);
<slotsToAdd>5__9 = 16;
<i>5__10 = 0;
while (<i>5__10 < <slotsToAdd>5__9)
{
<newEntry>5__11 = Object.Instantiate<GameObject>(((Component)<template>5__8).gameObject, <entries>5__3);
<newIndex>5__12 = <entries>5__3.childCount - 1;
((Object)<newEntry>5__11).name = ((Object)((Component)<template>5__8).gameObject).name + " (" + <newIndex>5__12 + ")";
<newEntry>5__11 = null;
<i>5__10++;
}
<template>5__8.SetSiblingIndex(20);
<template>5__8 = null;
}
<slotCount>5__4 = <entries>5__3.childCount - 1;
<newSlots>5__5 = (RectTransform[])(object)new RectTransform[<slotCount>5__4];
<j>5__13 = 1;
while (<j>5__13 < <entries>5__3.childCount)
{
<newSlots>5__5[<j>5__13 - 1] = ((Component)<entries>5__3.GetChild(<j>5__13)).GetComponent<RectTransform>();
<j>5__13++;
}
lobbyInterface.PlayerSlots = Il2CppReferenceArray<RectTransform>.op_Implicit(<newSlots>5__5);
((TMP_Text)lobbyInterface.LobbyTitle).text = "Lobby (" + <lobby>5__1.PlayerCount + "/" + 20 + ")";
((Behaviour)lobbyInterface).enabled = true;
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
private static Core? _modInstance;
public static void SetModInstance(Core modInstance)
{
_modInstance = modInstance;
}
[HarmonyPostfix]
[HarmonyPatch(typeof(Lobby), "Start")]
private static void Lobby_Start_Postfix(Lobby __instance)
{
try
{
if (((Il2CppArrayBase<CSteamID>)(object)__instance.Players).Length != 20)
{
CSteamID[] array = (CSteamID[])(object)new CSteamID[20];
int length = Math.Min(((Il2CppArrayBase<CSteamID>)(object)__instance.Players).Length, 20);
Array.Copy(Il2CppArrayBase<CSteamID>.op_Implicit((Il2CppArrayBase<CSteamID>)(object)__instance.Players), array, length);
__instance.Players = Il2CppStructArray<CSteamID>.op_Implicit(array);
}
}
catch (Exception arg)
{
MelonLogger.Error($"Failed to resize Lobby.Players array: {arg}");
}
}
[HarmonyPrefix]
[HarmonyPatch(typeof(Lobby), "CreateLobby")]
private static bool Lobby_CreateLobby_Prefix(Lobby __instance)
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
try
{
SteamMatchmaking.CreateLobby((ELobbyType)1, 20);
return false;
}
catch (Exception arg)
{
MelonLogger.Error($"Failed to patch CreateLobby: {arg}");
return true;
}
}
[HarmonyPrefix]
[HarmonyPatch(typeof(Lobby), "TryOpenInviteInterface")]
private static bool Lobby_TryOpenInviteInterface_Prefix(Lobby __instance)
{
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
try
{
if (!__instance.IsInLobby)
{
MelonLogger.Msg("Not currently in a lobby, creating one...");
SteamMatchmaking.CreateLobby((ELobbyType)1, 20);
}
int numLobbyMembers = SteamMatchmaking.GetNumLobbyMembers(__instance.LobbySteamID);
if (numLobbyMembers >= 20)
{
MelonLogger.Warning("Lobby already at max capacity!");
return false;
}
SteamFriends.ActivateGameOverlayInviteDialog(__instance.LobbySteamID);
return false;
}
catch (Exception arg)
{
MelonLogger.Error($"Failed to patch TryOpenInviteInterface: {arg}");
return true;
}
}
[HarmonyPostfix]
[HarmonyPatch(typeof(Lobby), "OnLobbyCreated")]
private static void Lobby_OnLobbyCreated_Postfix(Lobby __instance, LobbyCreated_t result)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
//IL_0009: Invalid comparison between Unknown and I4
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0016: 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_0027: Unknown result type (might be due to invalid IL or missing references)
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
try
{
if ((int)result.m_eResult == 1)
{
CSteamID val = (CSteamID)result.m_ulSteamIDLobby;
string text = 20.ToString();
SteamMatchmaking.SetLobbyData(val, "max_players", text);
SteamMatchmaking.SetLobbyData(val, "num_slots", text);
MelonLogger.Msg($"Set lobby max_players and num_slots to {20}");
}
}
catch (Exception arg)
{
MelonLogger.Error($"Failed to set lobby max_players/num_slots: {arg}");
}
}
[HarmonyPostfix]
[HarmonyPatch(typeof(LobbyInterface), "Awake")]
private static void LobbyInterface_Awake_Postfix(LobbyInterface __instance)
{
try
{
if (_modInstance != null)
{
MelonCoroutines.Start(WaitForLobby(__instance));
}
}
catch (Exception arg)
{
MelonLogger.Error($"Failed to start WaitForLobby coroutine: {arg}");
}
}
[IteratorStateMachine(typeof(<WaitForLobby>d__7))]
private static IEnumerator WaitForLobby(LobbyInterface lobbyInterface)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <WaitForLobby>d__7(0)
{
lobbyInterface = lobbyInterface
};
}
[HarmonyPostfix]
[HarmonyPatch(typeof(LobbyInterface), "Awake")]
private static void LobbyInterface_Awake_Postfix_UpdateTitle(LobbyInterface __instance)
{
try
{
if (!((Object)(object)__instance.Lobby != (Object)null))
{
return;
}
Action originalDelegate = __instance.Lobby.onLobbyChange;
__instance.Lobby.onLobbyChange = null;
__instance.Lobby.onLobbyChange = Action.op_Implicit((Action)delegate
{
if ((Delegate)(object)originalDelegate != (Delegate)null)
{
originalDelegate.Invoke();
}
else
{
__instance.UpdateButtons();
__instance.UpdatePlayers();
}
((TMP_Text)__instance.LobbyTitle).text = "Lobby (" + __instance.Lobby.PlayerCount + "/" + 20 + ")";
});
}
catch (Exception arg)
{
MelonLogger.Error($"Failed to patch onLobbyChange delegate: {arg}");
}
}
[HarmonyPostfix]
[HarmonyPatch(typeof(LobbyInterface), "UpdateButtons")]
private static void LobbyInterface_UpdateButtons_Postfix(LobbyInterface __instance)
{
try
{
((Component)__instance.InviteButton).gameObject.SetActive(__instance.Lobby.IsHost && __instance.Lobby.PlayerCount < 20);
}
catch (Exception arg)
{
MelonLogger.Error($"Failed to patch UpdateButtons: {arg}");
}
}
}
}using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BiggerLobbies;
using BiggerLobbies.Integrations;
using HarmonyLib;
using MelonLoader;
using Microsoft.CodeAnalysis;
using ScheduleOne.DevUtilities;
using ScheduleOne.Networking;
using ScheduleOne.UI.Multiplayer;
using Steamworks;
using TMPro;
using UnityEngine;
using UnityEngine.UI;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: MelonInfo(typeof(Core), "BiggerLobbies", "1.0.0", "Bars", null)]
[assembly: MelonGame("TVGS", "Schedule I")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("BiggerLobbies_Mono")]
[assembly: AssemblyConfiguration("Mono")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("BiggerLobbies_Mono")]
[assembly: AssemblyTitle("BiggerLobbies_Mono")]
[assembly: NeutralResourcesLanguage("en-US")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.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.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]
[Microsoft.CodeAnalysis.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]
[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 BiggerLobbies
{
public class Core : MelonMod
{
public static Core? Instance { get; private set; }
public override void OnInitializeMelon()
{
Instance = this;
HarmonyPatches.SetModInstance(this);
}
public override void OnApplicationQuit()
{
Instance = null;
}
}
}
namespace BiggerLobbies.Utils
{
public static class Constants
{
public static class Game
{
public const string GAME_STUDIO = "TVGS";
public const string GAME_NAME = "Schedule I";
}
public const string MOD_NAME = "BiggerLobbies";
public const string MOD_VERSION = "1.0.0";
public const string MOD_AUTHOR = "Bars";
public const int MAX_PLAYERS = 20;
}
}
namespace BiggerLobbies.Integrations
{
[HarmonyPatch]
public static class HarmonyPatches
{
[CompilerGenerated]
private sealed class <WaitForLobby>d__7 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public LobbyInterface lobbyInterface;
private Lobby <lobby>5__1;
private GridLayoutGroup <gridGroup>5__2;
private Transform <entries>5__3;
private int <slotCount>5__4;
private RectTransform[] <newSlots>5__5;
private CSteamID[] <newPlayers>5__6;
private int <copyLength>5__7;
private Transform <template>5__8;
private int <slotsToAdd>5__9;
private int <i>5__10;
private GameObject <newEntry>5__11;
private int <newIndex>5__12;
private int <j>5__13;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <WaitForLobby>d__7(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<lobby>5__1 = null;
<gridGroup>5__2 = null;
<entries>5__3 = null;
<newSlots>5__5 = null;
<newPlayers>5__6 = null;
<template>5__8 = null;
<newEntry>5__11 = null;
<>1__state = -2;
}
private bool MoveNext()
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
break;
case 1:
<>1__state = -1;
break;
}
if ((Object)(object)Singleton<Lobby>.Instance == (Object)null)
{
<>2__current = null;
<>1__state = 1;
return true;
}
<lobby>5__1 = Singleton<Lobby>.Instance;
if (<lobby>5__1.Players.Length != 20)
{
<newPlayers>5__6 = (CSteamID[])(object)new CSteamID[20];
<copyLength>5__7 = Math.Min(<lobby>5__1.Players.Length, 20);
Array.Copy(<lobby>5__1.Players, <newPlayers>5__6, <copyLength>5__7);
<lobby>5__1.Players = <newPlayers>5__6;
<newPlayers>5__6 = null;
}
if (!SteamManager.Initialized)
{
((Component)lobbyInterface).gameObject.SetActive(false);
return false;
}
<gridGroup>5__2 = ((Component)lobbyInterface).GetComponentInChildren<GridLayoutGroup>();
if ((Object)(object)<gridGroup>5__2 == (Object)null)
{
MelonLogger.Error("Could not find GridLayoutGroup in LobbyInterface");
return false;
}
<entries>5__3 = ((Component)<gridGroup>5__2).transform;
if (<entries>5__3.childCount > 1)
{
<template>5__8 = <entries>5__3.GetChild(1);
<slotsToAdd>5__9 = 16;
<i>5__10 = 0;
while (<i>5__10 < <slotsToAdd>5__9)
{
<newEntry>5__11 = Object.Instantiate<GameObject>(((Component)<template>5__8).gameObject, <entries>5__3);
<newIndex>5__12 = <entries>5__3.childCount - 1;
((Object)<newEntry>5__11).name = ((Object)((Component)<template>5__8).gameObject).name + " (" + <newIndex>5__12 + ")";
<newEntry>5__11 = null;
<i>5__10++;
}
<template>5__8.SetSiblingIndex(20);
<template>5__8 = null;
}
<slotCount>5__4 = <entries>5__3.childCount - 1;
<newSlots>5__5 = (RectTransform[])(object)new RectTransform[<slotCount>5__4];
<j>5__13 = 1;
while (<j>5__13 < <entries>5__3.childCount)
{
<newSlots>5__5[<j>5__13 - 1] = ((Component)<entries>5__3.GetChild(<j>5__13)).GetComponent<RectTransform>();
<j>5__13++;
}
lobbyInterface.PlayerSlots = <newSlots>5__5;
((TMP_Text)lobbyInterface.LobbyTitle).text = "Lobby (" + <lobby>5__1.PlayerCount + "/" + 20 + ")";
((Behaviour)lobbyInterface).enabled = true;
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
private static Core? _modInstance;
public static void SetModInstance(Core modInstance)
{
_modInstance = modInstance;
}
[HarmonyPostfix]
[HarmonyPatch(typeof(Lobby), "Start")]
private static void Lobby_Start_Postfix(Lobby __instance)
{
try
{
if (__instance.Players.Length != 20)
{
CSteamID[] array = (CSteamID[])(object)new CSteamID[20];
int length = Math.Min(__instance.Players.Length, 20);
Array.Copy(__instance.Players, array, length);
__instance.Players = array;
}
}
catch (Exception arg)
{
MelonLogger.Error($"Failed to resize Lobby.Players array: {arg}");
}
}
[HarmonyPrefix]
[HarmonyPatch(typeof(Lobby), "CreateLobby")]
private static bool Lobby_CreateLobby_Prefix(Lobby __instance)
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
try
{
SteamMatchmaking.CreateLobby((ELobbyType)1, 20);
return false;
}
catch (Exception arg)
{
MelonLogger.Error($"Failed to patch CreateLobby: {arg}");
return true;
}
}
[HarmonyPrefix]
[HarmonyPatch(typeof(Lobby), "TryOpenInviteInterface")]
private static bool Lobby_TryOpenInviteInterface_Prefix(Lobby __instance)
{
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
try
{
if (!__instance.IsInLobby)
{
MelonLogger.Msg("Not currently in a lobby, creating one...");
SteamMatchmaking.CreateLobby((ELobbyType)1, 20);
}
int numLobbyMembers = SteamMatchmaking.GetNumLobbyMembers(__instance.LobbySteamID);
if (numLobbyMembers >= 20)
{
MelonLogger.Warning("Lobby already at max capacity!");
return false;
}
SteamFriends.ActivateGameOverlayInviteDialog(__instance.LobbySteamID);
return false;
}
catch (Exception arg)
{
MelonLogger.Error($"Failed to patch TryOpenInviteInterface: {arg}");
return true;
}
}
[HarmonyPostfix]
[HarmonyPatch(typeof(Lobby), "OnLobbyCreated")]
private static void Lobby_OnLobbyCreated_Postfix(Lobby __instance, LobbyCreated_t result)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
//IL_0009: Invalid comparison between Unknown and I4
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0016: 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_0027: Unknown result type (might be due to invalid IL or missing references)
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
try
{
if ((int)result.m_eResult == 1)
{
CSteamID val = (CSteamID)result.m_ulSteamIDLobby;
string text = 20.ToString();
SteamMatchmaking.SetLobbyData(val, "max_players", text);
SteamMatchmaking.SetLobbyData(val, "num_slots", text);
MelonLogger.Msg($"Set lobby max_players and num_slots to {20}");
}
}
catch (Exception arg)
{
MelonLogger.Error($"Failed to set lobby max_players/num_slots: {arg}");
}
}
[HarmonyPostfix]
[HarmonyPatch(typeof(LobbyInterface), "Awake")]
private static void LobbyInterface_Awake_Postfix(LobbyInterface __instance)
{
try
{
if (_modInstance != null)
{
MelonCoroutines.Start(WaitForLobby(__instance));
}
}
catch (Exception arg)
{
MelonLogger.Error($"Failed to start WaitForLobby coroutine: {arg}");
}
}
[IteratorStateMachine(typeof(<WaitForLobby>d__7))]
private static IEnumerator WaitForLobby(LobbyInterface lobbyInterface)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <WaitForLobby>d__7(0)
{
lobbyInterface = lobbyInterface
};
}
[HarmonyPostfix]
[HarmonyPatch(typeof(LobbyInterface), "Awake")]
private static void LobbyInterface_Awake_Postfix_UpdateTitle(LobbyInterface __instance)
{
try
{
if (!((Object)(object)__instance.Lobby != (Object)null))
{
return;
}
Action originalDelegate = __instance.Lobby.onLobbyChange;
__instance.Lobby.onLobbyChange = null;
__instance.Lobby.onLobbyChange = delegate
{
if (originalDelegate != null)
{
originalDelegate();
}
else
{
__instance.UpdateButtons();
__instance.UpdatePlayers();
}
((TMP_Text)__instance.LobbyTitle).text = "Lobby (" + __instance.Lobby.PlayerCount + "/" + 20 + ")";
};
}
catch (Exception arg)
{
MelonLogger.Error($"Failed to patch onLobbyChange delegate: {arg}");
}
}
[HarmonyPostfix]
[HarmonyPatch(typeof(LobbyInterface), "UpdateButtons")]
private static void LobbyInterface_UpdateButtons_Postfix(LobbyInterface __instance)
{
try
{
((Component)__instance.InviteButton).gameObject.SetActive(__instance.Lobby.IsHost && __instance.Lobby.PlayerCount < 20);
}
catch (Exception arg)
{
MelonLogger.Error($"Failed to patch UpdateButtons: {arg}");
}
}
}
}