UMainMenuSystemWidget Class Reference

#include <MainMenuSystemWidget.h>

Inheritance diagram for UMainMenuSystemWidget:

Public Member Functions
	UMainMenuSystemWidget (const FObjectInitializer &ObjectInitializer)
void	SelectIndex (uint32 Index)
virtual void	SetServerList (const TArray< FServerRow > &ServerInfo) override
virtual UWidget *	NativeGetDesiredFocusTarget () const override
Public Member Functions inherited from UMenuSystemWidget
	UMenuSystemWidget (const FObjectInitializer &ObjectInitializer)
virtual bool	NativeOnHandleBackAction () override
void	SetMenuInterface (IMenuSystem *Interface)
void	Setup ()
virtual void	OpenConfirmationMessage (const FModalData &ModalData)
void	SetOwnerWidget (UUserWidget *Owner)
UUserWidget *	GetOwnerWidget () const
void	WidgetVisibilityChanged (ESlateVisibility SlateVisibility)
bool	GetIsOnlineGame () const
bool	GetIsPublicMatch () const
virtual bool	GetDebuggingMode () const
virtual FString	GetPlayerUserName () const
virtual bool	GetIsPlayerLoggedIn () const
virtual FString	GetCurrentSessionName () const
virtual EOnlineSubsystem	GetOnlineSubsystem () const

Protected Member Functions
virtual bool	Initialize () override
virtual void	NativeConstruct () override
virtual void	ModalButtonSelected (const int32 Index) override
void	OnDifficultyChanged ()
void	SetDifficultyLevelText () const
void	LoginToEpicOnline () const
void	ReturnToCurrentMenu ()
void	ReturnToMainMenu ()
void	ReturnToMultiplayerMenu ()
void	SetActiveMenu (const int32 Index, class UWidgetSwitcher *MenuSwitcherWidget)
UWidget *	GetActiveMenuWidget () const
class UWidgetSwitcher *	GetActiveMenu () const
void	JoinButtonClicked ()
void	SearchServers ()
void	HostButtonClicked ()
void	UpdateServerRows ()
void	NumberOnSliderChanged (float Value)
void	MinNumberOnSliderChanged (float Value)
void	OpenQuitConfirmationPopup ()
void	OpenLevelSelect (const EGameplayMode GameplayMode=EGameplayMode::Multiplayer, const bool bDebugLevels=false)
void	BackOneMenu (bool bOpenConfirmation)
void	SetIsControllerInput (bool bIsNewController)
Protected Member Functions inherited from UMenuSystemWidget
void	OnModalButtonSelectedEvent (const int32 Index)
virtual void	ModalClosed ()
void	OnModalClosedEvent ()
class UModalMenuSystemWidget *	GetCurrentModal () const
void	SetModalSlot (UPanelWidget *PanelWidget)
void	SetNotificationSlot (UPanelWidget *PanelWidget)
Protected Member Functions inherited from UBaseActivatableWidget
void	LogDebugError (const FString &Message) const
void	LogDebugError (const FString &Message, const int32 Value) const
void	LogDebugError (const FString &Message, const float Value) const
void	LogDebugWarning (const FString &Message) const
void	LogDebugWarning (const FString &Message, const int32 Value) const
void	LogDebugWarning (const FString &Message, const float Value) const
void	LogDebugMessage (const FString &Message, const bool bWarning=false, const bool bError=false) const
void	LogDebugMessage (const FString &Message, const int32 Value, const bool bWarning=false, const bool bError=false) const
void	LogDebugMessage (const FString &Message, const float Value, const bool bWarning=false, const bool bError=false) const
void	LogDebugMessage (const FString &Message, const bool bValue, const bool bWarning, const bool bError) const
void	LogOnScreenMessage (const int32 Key, const FString &Message, FColor Color=FColor::Green) const
void	SetCategoryName (const FLogCategoryBase &Category)

Protected Attributes
bool	bIsControllerInput = false
int32	ButtonFocused = 1
int32	MenuPageIndex = 0
int32	MultiplayerPageIndex = 0
const int32	MultiplayerPageIndexNumber = 4
const int32	MainMenuPageIndexNumber = 2
const int32	SignInPageIndexNumber = 1
class ULevelSelectionWidget *	LevelSelectionWidget = nullptr
class UOverlay *	LevelSelectOverlay = nullptr
class UPanelWidget *	ModalPanel = nullptr
class UPanelWidget *	NotificationPanel = nullptr
class UButton *	StartScreenButton = nullptr
class UButton *	JoinButton = nullptr
class UCommonActivatableWidgetSwitcher *	MenuSwitcher = nullptr
class UCommonActivatableWidgetSwitcher *	MultiplayerMenuSwitcher = nullptr
class UWidget *	StartScreen = nullptr
class UTextBlock *	GameVersionText = nullptr
class UTextBlock *	UserNameText = nullptr
bool	bSearchingForServersInProgress = false
bool	bAllowJoinInProgress = false
bool	bAllowInvites = false
bool	bIsLAN = false
bool	bIsDedicatedServer = false
bool	bShouldAdvertise = false
bool	bUseLobbiesIfAvailable = false
bool	bUseLobbiesVoiceChatIfAvailable = false
bool	bUsesPresence = false
bool	bAllowJoinViaPresence = false
class UPanelWidget *	ServerList = nullptr
class UButton *	SearchServersButton = nullptr
class UEditableTextBox *	IPInputTextBox = nullptr
class UEditableTextBox *	ServerNameTextBox = nullptr
class USlider *	NumberOfPlayersSlider = nullptr
class USlider *	MinNumberOfPlayersSlider = nullptr
class UTextBlock *	NumberOfPlayersText = nullptr
class UTextBlock *	MinNumberOfPlayersText = nullptr
class UCheckBox *	DedicatedServerCheckbox = nullptr
class UCheckBox *	LANCheckbox = nullptr
class UCheckBox *	UsesPresenceCheckbox = nullptr
class UTextBlock *	DifficultyTextBlock = nullptr
class UWidget *	SearchingProgressSpinner = nullptr
class USingleMenuSystemWidget *	SignInScreenMenu = nullptr
class USingleMenuSystemWidget *	MainMenu = nullptr
class USingleMenuSystemWidget *	CampaignMenu = nullptr
class USingleMenuSystemWidget *	MultiplayerMenu = nullptr
class USingleMenuSystemWidget *	HordeMenu = nullptr
class USingleMenuSystemWidget *	CharacterMenu = nullptr
class USingleMenuSystemWidget *	BrowseMenu = nullptr
class USingleMenuSystemWidget *	HostMenu = nullptr
class USingleMenuSystemWidget *	QuickMatchMenu = nullptr
class USingleMenuSystemWidget *	PlaylistMenu = nullptr
Protected Attributes inherited from UMenuSystemWidget
IMenuSystem *	MenuInterface = nullptr
class IModalInterface *	ModalInterface = nullptr
bool	bIsController = false
bool	bIsKeyboard = false
bool	bMouse = false
Protected Attributes inherited from UBaseActivatableWidget
bool	bDebuggingMode = false

