731 lines
20 KiB
C#
731 lines
20 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using RoR2.EntitlementManagement;
|
|
using RoR2.ExpansionManagement;
|
|
using RoR2.Networking;
|
|
using TMPro;
|
|
using UnityEngine;
|
|
using UnityEngine.UI;
|
|
|
|
namespace RoR2.UI.MainMenu;
|
|
|
|
[RequireComponent(typeof(FirstSelectedObjectProvider))]
|
|
public class MultiplayerMenuController : BaseMainMenuScreen
|
|
{
|
|
public enum Subview
|
|
{
|
|
Main,
|
|
FindGame,
|
|
HostGame
|
|
}
|
|
|
|
public enum MPButtons
|
|
{
|
|
HostGame,
|
|
FindGame,
|
|
Quickplay,
|
|
StartPrivateGame,
|
|
Invite,
|
|
FindFriendSession,
|
|
Back,
|
|
EnterGame,
|
|
NONE
|
|
}
|
|
|
|
private const float titleTransitionDuration = 0.5f;
|
|
|
|
private const float titleTransitionBuffer = 0.1f;
|
|
|
|
public Image fadeImage;
|
|
|
|
public LerpUIRect[] uiToLerp;
|
|
|
|
private float titleStopwatch;
|
|
|
|
private Subview _curSubView;
|
|
|
|
[Header("Subviews")]
|
|
public GameObject MainMultiplayerMenu;
|
|
|
|
public GameObject JoinGameMenu;
|
|
|
|
public GameObject HostGameMenu;
|
|
|
|
[Header("Buttons")]
|
|
public MPButton hostGame;
|
|
|
|
public MPButton findGame;
|
|
|
|
public MPButton quickplayButton;
|
|
|
|
public MPButton startPrivateGameButton;
|
|
|
|
public MPButton inviteButton;
|
|
|
|
public MPButton findFriendSessionButton;
|
|
|
|
public MPButton backButton;
|
|
|
|
public CarouselController gameModePicker;
|
|
|
|
public MPButton enterGameButton;
|
|
|
|
public GameObject[] lobbyActions;
|
|
|
|
[Header("Quickplay Logic")]
|
|
public LanguageTextMeshController quickplayLabelController;
|
|
|
|
public string quickplayStartToken;
|
|
|
|
public string quickplayStopToken;
|
|
|
|
public RectTransform quickplaySpinnerRectTransform;
|
|
|
|
public TextMeshProUGUI quickplayStateText;
|
|
|
|
private string pendingQuickplayText;
|
|
|
|
public RectTransform genericSpinnerRectTransform;
|
|
|
|
private const float spinnerRotationSpeed = 360f;
|
|
|
|
[Header("Sub-Views")]
|
|
public SteamJoinClipboardLobby joinClipboardLobbyButtonController;
|
|
|
|
public FriendSessionBrowserController friendSessionBrowserController;
|
|
|
|
public LobbyUserList lobbyUserList;
|
|
|
|
[Header("Platform Specific Components")]
|
|
public CarouselController lobbyVisibilityController;
|
|
|
|
public static float QuickplayWaitTime;
|
|
|
|
public bool IsQuickPlaySearching;
|
|
|
|
public bool IsQuickPlayButtonLocked;
|
|
|
|
private Coroutine checkCanPlayOnlineCoroutine;
|
|
|
|
public static MultiplayerMenuController instance { get; private set; }
|
|
|
|
public Subview GetCurrentSubview()
|
|
{
|
|
return _curSubView;
|
|
}
|
|
|
|
public void SetSubview(Subview targetSubview)
|
|
{
|
|
_curSubView = targetSubview;
|
|
MainMultiplayerMenu.SetActive(targetSubview == Subview.Main);
|
|
JoinGameMenu.SetActive(targetSubview == Subview.FindGame);
|
|
HostGameMenu.SetActive(targetSubview == Subview.HostGame);
|
|
if ((bool)lobbyUserList)
|
|
{
|
|
lobbyUserList.DisplayContent(targetSubview == Subview.HostGame || targetSubview == Subview.Main);
|
|
}
|
|
}
|
|
|
|
public void ReturnToMainSubview()
|
|
{
|
|
SetSubview(Subview.Main);
|
|
}
|
|
|
|
private void ToggleMPFeatures(MPFeatures featureFlags)
|
|
{
|
|
Toggle(hostGame, featureFlags.HasFlag(MPFeatures.HostGame));
|
|
Toggle(findGame, featureFlags.HasFlag(MPFeatures.FindGame));
|
|
Toggle(quickplayButton, featureFlags.HasFlag(MPFeatures.Quickplay));
|
|
Toggle(gameModePicker, val: true);
|
|
Toggle(startPrivateGameButton, featureFlags.HasFlag(MPFeatures.PrivateGame));
|
|
Toggle(inviteButton, featureFlags.HasFlag(MPFeatures.Invite));
|
|
Toggle(findFriendSessionButton, featureFlags.HasFlag(MPFeatures.FindFriendSession));
|
|
Toggle(enterGameButton, featureFlags.HasFlag(MPFeatures.EnterGameButton));
|
|
}
|
|
|
|
private void ToggleMPFeaturesInteractable(MPFeatures featureFlags)
|
|
{
|
|
hostGame.interactable = featureFlags.HasFlag(MPFeatures.HostGame);
|
|
findGame.interactable = featureFlags.HasFlag(MPFeatures.FindGame);
|
|
quickplayButton.interactable = featureFlags.HasFlag(MPFeatures.Quickplay) && ShouldEnableQuickplayButton();
|
|
gameModePicker.ToggleArrowsInteractable(isInteractable: true);
|
|
startPrivateGameButton.interactable = featureFlags.HasFlag(MPFeatures.PrivateGame);
|
|
inviteButton.interactable = featureFlags.HasFlag(MPFeatures.Invite);
|
|
findFriendSessionButton.interactable = featureFlags.HasFlag(MPFeatures.FindFriendSession);
|
|
if (enterGameButton != null)
|
|
{
|
|
enterGameButton.interactable = PlatformSystems.lobbyManager.ShouldEnableEnterGameButton();
|
|
}
|
|
}
|
|
|
|
private void SetDefaultFallback()
|
|
{
|
|
if (quickplayButton.isActiveAndEnabled)
|
|
{
|
|
quickplayButton.defaultFallbackButton = true;
|
|
}
|
|
}
|
|
|
|
private void ToggleMPLobbyFeaturesInteractable(MPLobbyFeatures lobbyFlags)
|
|
{
|
|
lobbyUserList.createLobbyButton.interactable = lobbyFlags.HasFlag(MPLobbyFeatures.CreateLobby);
|
|
lobbyUserList.leaveLobbyButton.interactable = lobbyFlags.HasFlag(MPLobbyFeatures.LeaveLobby);
|
|
lobbyUserList.copyLobbyButton.interactable = lobbyFlags.HasFlag(MPLobbyFeatures.Clipboard);
|
|
lobbyUserList.joinLobbyButton.interactable = lobbyFlags.HasFlag(MPLobbyFeatures.Clipboard);
|
|
lobbyUserList.lobbyTypeDropdown.interactable = lobbyFlags.HasFlag(MPLobbyFeatures.LobbyDropdownOptions);
|
|
}
|
|
|
|
private void Toggle(MonoBehaviour component, bool val)
|
|
{
|
|
if ((bool)component)
|
|
{
|
|
component.gameObject.SetActive(val);
|
|
}
|
|
else
|
|
{
|
|
Debug.LogError("Null ref on Toggle of Button in MultiplayerMenuController on \"" + base.gameObject.name + "\"");
|
|
}
|
|
}
|
|
|
|
private void Toggle(GameObject[] goToToggle, bool val)
|
|
{
|
|
int num = goToToggle.Length;
|
|
for (int i = 0; i < num; i++)
|
|
{
|
|
goToToggle[i].gameObject.SetActive(val);
|
|
}
|
|
}
|
|
|
|
private void Toggle(MonoBehaviour[] buttons, bool val)
|
|
{
|
|
int num = buttons.Length;
|
|
for (int i = 0; i < num; i++)
|
|
{
|
|
buttons[i].gameObject.SetActive(val);
|
|
}
|
|
}
|
|
|
|
public void SetQuickplayButtonStateText(string textKey, object[] formatArgs = null)
|
|
{
|
|
if (formatArgs == null)
|
|
{
|
|
formatArgs = Array.Empty<object>();
|
|
}
|
|
TextMeshProUGUI textMeshProUGUI = quickplayStateText;
|
|
if ((bool)textMeshProUGUI)
|
|
{
|
|
textMeshProUGUI.text = Language.GetStringFormatted(textKey, formatArgs);
|
|
}
|
|
}
|
|
|
|
public void SetButtonText(MPButton button, string textKey, object[] formatArgs = null)
|
|
{
|
|
if (formatArgs == null)
|
|
{
|
|
formatArgs = Array.Empty<object>();
|
|
}
|
|
TextMeshProUGUI component = button.GetComponent<TextMeshProUGUI>();
|
|
if ((bool)component)
|
|
{
|
|
component.text = Language.GetStringFormatted(textKey, formatArgs);
|
|
}
|
|
}
|
|
|
|
public void SetNetworkType(bool isInternet)
|
|
{
|
|
PlatformSystems.lobbyManager.SetNetworkType(isInternet);
|
|
}
|
|
|
|
public void RefreshFirstObjectSelectedProvider()
|
|
{
|
|
if ((bool)firstSelectedObjectProvider)
|
|
{
|
|
firstSelectedObjectProvider.firstSelectedObject = gameModePicker.gameObject;
|
|
firstSelectedObjectProvider.fallBackFirstSelectedObjects = new GameObject[9] { gameModePicker.gameObject, hostGame.gameObject, findGame.gameObject, quickplayButton.gameObject, enterGameButton.gameObject, startPrivateGameButton.gameObject, inviteButton.gameObject, findFriendSessionButton.gameObject, backButton.gameObject };
|
|
}
|
|
}
|
|
|
|
public new void OnEnable()
|
|
{
|
|
ResetText();
|
|
ToggleMPFeatures(PlatformSystems.lobbyManager.GetPlatformMPFeatureFlags());
|
|
SetupLocalAndInternetMPButtons();
|
|
if ((bool)lobbyUserList)
|
|
{
|
|
lobbyUserList.DisplayContent(display: true);
|
|
}
|
|
RefreshFirstObjectSelectedProvider();
|
|
BuildGameModeChoices();
|
|
SetDefaultFallback();
|
|
firstSelectedObjectProvider?.ForceSelectFirstInteractable();
|
|
LerpAllUI(LerpUIRect.LerpState.Entering);
|
|
if (!instance)
|
|
{
|
|
instance = SingletonHelper.Assign(instance, this);
|
|
}
|
|
PlatformSystems.lobbyManager.OnMultiplayerMenuEnabled(OnLobbyLeave);
|
|
checkCanPlayOnlineCoroutine = StartCoroutine(CheckCanPlayOnline());
|
|
firstSelectedObjectProvider?.ResetLastSelected();
|
|
firstSelectedObjectProvider?.EnsureSelectedObject();
|
|
}
|
|
|
|
private IEnumerator CheckCanPlayOnline()
|
|
{
|
|
IEnumerator<NetworkManagerSystem.CanPlayOnlineState> canPlayOnlineEnumerator = NetworkManagerSystem.singleton.CanPlayOnline();
|
|
NetworkManagerSystem.CanPlayOnlineState lastResult = NetworkManagerSystem.CanPlayOnlineState.Pending;
|
|
while (canPlayOnlineEnumerator.MoveNext())
|
|
{
|
|
lastResult = canPlayOnlineEnumerator.Current;
|
|
if (lastResult != 0)
|
|
{
|
|
break;
|
|
}
|
|
yield return null;
|
|
}
|
|
if (lastResult != NetworkManagerSystem.CanPlayOnlineState.Yes)
|
|
{
|
|
if (!NetworkManagerSystem.singleton.isNetworkActive)
|
|
{
|
|
PlatformSystems.lobbyManager.LeaveLobby();
|
|
}
|
|
myMainMenuController.SetDesiredMenuScreen(myMainMenuController.titleMenuScreen);
|
|
}
|
|
checkCanPlayOnlineCoroutine = null;
|
|
}
|
|
|
|
public void OnDisable()
|
|
{
|
|
if (checkCanPlayOnlineCoroutine != null)
|
|
{
|
|
StopCoroutine(checkCanPlayOnlineCoroutine);
|
|
}
|
|
LobbyManager lobbyManager = PlatformSystems.lobbyManager;
|
|
lobbyManager.onLobbyLeave = (Action<PlatformID>)Delegate.Remove(lobbyManager.onLobbyLeave, new Action<PlatformID>(OnLobbyLeave));
|
|
if (!NetworkManagerSystem.singleton.isNetworkActive)
|
|
{
|
|
PlatformSystems.lobbyManager.LeaveLobby();
|
|
}
|
|
instance = SingletonHelper.Unassign(instance, this);
|
|
}
|
|
|
|
private void OnLobbyLeave(PlatformID lobbyId)
|
|
{
|
|
ResetText();
|
|
if (!(PlatformSystems.lobbyManager as SteamworksLobbyManager).isInLobbyDelayed && !PlatformSystems.lobbyManager.awaitingJoin && MainMenuController.instance.desiredMenuScreen == MainMenuController.instance.multiplayerMenuScreen)
|
|
{
|
|
PlatformSystems.lobbyManager.CreateLobby();
|
|
}
|
|
}
|
|
|
|
public new void Awake()
|
|
{
|
|
base.Awake();
|
|
LerpAllUI(LerpUIRect.LerpState.Entering);
|
|
hostGame.onClick.AddListener(delegate
|
|
{
|
|
SetSubview(Subview.HostGame);
|
|
});
|
|
findGame.onClick.AddListener(delegate
|
|
{
|
|
SetSubview(Subview.FindGame);
|
|
});
|
|
quickplayButton.onClick.AddListener(delegate
|
|
{
|
|
PlatformSystems.lobbyManager.ToggleQuickplay();
|
|
});
|
|
startPrivateGameButton.onClick.AddListener(delegate
|
|
{
|
|
PlatformSystems.lobbyManager.OnStartPrivateGame();
|
|
});
|
|
findFriendSessionButton.onClick.AddListener(delegate
|
|
{
|
|
PlatformSystems.lobbyManager.OpenFriendSessionBrowser();
|
|
});
|
|
}
|
|
|
|
public void ShowFriendSessionBrowser()
|
|
{
|
|
friendSessionBrowserController.gameObject.SetActive(value: true);
|
|
}
|
|
|
|
public void LerpAllUI(LerpUIRect.LerpState lerpState)
|
|
{
|
|
LerpUIRect[] array = uiToLerp;
|
|
for (int i = 0; i < array.Length; i++)
|
|
{
|
|
array[i].lerpState = lerpState;
|
|
}
|
|
}
|
|
|
|
private void BuildGameModeChoices()
|
|
{
|
|
List<CarouselController.Choice> list = new List<CarouselController.Choice>();
|
|
List<string> list2 = gameModePicker.choices.Select((CarouselController.Choice choice) => choice.suboptionDisplayToken).ToList();
|
|
for (GameModeIndex gameModeIndex = (GameModeIndex)0; (int)gameModeIndex < GameModeCatalog.gameModeCount; gameModeIndex++)
|
|
{
|
|
Run gameModePrefabComponent = GameModeCatalog.GetGameModePrefabComponent(gameModeIndex);
|
|
ExpansionRequirementComponent component = gameModePrefabComponent.GetComponent<ExpansionRequirementComponent>();
|
|
if (gameModePrefabComponent != null && gameModePrefabComponent.userPickable && list2.Contains(gameModePrefabComponent.nameToken) && (!component || !component.requiredExpansion || EntitlementManager.localUserEntitlementTracker.AnyUserHasEntitlement(component.requiredExpansion.requiredEntitlement)))
|
|
{
|
|
list.Add(new CarouselController.Choice
|
|
{
|
|
suboptionDisplayToken = gameModePrefabComponent.nameToken,
|
|
convarValue = gameModePrefabComponent.name
|
|
});
|
|
}
|
|
}
|
|
gameModePicker.choices = list.ToArray();
|
|
gameModePicker.gameObject.SetActive(list.Count > 1);
|
|
string @string = Console.instance.FindConVar("gamemode").GetString();
|
|
bool flag = false;
|
|
for (int i = 0; i < list.Count; i++)
|
|
{
|
|
if (list[i].convarValue == @string)
|
|
{
|
|
flag = true;
|
|
break;
|
|
}
|
|
}
|
|
if (list.Count == 1 || !flag)
|
|
{
|
|
Debug.LogFormat("Invalid gamemode {0} detected. Reverting to ClassicRun.", @string);
|
|
gameModePicker.SubmitSetting(list[0].convarValue);
|
|
}
|
|
}
|
|
|
|
public void ResetText()
|
|
{
|
|
if (PlatformSystems.lobbyManager.GetPlatformMPFeatureFlags().HasFlag(MPFeatures.Quickplay))
|
|
{
|
|
SetQuickplayText("", new object[0]);
|
|
}
|
|
}
|
|
|
|
private void SetupLocalAndInternetMPButtons()
|
|
{
|
|
LanguageTextMeshController componentInChildren = findFriendSessionButton.GetComponentInChildren<LanguageTextMeshController>();
|
|
LanguageTextMeshController languageTextMeshController = (inviteButton as HGButton)?.hoverLanguageTextMeshController;
|
|
LanguageTextMeshController componentInChildren2 = startPrivateGameButton.GetComponentInChildren<LanguageTextMeshController>();
|
|
if (PlatformSystems.lobbyManager.IsNetworkTypeInternet())
|
|
{
|
|
if ((bool)componentInChildren)
|
|
{
|
|
componentInChildren.token = "FRIEND_GAME_BROWSER";
|
|
}
|
|
if ((bool)languageTextMeshController)
|
|
{
|
|
languageTextMeshController.token = "FRIEND_GAME_BROWSER_DESCRIPTION";
|
|
}
|
|
if ((bool)componentInChildren2)
|
|
{
|
|
componentInChildren2.token = "HOST_PRIVATE_GAME";
|
|
}
|
|
return;
|
|
}
|
|
enterGameButton.interactable = false;
|
|
if ((bool)componentInChildren)
|
|
{
|
|
componentInChildren.token = "BROWSE_LOCAL_GAME";
|
|
}
|
|
if ((bool)languageTextMeshController)
|
|
{
|
|
languageTextMeshController.token = "BROWSE_LOCAL_GAME_DESCRIPTION";
|
|
}
|
|
if ((bool)componentInChildren2)
|
|
{
|
|
componentInChildren2.token = "HOST_LOCAL_GAME";
|
|
}
|
|
}
|
|
|
|
public void ReturnToMainMenu()
|
|
{
|
|
ResetLobby();
|
|
myMainMenuController.SetDesiredMenuScreen(myMainMenuController.titleMenuScreen);
|
|
}
|
|
|
|
public void ResetLobby()
|
|
{
|
|
PlatformSystems.lobbyManager.LeaveLobby();
|
|
if (enterGameButton != null)
|
|
{
|
|
enterGameButton.interactable = PlatformSystems.lobbyManager.ShouldEnableEnterGameButton();
|
|
}
|
|
lobbyUserList.ClearUserList();
|
|
}
|
|
|
|
public void OnEnterGameButtonPressed()
|
|
{
|
|
titleStopwatch = 0f;
|
|
LerpAllUI(LerpUIRect.LerpState.Leaving);
|
|
PlatformSystems.lobbyManager.EnterGameButtonPressed();
|
|
}
|
|
|
|
private void UpdateSpinner(RectTransform spinnerRectTransform)
|
|
{
|
|
Vector3 localEulerAngles = spinnerRectTransform.localEulerAngles;
|
|
localEulerAngles.z += Time.deltaTime * 360f;
|
|
spinnerRectTransform.localEulerAngles = localEulerAngles;
|
|
}
|
|
|
|
private new void Update()
|
|
{
|
|
base.Update();
|
|
titleStopwatch += Time.deltaTime;
|
|
PlatformSystems.lobbyManager.CheckBusyTimer();
|
|
if (friendSessionBrowserController.gameObject.activeSelf)
|
|
{
|
|
return;
|
|
}
|
|
if (PlatformSystems.lobbyManager.IsQuickPlaySearching())
|
|
{
|
|
ToggleMPFeaturesInteractable(MPFeatures.Quickplay);
|
|
quickplayLabelController.token = quickplayStopToken;
|
|
}
|
|
if (PlatformSystems.lobbyManager.ShouldShowSpinner())
|
|
{
|
|
quickplaySpinnerRectTransform.gameObject.SetActive(value: true);
|
|
UpdateSpinner(quickplaySpinnerRectTransform);
|
|
}
|
|
else
|
|
{
|
|
ToggleMPFeaturesInteractable(PlatformSystems.lobbyManager.GetPlatformMPFeatureFlags());
|
|
quickplaySpinnerRectTransform.gameObject.SetActive(value: false);
|
|
if (!PlatformSystems.lobbyManager.IsQuickPlaySearching())
|
|
{
|
|
quickplayLabelController.token = quickplayStartToken;
|
|
}
|
|
else
|
|
{
|
|
quickplayLabelController.token = quickplayStopToken;
|
|
}
|
|
if ((bool)quickplayButton)
|
|
{
|
|
quickplayButton.interactable = ShouldEnableQuickplayButton();
|
|
}
|
|
else
|
|
{
|
|
quickplayButton.interactable = ShouldEnableQuickplayButton();
|
|
if (!ShouldEnableQuickplayButton())
|
|
{
|
|
quickplaySpinnerRectTransform.gameObject.SetActive(value: true);
|
|
UpdateSpinner(quickplaySpinnerRectTransform);
|
|
}
|
|
}
|
|
if ((bool)startPrivateGameButton)
|
|
{
|
|
startPrivateGameButton.interactable = ShouldEnableStartPrivateGameButton();
|
|
}
|
|
if ((bool)joinClipboardLobbyButtonController && (bool)joinClipboardLobbyButtonController.mpButton)
|
|
{
|
|
joinClipboardLobbyButtonController.mpButton.interactable = ShouldEnableJoinClipboardLobbyButton();
|
|
}
|
|
if ((bool)inviteButton)
|
|
{
|
|
inviteButton.interactable = PlatformSystems.lobbyManager.ShouldEnableInviteButton();
|
|
}
|
|
if ((bool)findFriendSessionButton)
|
|
{
|
|
findFriendSessionButton.interactable = ShouldEnableFindFriendSessionButton();
|
|
}
|
|
backButton.interactable = ShouldEnableBackButton();
|
|
if (enterGameButton != null && enterGameButton.isActiveAndEnabled)
|
|
{
|
|
enterGameButton.interactable = PlatformSystems.lobbyManager.ShouldEnableEnterGameButton();
|
|
}
|
|
}
|
|
if (PlatformSystems.lobbyManager.ShouldShowGenericSpinner())
|
|
{
|
|
genericSpinnerRectTransform.gameObject.SetActive(value: true);
|
|
UpdateSpinner(genericSpinnerRectTransform);
|
|
}
|
|
else
|
|
{
|
|
genericSpinnerRectTransform.gameObject.SetActive(value: false);
|
|
}
|
|
if (!string.IsNullOrEmpty(pendingQuickplayText))
|
|
{
|
|
SetQuickplayText(pendingQuickplayText);
|
|
pendingQuickplayText = string.Empty;
|
|
}
|
|
if (SimpleDialogBox.instancesList.Count > 0 && (bool)firstSelectedObjectProvider)
|
|
{
|
|
SimpleDialogBox simpleDialogBox = SimpleDialogBox.instancesList[0];
|
|
if ((bool)simpleDialogBox)
|
|
{
|
|
firstSelectedObjectProvider.firstSelectedObject = simpleDialogBox.GetComponentInChildren<MPButton>().gameObject;
|
|
firstSelectedObjectProvider.ResetLastSelected();
|
|
}
|
|
}
|
|
firstSelectedObjectProvider?.EnsureSelectedObject();
|
|
}
|
|
|
|
public void InviteButtonPressed()
|
|
{
|
|
if (!PlatformSystems.lobbyManager.isInLobby)
|
|
{
|
|
NetworkManagerSystem.singleton.CreateLocalLobby();
|
|
}
|
|
PlatformSystems.lobbyManager.OpenInviteOverlay();
|
|
}
|
|
|
|
private bool ShouldEnableQuickplayButton()
|
|
{
|
|
return PlatformSystems.lobbyManager.ShouldEnableQuickplayButton();
|
|
}
|
|
|
|
private bool ShouldEnableStartPrivateGameButton()
|
|
{
|
|
return PlatformSystems.lobbyManager.ShouldEnableStartPrivateGameButton();
|
|
}
|
|
|
|
private bool ShouldEnableJoinClipboardLobbyButton()
|
|
{
|
|
if (!PlatformSystems.lobbyManager.newestLobbyData.quickplayQueued)
|
|
{
|
|
return joinClipboardLobbyButtonController.validClipboardLobbyID;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private bool ShouldEnableFindFriendSessionButton()
|
|
{
|
|
return PlatformSystems.lobbyManager.ShouldEnableFindFriendSessionButton();
|
|
}
|
|
|
|
public void ToggleQuickplay()
|
|
{
|
|
PlatformSystems.lobbyManager.ToggleQuickplay();
|
|
}
|
|
|
|
public override bool IsReadyToLeave()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
public bool ShouldEnableBackButton()
|
|
{
|
|
if (!PlatformSystems.lobbyManager.IsBusy)
|
|
{
|
|
return _curSubView == Subview.Main;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public void GoBack()
|
|
{
|
|
if (friendSessionBrowserController.isActiveAndEnabled)
|
|
{
|
|
friendSessionBrowserController.gameObject.SetActive(value: false);
|
|
}
|
|
else if (PlatformSystems.lobbyManager.IsQuickPlaySearching() && NetworkManagerSystem.singleton.IsHost())
|
|
{
|
|
quickplayButton.InvokeClick();
|
|
}
|
|
else if (PlatformSystems.lobbyManager.isInLobby)
|
|
{
|
|
ResetLobby();
|
|
ResetLastSelected();
|
|
ReturnToMainMenu();
|
|
}
|
|
else if (ShouldEnableBackButton())
|
|
{
|
|
ReturnToMainMenu();
|
|
}
|
|
}
|
|
|
|
public void ResetLastSelected()
|
|
{
|
|
firstSelectedObjectProvider?.ResetLastSelected();
|
|
firstSelectedObjectProvider?.EnsureSelectedObject();
|
|
}
|
|
|
|
public void SetQuickplayTextBelowMinPlayers()
|
|
{
|
|
if (PlatformSystems.lobbyManager.HasMPFeature(MPFeatures.Quickplay))
|
|
{
|
|
object[] formatArgs = new object[2]
|
|
{
|
|
PlatformSystems.lobbyManager.calculatedTotalPlayerCount,
|
|
RoR2Application.maxPlayers
|
|
};
|
|
SetQuickplayText("STEAM_LOBBY_STATUS_QUICKPLAY_WAITING_BELOW_MINIMUM_PLAYERS", formatArgs);
|
|
}
|
|
}
|
|
|
|
public void UpdateCutoffTimeText(int numberOfPlayers, float timeRemaining)
|
|
{
|
|
object[] formatArgs = new object[3]
|
|
{
|
|
numberOfPlayers,
|
|
RoR2Application.maxPlayers,
|
|
(int)Math.Max(0.0, timeRemaining)
|
|
};
|
|
SetQuickplayText("STEAM_LOBBY_STATUS_QUICKPLAY_WAITING_ABOVE_MINIMUM_PLAYERS", formatArgs);
|
|
}
|
|
|
|
public void SetPendingQuickplayText(string text, object[] formatArgs = null)
|
|
{
|
|
if (formatArgs == null)
|
|
{
|
|
formatArgs = Array.Empty<object>();
|
|
}
|
|
pendingQuickplayText = Language.GetStringFormatted(text, formatArgs);
|
|
}
|
|
|
|
public void SetQuickplayText(string text, object[] formatArgs = null)
|
|
{
|
|
if (formatArgs == null)
|
|
{
|
|
formatArgs = Array.Empty<object>();
|
|
}
|
|
quickplayStateText.text = Language.GetStringFormatted(text, formatArgs);
|
|
}
|
|
|
|
public void ToggleAllButtonsInteractable(bool interactable)
|
|
{
|
|
for (int i = 0; i < 8; i++)
|
|
{
|
|
SetButtonInteractableStatus((MPButtons)i, interactable);
|
|
}
|
|
firstSelectedObjectProvider.ForceSelectFirstInteractable();
|
|
}
|
|
|
|
public void SetButtonInteractableStatus(MPButtons button, bool interactable)
|
|
{
|
|
MPButton mPButton = null;
|
|
switch (button)
|
|
{
|
|
case MPButtons.HostGame:
|
|
mPButton = hostGame;
|
|
break;
|
|
case MPButtons.FindGame:
|
|
mPButton = findGame;
|
|
break;
|
|
case MPButtons.Quickplay:
|
|
mPButton = quickplayButton;
|
|
break;
|
|
case MPButtons.StartPrivateGame:
|
|
mPButton = startPrivateGameButton;
|
|
break;
|
|
case MPButtons.Invite:
|
|
mPButton = inviteButton;
|
|
break;
|
|
case MPButtons.FindFriendSession:
|
|
mPButton = findFriendSessionButton;
|
|
break;
|
|
case MPButtons.Back:
|
|
mPButton = backButton;
|
|
break;
|
|
case MPButtons.EnterGame:
|
|
mPButton = enterGameButton;
|
|
break;
|
|
}
|
|
if (mPButton != null)
|
|
{
|
|
mPButton.interactable = interactable;
|
|
}
|
|
}
|
|
}
|