Private Member Functions
void	StartScreenButtonClicked ()
void	SignInScreenButtonSelected (const int32 Index)
void	MainMenuButtonSelected (const int32 Index)
void	CampaignMenuButtonSelected (const int32 Index)
void	MultiplayerMenuButtonSelected (const int32 Index)
void	HordeMenuButtonSelected (const int32 Index)
void	CharacterMenuButtonSelected (const int32 Index)
void	BrowseMenuButtonSelected (const int32 Index)
void	HostMenuButtonSelected (const int32 Index)
void	QuickMatchMenuButtonSelected (const int32 Index)
void	PlaylistMenuButtonSelected (const int32 Index)
void	CloseLevelSelect (const bool bOpenConfirm)

Private Attributes
class IPlayFabMenu *	PlayFabMenu = nullptr
TSubclassOf< class UUserWidget >	ServerRowClass
TSubclassOf< class UUserWidget >	LevelSelectClass
float	NumberOfPlayers = 1
float	MinNumberOfPlayers = 1
TOptional< uint32 >	SelectedIndex
bool	bCloseGame = false

Additional Inherited Members
Public Attributes inherited from UMenuSystemWidget
FOnMenuBackButtonSelected	OnMenuBackButtonSelected

Constructor & Destructor Documentation

UMainMenuSystemWidget()

UMainMenuSystemWidget::UMainMenuSystemWidget

(

const FObjectInitializer &

ObjectInitializer

)

    : Super(ObjectInitializer)
{
    const ConstructorHelpers::FClassFinder<UUserWidget> ServerRowBP(TEXT("/MenuSystem/Widgets/CommonUI/WBP_ServerRowMenuSystem"));
    if (!ensure(ServerRowBP.Class != nullptr)) return;
    ServerRowClass = ServerRowBP.Class;
 
    const ConstructorHelpers::FClassFinder<UUserWidget> LevelSelectBP(TEXT("/MenuSystem/Widgets/CommonUI/WBP_LevelSelection"));
    if (!ensure(LevelSelectBP.Class != nullptr)) return;
    LevelSelectClass = LevelSelectBP.Class;
}

Member Function Documentation

BackOneMenu()

void UMainMenuSystemWidget::BackOneMenu ( bool bOpenConfirmation )

protected

{
    if(bOpenConfirmation)
    {
        
    }
    UE_LOG(LogTemp,Warning,TEXT("Back One Menu In Main Menu"));
    if(GetActiveMenu() == MultiplayerMenuSwitcher)
    {
        if(MultiplayerMenuSwitcher->GetActiveWidgetIndex() == 0)
        {
            UE_LOG(LogTemp,Warning,TEXT("Back Button To Main Menu From Multiplayer Index"));
            ReturnToMainMenu();
            return;
        }
        UE_LOG(LogTemp,Warning,TEXT("Back Button To ToMultiplayerMenu From Multiplayer"));
        ReturnToMultiplayerMenu();
        return;
    }
    if(GetActiveMenu() == MenuSwitcher)
    {
        UE_LOG(LogTemp,Warning,TEXT("Back Button To ReturnToMainMenu"));
        ReturnToMainMenu();
    }
}

BrowseMenuButtonSelected()

void UMainMenuSystemWidget::BrowseMenuButtonSelected ( const int32 Index )

private

{
    switch (Index)
    {
    default:
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
        break;
    case 6:
        JoinButtonClicked();
        break;
    case 7:
        SearchServers();
        break;
    case 8:
        ReturnToMultiplayerMenu();
        break;
    }
}

CampaignMenuButtonSelected()

void UMainMenuSystemWidget::CampaignMenuButtonSelected ( const int32 Index )

private

{
    switch (Index)
    {
    default:
    case 0:
        if(MenuInterface != nullptr)
        {
            MenuInterface->StartCampaign(false);
        }
        break;
    case 1:
        if(MenuInterface != nullptr)
        {
            MenuInterface->StartCampaign(true);
        }
        break;
    case 2:
        //@ TODO Load Game Option   //
        //- Load Game   //
            if(LevelSelectOverlay != nullptr && MenuInterface != nullptr)
            {
                // for(auto SaveSlot : MenuInterface->GetAllSaveSlots())
                // {
                //  // USavedGameWidget CreateWidget();
                //  //
                // }
                // for(GetAllSavedGameSlots())
            }
        break;
    case 3:
        //- Level Select    //
        if(GetOwningPlayer() != nullptr)
        {
            OpenLevelSelect(EGameplayMode::Campaign, UMenuBPLib::GetGameDebuggingMode(GetOwningPlayer()));
        }
        break;
    case 4:
        {
            IDifficultyInterface* DifficultyInterface = Cast<IDifficultyInterface>(GetGameInstance());
            if(DifficultyInterface != nullptr)
            {
                if(MenuInterface != nullptr)
                {
                    int32 NextLevel = static_cast<int32>(DifficultyInterface->GetDifficultyLevel()) + 1;
                    if (NextLevel > static_cast<int>(EDifficultyLevel::Master))
                    {
                        NextLevel = static_cast<int32>(EDifficultyLevel::Assisted);
                    }
                    DifficultyInterface->SetDifficultyLevel(static_cast<EDifficultyLevel>(NextLevel));
                    SetDifficultyLevelText();
                }
            }
        }
        break;
    case 5:
        ReturnToMainMenu();
        break;
    case 6:
        break;
    }
}

CharacterMenuButtonSelected()

void UMainMenuSystemWidget::CharacterMenuButtonSelected ( const int32 Index )

private

{
    switch (Index)
    {
    default:
    case 0:
        break;
    case 1:
        break;
    case 2:
        break;
    case 3:
        break;
    case 4:
        break;
    case 5:
        ReturnToMainMenu();
        break;
    case 6:
        break;
    }
}

CloseLevelSelect()

void UMainMenuSystemWidget::CloseLevelSelect ( const bool bOpenConfirm )

private

{
    if(LevelSelectionWidget != nullptr)
    {
        LevelSelectionWidget->DeactivateWidget();
    }
    if(bOpenConfirm)
    {
        
    }
    ActivateWidget();
    // SetFocusToFirstVisibleOption();
}

GetActiveMenu()

UWidgetSwitcher * UMainMenuSystemWidget::GetActiveMenu ( ) const

protected

{
    if(MenuPageIndex == MultiplayerPageIndexNumber)
    {
        return MultiplayerMenuSwitcher;
    }
    return MenuSwitcher;
}

GetActiveMenuWidget()

UWidget * UMainMenuSystemWidget::GetActiveMenuWidget ( ) const

protected

{
    const UWidgetSwitcher* ActiveWidgetSwitcher = GetActiveMenu();
    const UMenuSystemWidget* ActiveWidget = Cast<UMenuSystemWidget>(ActiveWidgetSwitcher->GetActiveWidget());
    if(ActiveWidget != nullptr)
    {
        return ActiveWidget->GetDesiredFocusTarget();
    }
    //- In case their is an overlay with multiple 
    const UOverlay* OverlayMenu = Cast<UOverlay>(ActiveWidgetSwitcher->GetActiveWidget());
    if(OverlayMenu != nullptr)
    {
        ActiveWidget = Cast<UMenuSystemWidget>(OverlayMenu->GetChildAt(0));
        if(ActiveWidget != nullptr)
        {
            return ActiveWidget->GetDesiredFocusTarget();
        }
    }
    return nullptr;
}

HordeMenuButtonSelected()

void UMainMenuSystemWidget::HordeMenuButtonSelected ( const int32 Index )

private

{
    switch (Index)
    {
    default:
    case 0:
        //- Start   //
        if(MenuInterface != nullptr)
        {
            MenuInterface->StartHorde();
        }
        break;
    case 1:
        //- Map      //
        if(GetOwningPlayer() != nullptr)
        {
            OpenLevelSelect(EGameplayMode::Horde, false);
            //@TODO Temp Off    //
            // OpenLevelSelect(EGameplayMode::Horde, UMenuBPLib::GetGameDebuggingMode(GetOwningPlayer()));
        }
        break;
    case 2:
        //- Mode    //
        break;
    case 3:
        {
            //- Difficulty  //
            //@ TODO Change Difficulty
            IDifficultyInterface* DifficultyInterface = Cast<IDifficultyInterface>(GetGameInstance());
            if(DifficultyInterface != nullptr)
            {
                if(MenuInterface != nullptr)
                {
                    int32 NextLevel = static_cast<int32>(DifficultyInterface->GetDifficultyLevel()) + 1;
                    if (NextLevel > static_cast<int>(EDifficultyLevel::Master))
                    {
                        NextLevel = static_cast<int32>(EDifficultyLevel::Assisted);
                    }
                    DifficultyInterface->SetDifficultyLevel(static_cast<EDifficultyLevel>(NextLevel));
                    SetDifficultyLevelText();
                }
            }
        }
        break;
    case 4:
        //- Settings    //
        break;
    case 5:
        ReturnToMainMenu();
        break;
    case 6:
        break;
    }
}

HostButtonClicked()

void UMainMenuSystemWidget::HostButtonClicked ( )

protected

{
    if(MenuInterface != nullptr)
    {
        FOnlineSessionSettings SessionSettings;
        SessionSettings.bShouldAdvertise = bShouldAdvertise;
        SessionSettings.bAllowJoinInProgress = bAllowJoinInProgress;
        SessionSettings.bIsDedicated = bIsDedicatedServer;
        SessionSettings.bUsesPresence = bUsesPresence;
        SessionSettings.NumPublicConnections = NumberOfPlayers;
        SessionSettings.bAllowInvites = bAllowInvites;
        SessionSettings.bIsLANMatch = bIsLAN;
        SessionSettings.bAllowJoinViaPresence = bAllowJoinViaPresence;
 
        
        //- not in 4.26 //
        // SessionSettings.bUseLobbiesIfAvailable = bUseLobbiesIfAvailable; // Glitched? 
        // SessionSettings.bUseLobbiesVoiceChatIfAvailable = true; // Glitched?
        
        FString ServerName = "Default";
        if(ServerNameTextBox->GetText().ToString() != "")
        {
            ServerName = ServerNameTextBox->GetText().ToString();
        };
        MenuInterface->SetMinNumberOfPlayersToStart(MinNumberOfPlayers);
        SessionSettings.Set(TEXT("Server Name"), ServerName, EOnlineDataAdvertisementType::ViaOnlineServiceAndPing);
        MenuInterface->Host(SessionSettings);
    }
}

HostMenuButtonSelected()

void UMainMenuSystemWidget::HostMenuButtonSelected ( const int32 Index )

private

{
    switch (Index)
    {
    default:
    case 0:
        //- Create Game //
        if(!ServerNameTextBox->GetText().IsEmpty() && MenuInterface != nullptr)
        {
            bIsDedicatedServer = DedicatedServerCheckbox->IsChecked();
            bIsLAN = LANCheckbox->IsChecked();
            bUsesPresence = UsesPresenceCheckbox->IsChecked();
            MenuInterface->SetMinNumberOfPlayersToStart(MinNumberOfPlayers);
            MenuInterface->CreateEOSSession(ServerNameTextBox->GetText().ToString(), bIsDedicatedServer, bIsLAN, bUsesPresence, NumberOfPlayers);
        }
        break;
    case 1:
        //- Map //
        if(GetOwningPlayer() != nullptr)
        {
            OpenLevelSelect(EGameplayMode::Multiplayer, UMenuBPLib::GetGameDebuggingMode(GetOwningPlayer()));
        }
        break;
    case 2:
        //- Mode    //
        break;
    case 3:
        //- Settings    //
        break;
    case 4:
        //- BLANK   //
        break;
    case 5:
        ReturnToMultiplayerMenu();
        break;
    case 6:
        break;
    }
}

Initialize()

bool UMainMenuSystemWidget::Initialize ( )

overrideprotectedvirtual

Reimplemented from UMenuSystemWidget.

{
    const bool Success = Super::Initialize();
    if(!Success) return false;
    if (!ensure(StartScreenButton != nullptr)) return false;
    if (!ensure(SearchingProgressSpinner != nullptr)) return false;
    if (!ensure(NumberOfPlayersSlider != nullptr)) return false;
    if (!ensure(NumberOfPlayersText != nullptr)) return false;
    if (!ensure(GameVersionText != nullptr)) return false;
    if (!ensure(UserNameText != nullptr)) return false;
    if (!ensure(MenuSwitcher != nullptr)) return false; 
    if (!ensure(MultiplayerMenuSwitcher != nullptr)) return false;  
    if (!ensure(SearchingProgressSpinner != nullptr)) return false;
    if (!ensure(LevelSelectOverlay != nullptr)) return false;
    if (!ensure(DedicatedServerCheckbox != nullptr)) return false;
    if (!ensure(LANCheckbox != nullptr)) return false;
    if (!ensure(UsesPresenceCheckbox != nullptr)) return false;
 
    if (!ensure(MinNumberOfPlayersSlider != nullptr)) return false;
    if (!ensure(MinNumberOfPlayersText != nullptr)) return false;
 
    if (!ensure(ModalPanel != nullptr)) return false;
    if (!ensure(NotificationPanel != nullptr)) return false;
    
    if (!ensure(SignInScreenMenu != nullptr)) return false;
    if (!ensure(MainMenu != nullptr)) return false;
    if (!ensure(CampaignMenu != nullptr)) return false;
    if (!ensure(MultiplayerMenu != nullptr)) return false;
    if (!ensure(HordeMenu != nullptr)) return false;
    if (!ensure(CharacterMenu != nullptr)) return false;
    if (!ensure(BrowseMenu != nullptr)) return false;
    if (!ensure(HostMenu != nullptr)) return false;
    if (!ensure(QuickMatchMenu != nullptr)) return false;
    if (!ensure(PlaylistMenu != nullptr)) return false;
    
    SignInScreenMenu->OnMenuButtonSelected.AddUniqueDynamic(this, &UMainMenuSystemWidget::SignInScreenButtonSelected);
    SignInScreenMenu->SetIsBackHandler(false);
    MainMenu->OnMenuButtonSelected.AddUniqueDynamic(this, &UMainMenuSystemWidget::MainMenuButtonSelected);
    MainMenu->SetIsBackHandler(false);
    CampaignMenu->OnMenuButtonSelected.AddUniqueDynamic(this, &UMainMenuSystemWidget::CampaignMenuButtonSelected);
    MultiplayerMenu->OnMenuButtonSelected.AddUniqueDynamic(this, &UMainMenuSystemWidget::MultiplayerMenuButtonSelected);
    HordeMenu->OnMenuButtonSelected.AddUniqueDynamic(this, &UMainMenuSystemWidget::HordeMenuButtonSelected);
    CharacterMenu->OnMenuButtonSelected.AddUniqueDynamic(this, &UMainMenuSystemWidget::CharacterMenuButtonSelected);
    BrowseMenu->OnMenuButtonSelected.AddUniqueDynamic(this, &UMainMenuSystemWidget::BrowseMenuButtonSelected);
    HostMenu->OnMenuButtonSelected.AddUniqueDynamic(this, &UMainMenuSystemWidget::HostMenuButtonSelected);
    QuickMatchMenu->OnMenuButtonSelected.AddUniqueDynamic(this, &UMainMenuSystemWidget::QuickMatchMenuButtonSelected);
    PlaylistMenu->OnMenuButtonSelected.AddUniqueDynamic(this, &UMainMenuSystemWidget::PlaylistMenuButtonSelected);
    CampaignMenu->OnMenuBackButtonSelected.AddUniqueDynamic(this, &UMainMenuSystemWidget::BackOneMenu);
    MultiplayerMenu->OnMenuBackButtonSelected.AddUniqueDynamic(this, &UMainMenuSystemWidget::BackOneMenu);
    HordeMenu->OnMenuBackButtonSelected.AddUniqueDynamic(this, &UMainMenuSystemWidget::BackOneMenu);
    CharacterMenu->OnMenuBackButtonSelected.AddUniqueDynamic(this, &UMainMenuSystemWidget::BackOneMenu);
    BrowseMenu->OnMenuBackButtonSelected.AddUniqueDynamic(this, &UMainMenuSystemWidget::BackOneMenu);
    HostMenu->OnMenuBackButtonSelected.AddUniqueDynamic(this, &UMainMenuSystemWidget::BackOneMenu);
    QuickMatchMenu->OnMenuBackButtonSelected.AddUniqueDynamic(this, &UMainMenuSystemWidget::BackOneMenu);
    PlaylistMenu->OnMenuBackButtonSelected.AddUniqueDynamic(this, &UMainMenuSystemWidget::BackOneMenu);
 
    // MenuSwitcher->HandleSlateActiveIndexChanged
    
    JoinButton->OnClicked.AddDynamic(this, &UMainMenuSystemWidget::JoinButtonClicked);
    StartScreenButton->OnClicked.AddDynamic(this, &UMainMenuSystemWidget::StartScreenButtonClicked);
    SearchingProgressSpinner->SetVisibility(ESlateVisibility::Hidden);
    NumberOfPlayersSlider->OnValueChanged.AddDynamic(this, &UMainMenuSystemWidget::NumberOnSliderChanged);
 
    MinNumberOfPlayersSlider->OnValueChanged.AddDynamic(this, &UMainMenuSystemWidget::MinNumberOnSliderChanged);
 
    NumberOfPlayersSlider->SetStepSize(1.0f);
    NumberOfPlayersSlider->SetMinValue(1.0f);
    NumberOfPlayersSlider->SetMaxValue(16.0f);
    MinNumberOfPlayersSlider->SetStepSize(1.0f);
    MinNumberOfPlayersSlider->SetMinValue(1.0f);
    MinNumberOfPlayersSlider->SetMaxValue(16.0f);
 
    SetModalSlot(ModalPanel);
    SetNotificationSlot(NotificationPanel);
 
    return true;
}

JoinButtonClicked()

void UMainMenuSystemWidget::JoinButtonClicked ( )

protected

{
    if(SelectedIndex.IsSet() && MenuInterface != nullptr)
    {
        MenuInterface->Join(SelectedIndex.GetValue());
        UE_LOG(LogMenuSystem, Warning, TEXT("Selected Index: %d"), SelectedIndex.GetValue());
    }
    else
    {
        UE_LOG(LogMenuSystem, Warning, TEXT("Nothing Selected"));
    }
    //TODO: Create manual IP input
    // if(MenuInterface != nullptr)
    // {
    //     if (!ensure(IPInputTextBox != nullptr)) return;
    //     FString IpAddressInput = IPInputTextBox->GetText().ToString();
    //     MenuInterface->JoinManualAddress(IpAddressInput);
    // }
}

LoginToEpicOnline()

void UMainMenuSystemWidget::LoginToEpicOnline ( ) const

protected

{
    if(MenuInterface != nullptr)
    {
        MenuInterface->LoginToEpicOnline();
    }
}

MainMenuButtonSelected()

void UMainMenuSystemWidget::MainMenuButtonSelected ( const int32 Index )

private

{
    //- Why Add 3? 0 Press Start, 1 Sign in, 2 = Main Menu  //
    const int32 NextIndex = Index + 3;
    switch (Index)
    {
    default:
    case 0:
    case 2:
    case 3:
        SetActiveMenu(NextIndex, MenuSwitcher);
        break;
    case 1:
        //- Multiplayer Menu    //
        SetActiveMenu(NextIndex, MenuSwitcher);
        //- Set Multiplayer Switcher back to the Main Page  //
        SetActiveMenu(0, MultiplayerMenuSwitcher);
        break;
    case 4:
        //- Options Menu    //
        if(MenuInterface != nullptr && GetOwningPlayer() != nullptr)
        {
            MenuInterface->LaunchOptionsMenu(GetOwningPlayer(), this, true);
        }
        break;
    case 5:
        //- Go Back to Sign in screen //
        if(GetOnlineSubsystem() == EOnlineSubsystem::Steam)
        {
            if(PlayFabMenu != nullptr)
            {
                PlayFabMenu->LoginToPlayFab();
            }
            //- Steam Doesn't allow Login/Logout    //
            return;
        }
        if(MenuInterface != nullptr)
        {
            MenuInterface->Logout();    
        }
        SetActiveMenu(1, MenuSwitcher);
        break;
    case 6:
        OpenQuitConfirmationPopup();
        break;
    }
}

MinNumberOnSliderChanged()

void UMainMenuSystemWidget::MinNumberOnSliderChanged ( float Value )

protected

{
    MinNumberOfPlayers = Value;
    MinNumberOfPlayersText->SetText(FText::AsNumber(Value));
}

ModalButtonSelected()

void UMainMenuSystemWidget::ModalButtonSelected ( const int32 Index )

overrideprotectedvirtual

Reimplemented from UMenuSystemWidget.

{
    Super::ModalButtonSelected(Index);
    if(GetCurrentModal() != nullptr)
    {
        if(Index == GetCurrentModal()->GetMainButtonIndex() && bCloseGame)
        {
            UMenuBPLib::QuitGame(GetOwningPlayer());
            return;
        }
        bCloseGame = false;
        GetCurrentModal()->CloseWindow();
    }
    ReturnToCurrentMenu();
    ActivateWidget();
}

MultiplayerMenuButtonSelected()

void UMainMenuSystemWidget::MultiplayerMenuButtonSelected ( const int32 Index )

private

{
    const int32 NextIndex = Index + 1;
    switch (Index)
    {
    default:
    case 0:
        //- Quick Match //
        if(MenuInterface != nullptr)
        {
            MenuInterface->FindSessionAndJoin();
            SetActiveMenu(NextIndex, MultiplayerMenuSwitcher);
        }
        break;
    case 2:
        //- Browse Servers  //
        SetActiveMenu(NextIndex, MultiplayerMenuSwitcher);
        SearchServers();
        break;
    case 1:
        //- Playlist    //
    case 3:
        //- Create Game //
    case 4:
        //- EMPTY   //
        SetActiveMenu(NextIndex, MultiplayerMenuSwitcher);
        break;
    case 5:
        //- Back    //
        ReturnToMainMenu();
        break;
    case 6:
        break;
    }
}

NativeConstruct()

void UMainMenuSystemWidget::NativeConstruct ( )

overrideprotectedvirtual

Reimplemented from UMenuSystemWidget.

{
    Super::NativeConstruct();
    SetDifficultyLevelText();
    PlayFabMenu = Cast<IPlayFabMenu>(GetGameInstance());
    ActivateWidget();
}

NativeGetDesiredFocusTarget()

UWidget * UMainMenuSystemWidget::NativeGetDesiredFocusTarget ( ) const

overridevirtual

{
    if(GetCurrentModal() != nullptr)
    {
        return GetCurrentModal();
    }
    if(MenuPageIndex == 0 && StartScreenButton != nullptr)
    {
        return StartScreenButton;
    }
    //@CHECK change type to ActivatableWidget, and return x->GetDesiredFocusTarget()
    return GetActiveMenuWidget();
}

NumberOnSliderChanged()

void UMainMenuSystemWidget::NumberOnSliderChanged ( float Value )

protected

{
    NumberOfPlayers = Value;
    NumberOfPlayersText->SetText(FText::AsNumber(Value));
}

OnDifficultyChanged()

void UMainMenuSystemWidget::OnDifficultyChanged ( )

protected

OpenLevelSelect()

void UMainMenuSystemWidget::OpenLevelSelect ( const EGameplayMode GameplayMode = EGameplayMode::Multiplayer, const bool bDebugLevels = false )

protected

{
    if(LevelSelectClass == nullptr || GetOwningPlayer() == nullptr){UE_LOG(LogMenuSystem, Error, TEXT("Open Level Select Failed"));return;}
    if(LevelSelectionWidget == nullptr)
    {
        LevelSelectionWidget = CreateWidget<ULevelSelectionWidget>(GetOwningPlayer(), LevelSelectClass);
        if(LevelSelectionWidget != nullptr)
        {
            LevelSelectionWidget->OnMenuBackButtonSelected.AddUniqueDynamic(this, &UMainMenuSystemWidget::CloseLevelSelect);
            LevelSelectOverlay->AddChild(LevelSelectionWidget);
        }
    }
    if(LevelSelectionWidget == nullptr){UE_LOG(LogMenuSystem, Error, TEXT("Level Select Widget Failed to Create"));return;}
    LevelSelectionWidget->SetMode(GameplayMode, bDebugLevels);
    LevelSelectionWidget->GetLastSelectedLevel();
    LevelSelectionWidget->SetVisibility(ESlateVisibility::Visible);
    LevelSelectionWidget->ActivateWidget();
    DeactivateWidget();
}

OpenQuitConfirmationPopup()

void UMainMenuSystemWidget::OpenQuitConfirmationPopup ( )

protected

{
    bCloseGame = true;
    const FModalData ModalData = FModalData(true);
    OpenConfirmationMessage(ModalData);
    DeactivateWidget();
}

PlaylistMenuButtonSelected()

void UMainMenuSystemWidget::PlaylistMenuButtonSelected ( const int32 Index )

private

{
    switch (Index)
    {
    default:
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
        //- Back    //
        ReturnToMultiplayerMenu();
        break;
    case 6:
        break;
    }
}

QuickMatchMenuButtonSelected()

void UMainMenuSystemWidget::QuickMatchMenuButtonSelected ( const int32 Index )

private

{
    switch (Index)
    {
    default:
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
        //- Stop Searching  //
        ReturnToMultiplayerMenu();
        break;
    case 6:
        break;
    }
}

ReturnToCurrentMenu()

void UMainMenuSystemWidget::ReturnToCurrentMenu ( )

protected

{
    SetActiveMenu(-1, GetActiveMenu());
}

ReturnToMainMenu()

void UMainMenuSystemWidget::ReturnToMainMenu ( )

protected

{
    SetActiveMenu(MainMenuPageIndexNumber, MenuSwitcher);
}

ReturnToMultiplayerMenu()

void UMainMenuSystemWidget::ReturnToMultiplayerMenu ( )

protected

{
    SetActiveMenu(0, MultiplayerMenuSwitcher);
}

SearchServers()

void UMainMenuSystemWidget::SearchServers ( )

protected

{
    if(MenuInterface != nullptr)
    {
        ServerList->ClearChildren();
        MenuInterface->SearchServers();
        bSearchingForServersInProgress = true;
        SearchingProgressSpinner->SetVisibility(ESlateVisibility::Visible);
    }
}

SelectIndex()

void UMainMenuSystemWidget::SelectIndex

(

uint32

Index

)

{
    SelectedIndex = Index;
    UpdateServerRows();
}

SetActiveMenu()

void UMainMenuSystemWidget::SetActiveMenu ( const int32 Index, class UWidgetSwitcher * MenuSwitcherWidget )

protected

{
    if(Index != -1)
    {
        if(MenuSwitcherWidget == MenuSwitcher)
        {
            MenuPageIndex = Index;
        }
        if(MenuSwitcherWidget == MultiplayerMenuSwitcher)
        {
            MultiplayerPageIndex = Index;
        }
        MenuSwitcherWidget->SetActiveWidgetIndex(Index);
    }
    UMenuSystemWidget* ActiveWidget = Cast<UMenuSystemWidget>(MenuSwitcherWidget->GetActiveWidget());
    if(ActiveWidget != nullptr)
    {
        ActiveWidget->ActivateWidget();
    }
    else
    {
        //- In case their is an overlay with multiple 
        const UOverlay* OverlayMenu = Cast<UOverlay>(MenuSwitcherWidget->GetActiveWidget());
        if(OverlayMenu != nullptr)
        {
            ActiveWidget = Cast<UMenuSystemWidget>(OverlayMenu->GetChildAt(0));
            if(ActiveWidget != nullptr)
            {
                ActiveWidget->ActivateWidget();
            }
        }
    }
}

SetDifficultyLevelText()

void UMainMenuSystemWidget::SetDifficultyLevelText ( ) const

protected

{
    const FString DifficultyLevel = UMenuBPLib::GetCurrentDifficultyLevelString(GetOwningPlayer());
    DifficultyTextBlock->SetText(FText::FromString(DifficultyLevel));
}

SetIsControllerInput()

void UMainMenuSystemWidget::SetIsControllerInput ( bool bIsNewController )

protected

{
    if(!bIsNewController == bIsControllerInput)
    {
        bIsControllerInput = bIsNewController;
    }
}

SetServerList()

void UMainMenuSystemWidget::SetServerList ( const TArray< FServerRow > & ServerInfo )

overridevirtual

Reimplemented from UMenuSystemWidget.

{
    UWorld* WorldRef = GetWorld();
    if (!ensure(WorldRef != nullptr)) return;
    ServerList->ClearChildren();
    uint32 i = 0;
    for(const FServerRow& ServerData : ServerInfo)
    {
        UServerRowMenuSystemWidget* Row = CreateWidget<UServerRowMenuSystemWidget>(WorldRef, ServerRowClass);
        if(Row != nullptr)
        {
            Row->ServerNameText->SetText(FText::FromString(ServerData.ServerName));
            FString PlayerCount = FString::Printf(TEXT("(%d/%d)"), ServerData.CurrentPlayers, ServerData.MaxPlayers);
            Row->ServerPlayerCountText->SetText(FText::FromString(PlayerCount));
            Row->ServerOwningPlayerText->SetText(FText::FromString(ServerData.HostUsername));
            Row->ServerPingText->SetText(FText::FromString(FString::Printf(TEXT("%dms"), ServerData.Ping)));
            Row->Setup(this, i);
            ++i;
            ServerList->AddChild(Row);
        }
    }
    bSearchingForServersInProgress = false;
    SearchingProgressSpinner->SetVisibility(ESlateVisibility::Hidden);
}

SignInScreenButtonSelected()

void UMainMenuSystemWidget::SignInScreenButtonSelected ( const int32 Index )

private

{
    switch (Index)
    {
    default:
    case 0:
        LoginToEpicOnline();
        ReturnToMainMenu();
        break;
    case 1:
        //- Play Offline    //
        ReturnToMainMenu();
        break;
    case 2:
        break;
    case 3:
        break;
    case 4:
        break;
    case 5:
        OpenQuitConfirmationPopup();
        break;
    case 6:
        break;
    }
}

StartScreenButtonClicked()

void UMainMenuSystemWidget::StartScreenButtonClicked ( )

private

{
    //- If Logged in Skip Login Page    //
    if(GetIsPlayerLoggedIn())
    {
        ReturnToMainMenu();
        return;
    }
    SetActiveMenu(SignInPageIndexNumber, MenuSwitcher);
}

UpdateServerRows()

void UMainMenuSystemWidget::UpdateServerRows ( )

protected

{
    for (int32 i = 0; i < ServerList->GetChildrenCount(); ++i)
    {
        UServerRowMenuSystemWidget* Row = Cast<UServerRowMenuSystemWidget>(ServerList->GetChildAt(i));
        if(Row != nullptr)
        {
            const bool bIsSelected = (SelectedIndex.IsSet() && SelectedIndex.GetValue() == i);
            Row->SetAsSelected(bIsSelected);
        }
    }
}

Member Data Documentation

bAllowInvites

bool UMainMenuSystemWidget::bAllowInvites = false

protected

bAllowJoinInProgress

bool UMainMenuSystemWidget::bAllowJoinInProgress = false

protected

bAllowJoinViaPresence

bool UMainMenuSystemWidget::bAllowJoinViaPresence = false

protected

bCloseGame

bool UMainMenuSystemWidget::bCloseGame = false

private

bIsControllerInput

bool UMainMenuSystemWidget::bIsControllerInput = false

protected

bIsDedicatedServer

bool UMainMenuSystemWidget::bIsDedicatedServer = false

protected

bIsLAN

bool UMainMenuSystemWidget::bIsLAN = false

protected

BrowseMenu

class USingleMenuSystemWidget* UMainMenuSystemWidget::BrowseMenu = nullptr

protected

bSearchingForServersInProgress

bool UMainMenuSystemWidget::bSearchingForServersInProgress = false

protected

bShouldAdvertise

bool UMainMenuSystemWidget::bShouldAdvertise = false

protected

bUseLobbiesIfAvailable

bool UMainMenuSystemWidget::bUseLobbiesIfAvailable = false

protected

bUseLobbiesVoiceChatIfAvailable

bool UMainMenuSystemWidget::bUseLobbiesVoiceChatIfAvailable = false

protected

bUsesPresence

bool UMainMenuSystemWidget::bUsesPresence = false

protected

ButtonFocused

int32 UMainMenuSystemWidget::ButtonFocused = 1

protected

CampaignMenu

class USingleMenuSystemWidget* UMainMenuSystemWidget::CampaignMenu = nullptr

protected

CharacterMenu

class USingleMenuSystemWidget* UMainMenuSystemWidget::CharacterMenu = nullptr

protected

DedicatedServerCheckbox

class UCheckBox* UMainMenuSystemWidget::DedicatedServerCheckbox = nullptr

protected

DifficultyTextBlock

class UTextBlock* UMainMenuSystemWidget::DifficultyTextBlock = nullptr

protected

GameVersionText

class UTextBlock* UMainMenuSystemWidget::GameVersionText = nullptr

protected

HordeMenu

class USingleMenuSystemWidget* UMainMenuSystemWidget::HordeMenu = nullptr

protected

HostMenu

class USingleMenuSystemWidget* UMainMenuSystemWidget::HostMenu = nullptr

protected

IPInputTextBox

class UEditableTextBox* UMainMenuSystemWidget::IPInputTextBox = nullptr

protected

JoinButton

class UButton* UMainMenuSystemWidget::JoinButton = nullptr

protected

LANCheckbox

class UCheckBox* UMainMenuSystemWidget::LANCheckbox = nullptr

protected

LevelSelectClass

TSubclassOf<class UUserWidget> UMainMenuSystemWidget::LevelSelectClass

private

LevelSelectionWidget

class ULevelSelectionWidget* UMainMenuSystemWidget::LevelSelectionWidget = nullptr

protected

LevelSelectOverlay

class UOverlay* UMainMenuSystemWidget::LevelSelectOverlay = nullptr

protected

MainMenu

class USingleMenuSystemWidget* UMainMenuSystemWidget::MainMenu = nullptr

protected

MainMenuPageIndexNumber

const int32 UMainMenuSystemWidget::MainMenuPageIndexNumber = 2

protected

MenuPageIndex

int32 UMainMenuSystemWidget::MenuPageIndex = 0

protected

MenuSwitcher

class UCommonActivatableWidgetSwitcher* UMainMenuSystemWidget::MenuSwitcher = nullptr

protected

MinNumberOfPlayers

float UMainMenuSystemWidget::MinNumberOfPlayers = 1

private

MinNumberOfPlayersSlider

class USlider* UMainMenuSystemWidget::MinNumberOfPlayersSlider = nullptr

protected

MinNumberOfPlayersText

class UTextBlock* UMainMenuSystemWidget::MinNumberOfPlayersText = nullptr

protected

ModalPanel

class UPanelWidget* UMainMenuSystemWidget::ModalPanel = nullptr

protected

MultiplayerMenu

class USingleMenuSystemWidget* UMainMenuSystemWidget::MultiplayerMenu = nullptr

protected

MultiplayerMenuSwitcher

class UCommonActivatableWidgetSwitcher* UMainMenuSystemWidget::MultiplayerMenuSwitcher = nullptr

protected

MultiplayerPageIndex

int32 UMainMenuSystemWidget::MultiplayerPageIndex = 0

protected

MultiplayerPageIndexNumber

const int32 UMainMenuSystemWidget::MultiplayerPageIndexNumber = 4

protected

NotificationPanel

class UPanelWidget* UMainMenuSystemWidget::NotificationPanel = nullptr

protected

NumberOfPlayers

float UMainMenuSystemWidget::NumberOfPlayers = 1

private

NumberOfPlayersSlider

class USlider* UMainMenuSystemWidget::NumberOfPlayersSlider = nullptr

protected

NumberOfPlayersText

class UTextBlock* UMainMenuSystemWidget::NumberOfPlayersText = nullptr

protected

PlayFabMenu

class IPlayFabMenu* UMainMenuSystemWidget::PlayFabMenu = nullptr

private

PlaylistMenu

class USingleMenuSystemWidget* UMainMenuSystemWidget::PlaylistMenu = nullptr

protected

QuickMatchMenu

class USingleMenuSystemWidget* UMainMenuSystemWidget::QuickMatchMenu = nullptr

protected

SearchingProgressSpinner

class UWidget* UMainMenuSystemWidget::SearchingProgressSpinner = nullptr

protected

SearchServersButton

class UButton* UMainMenuSystemWidget::SearchServersButton = nullptr

protected

SelectedIndex

TOptional<uint32> UMainMenuSystemWidget::SelectedIndex

private

ServerList

class UPanelWidget* UMainMenuSystemWidget::ServerList = nullptr

protected

ServerNameTextBox

class UEditableTextBox* UMainMenuSystemWidget::ServerNameTextBox = nullptr

protected

ServerRowClass

TSubclassOf<class UUserWidget> UMainMenuSystemWidget::ServerRowClass

private

SignInPageIndexNumber

const int32 UMainMenuSystemWidget::SignInPageIndexNumber = 1

protected

SignInScreenMenu

class USingleMenuSystemWidget* UMainMenuSystemWidget::SignInScreenMenu = nullptr

protected

StartScreen

class UWidget* UMainMenuSystemWidget::StartScreen = nullptr

protected

StartScreenButton

class UButton* UMainMenuSystemWidget::StartScreenButton = nullptr

protected

UserNameText

class UTextBlock* UMainMenuSystemWidget::UserNameText = nullptr

protected

UsesPresenceCheckbox

class UCheckBox* UMainMenuSystemWidget::UsesPresenceCheckbox = nullptr

protected

---

The documentation for this class was generated from the following files:

• T:/Unreal/Unreal Projects/SpaceAdventure52/SpaceAdventure/Plugins/MenuSystem/Source/MenuSystem/Public/Widgets/MainMenuSystemWidget.h
• T:/Unreal/Unreal Projects/SpaceAdventure52/SpaceAdventure/Plugins/MenuSystem/Source/MenuSystem/Private/Widgets/MainMenuSystemWidget.cpp