AMenuSystemLobbyGameMode Class Reference

#include <MenuSystemLobbyGameMode.h>

Inheritance diagram for AMenuSystemLobbyGameMode:

Public Member Functions
	AMenuSystemLobbyGameMode ()
virtual void	RegisterPlayer (APlayerController *NewPlayer)
void	StartCountdown ()
void	CancelCountdown ()
void	DebugAddPlayerXP (APlayerController *Player, const int32 XP=100)
void	DebugSaveProfile (APlayerController *Player)
void	DebugLoadProfile (APlayerController *Player)
void	DebugRefreshPlayerList ()

Public Attributes
TArray< class AMenuSystemPlayerController * >	AllPlayerControllers

Protected Member Functions
virtual void	BeginPlay () override
void	SetPlayerName (const APlayerController *Player, const FString &Name) const
virtual void	GenericPlayerInitialization (AController *Controller) override
virtual void	PostLogin (APlayerController *NewPlayer) override
virtual void	HandleSeamlessTravelPlayer (AController *&Controller) override
virtual void	SwapPlayerControllers (APlayerController *OldPC, APlayerController *NewPC) override
virtual void	Logout (AController *Exiting) override

Protected Attributes
int32	StartDelay = 5
bool	bAutoStart = false
class AMenuSystemGameState *	MenuGameState = nullptr

Private Member Functions
void	StartGame () const
void	NotifyPlayersCountdownStarted (const int32 Delay)
void	NotifyPlayersCountdownCanceled ()

Private Attributes
uint32	NumberOfPlayers = 0
uint32	MinNumberOfPlayers = 2
FTimerHandle	LoadMapTimerHandle

Constructor & Destructor Documentation

AMenuSystemLobbyGameMode()

AMenuSystemLobbyGameMode::AMenuSystemLobbyGameMode

(

)

{
    bUseSeamlessTravel = true;
}

Member Function Documentation

BeginPlay()

void AMenuSystemLobbyGameMode::BeginPlay ( )

overrideprotectedvirtual

{
    Super::BeginPlay();
    MenuGameState = GetGameState<AMenuSystemGameState>();
}

CancelCountdown()

void AMenuSystemLobbyGameMode::CancelCountdown

(

)

{
    GetWorldTimerManager().ClearTimer(LoadMapTimerHandle);
    NotifyPlayersCountdownCanceled();
}

DebugAddPlayerXP()

void AMenuSystemLobbyGameMode::DebugAddPlayerXP	(	APlayerController *	Player,
		const int32	XP = 100 )

{
    if(Player == nullptr){UE_LOG(LogMenuSystem, Error, TEXT("Player NUllptr in lobby"))return;}
    AMenuSystemPlayerState* MenuPlayerState = Player->GetPlayerState<AMenuSystemPlayerState>();
    if(MenuPlayerState != nullptr)
    {
        FUserProfile UserProfile = MenuPlayerState->GetUserProfile();
        UserProfile.AddXP(XP);
        MenuPlayerState->SetUserProfile(UserProfile);
                
    }
}

DebugLoadProfile()

void AMenuSystemLobbyGameMode::DebugLoadProfile

(

APlayerController *

Player

)

{
    IMenuSystem* MenuInterface = Cast<IMenuSystem>(GetGameInstance());
    if(MenuInterface == nullptr || Player == nullptr){return;}
    IOnlinePlayerState* OnlinePlayerState = Cast<IOnlinePlayerState>(Player->PlayerState);
    if(OnlinePlayerState != nullptr)
    {
        FUserProfile UserProfile;
        const bool bSuccess = MenuInterface->LoadOfflinePlayerProfile(UserProfile);
        if(bSuccess)
        {
            OnlinePlayerState->SetUserProfile(UserProfile);
            UE_LOG(LogMenuSystem, Warning, TEXT("DEBUG - Player Profile Loaded"));
        }
    }
}

DebugRefreshPlayerList()

void AMenuSystemLobbyGameMode::DebugRefreshPlayerList

(

)

{
    TArray<FUserProfile> AllUserProfiles;
    for(const auto PlayerController : AllPlayerControllers)
    {
        const IOnlinePlayerState* OnlinePlayerState = Cast<IOnlinePlayerState>(PlayerController->PlayerState);
        if(OnlinePlayerState != nullptr)
        {
            AllUserProfiles.AddUnique(OnlinePlayerState->GetUserProfile());
            // UE_LOG(LogMenuSystem, Warning, TEXT("Player Profile Loop, %s"), *OnlinePlayerState->GetUserProfile().DisplayName);
        }
    }
    for(const auto PlayerController : AllPlayerControllers)
    {
        PlayerController->SetPlayers(AllUserProfiles);
    }
}

DebugSaveProfile()

void AMenuSystemLobbyGameMode::DebugSaveProfile

(

APlayerController *

Player

)

{
    IMenuSystem* MenuInterface = Cast<IMenuSystem>(GetGameInstance());
    if(MenuInterface == nullptr){return;}
    MenuInterface->SaveOfflinePlayerProfile();
}

GenericPlayerInitialization()

void AMenuSystemLobbyGameMode::GenericPlayerInitialization ( AController * Controller )

overrideprotectedvirtual

{
    Super::GenericPlayerInitialization(Controller);
    APlayerController* NewPlayer = Cast<APlayerController>(Controller);
    if(NewPlayer == nullptr){return;}
    RegisterPlayer(NewPlayer);
    
    NumberOfPlayers++;
 
    if(MenuGameState == nullptr)
    {
        MenuGameState = GetGameState<AMenuSystemGameState>();
    }
    AMenuSystemPlayerController* MenuPlayerController = Cast<AMenuSystemPlayerController>(NewPlayer);
    if(MenuPlayerController != nullptr)
    {
        AllPlayerControllers.Add(MenuPlayerController);
        MenuPlayerController->CreateLobbyWidget();
        const AMenuSystemPlayerState* MenuPlayerState = MenuPlayerController->GetPlayerState<AMenuSystemPlayerState>();
        if(MenuPlayerState != nullptr)
        {
            UE_LOG(LogMenuSystem, Warning, TEXT("Player State Name: %s"), *MenuPlayerState->GetUserProfile().DisplayName);
            if(MenuGameState != nullptr)
            {
                // MenuGameState->AllProfiles.Add(MenuPlayerState->GetUserProfile());
                // UE_LOG(LogMenuSystem, Warning, TEXT("GM Player Name: %s"), *MenuPlayerState->GetUserProfile().DisplayName);
                MenuGameState->UpdatePlayerList();
                // MenuGameState->SetInLobby(true);
            }
        }
    }
    const IMenuSystem* MenuInterface = Cast<IMenuSystem>(GetGameInstance());
    if(MenuInterface != nullptr)
    {
        MinNumberOfPlayers = MenuInterface->GetMinNumberOfPlayersToStart();
    }
    UE_LOG(LogMenuSystem, Warning, TEXT("Number of Players: %d, Required: %d"), NumberOfPlayers, MinNumberOfPlayers);
    if(bAutoStart && NumberOfPlayers >= MinNumberOfPlayers)
    {
        StartCountdown();
    }
    // !Temp    // 
    DebugRefreshPlayerList();
}

HandleSeamlessTravelPlayer()

void AMenuSystemLobbyGameMode::HandleSeamlessTravelPlayer ( AController *& Controller )

overrideprotectedvirtual

{
    Super::HandleSeamlessTravelPlayer(Controller);
}

Logout()

void AMenuSystemLobbyGameMode::Logout ( AController * Exiting )

overrideprotectedvirtual

{
    Super::Logout(Exiting);
    AMenuSystemPlayerController* MenuSystemPlayerController = Cast<AMenuSystemPlayerController>(Exiting);
    if(MenuSystemPlayerController != nullptr)
    {
        AllPlayerControllers.Remove(MenuSystemPlayerController);
    }
    NumberOfPlayers--;
    UE_LOG(LogMenuSystem, Warning, TEXT("Number of Players: %d"), NumberOfPlayers);
}

NotifyPlayersCountdownCanceled()

void AMenuSystemLobbyGameMode::NotifyPlayersCountdownCanceled ( )

private

{
    for(const auto PlayerController : AllPlayerControllers)
    {
        PlayerController->CancelCountdown();
    }
}

NotifyPlayersCountdownStarted()

void AMenuSystemLobbyGameMode::NotifyPlayersCountdownStarted ( const int32 Delay )

private

{
    for(const auto PlayerController : AllPlayerControllers)
    {
        PlayerController->StartCountdown(Delay);
    }
}

PostLogin()

void AMenuSystemLobbyGameMode::PostLogin ( APlayerController * NewPlayer )

overrideprotectedvirtual

{
    Super::PostLogin(NewPlayer);
}

RegisterPlayer()

void AMenuSystemLobbyGameMode::RegisterPlayer ( APlayerController * NewPlayer )

virtual

{
    FUniqueNetIdRepl UniqueNetIdRepl;
    if(NewPlayer->IsLocalController())
    {
        const ULocalPlayer* LocalPlayer = NewPlayer->GetLocalPlayer();
        if(LocalPlayer != nullptr)
        {
            UniqueNetIdRepl = LocalPlayer->GetPreferredUniqueNetId();
        }
        else
        {
            const UNetConnection* RemoteNetConnection = Cast<UNetConnection>(NewPlayer->Player);
            check(IsValid(RemoteNetConnection));
            UniqueNetIdRepl = RemoteNetConnection->PlayerId;
        }
    }
    else
    {
        const UNetConnection* RemoteNetConnection = Cast<UNetConnection>(NewPlayer->Player);
        check(IsValid(RemoteNetConnection));
        UniqueNetIdRepl = RemoteNetConnection->PlayerId;
    }
    const TSharedPtr<const FUniqueNetId> UniqueNetId = UniqueNetIdRepl.GetUniqueNetId();
    //- extra added error check from pre login // 
    if(UniqueNetId == nullptr){Logout(NewPlayer);return;}
    check(UniqueNetId != nullptr)
    const IOnlineSubsystem* OnlineSubsystem = Online::GetSubsystem(NewPlayer->GetWorld());
    if(OnlineSubsystem != nullptr)
    {
        const IOnlineSessionPtr Session = OnlineSubsystem->GetSessionInterface();
        if(Session != nullptr)
        {
            const IMenuSystem* MenuSystem = Cast<IMenuSystem>(GetGameInstance());
            if(MenuSystem)
            {
                const bool bRegistrationSuccess = Session->RegisterPlayer(FName(MenuSystem->GetCurrentSessionName()),*UniqueNetId, false);
                if(bRegistrationSuccess)
                {
                    const IOnlineIdentityPtr OnlineIdentity = OnlineSubsystem->GetIdentityInterface();
                    if(OnlineIdentity != nullptr)
                    {
                        const FString PlayerName = OnlineIdentity->GetPlayerNickname(*UniqueNetId);
                        SetPlayerName(NewPlayer, PlayerName);
                    }
                    UE_LOG(LogMenuSystem,Warning,TEXT("Player Registered!, "));
                }
            }
        }
    }
}

SetPlayerName()

void AMenuSystemLobbyGameMode::SetPlayerName ( const APlayerController * Player, const FString & Name ) const

protected

{
    UE_LOG(LogMenuSystem,Warning,TEXT("Player Name: %s"), *Name);
    AMenuSystemPlayerState* MenuPlayerState = Player->GetPlayerState<AMenuSystemPlayerState>();
    if(MenuPlayerState != nullptr)
    {
        FUserProfile OnlineUserProfile;
        OnlineUserProfile.DisplayName = Name;
        MenuPlayerState->SetUserProfile(OnlineUserProfile);
        UE_LOG(LogMenuSystem, Warning, TEXT("Player State Name: %s"), *MenuPlayerState->GetUserProfile().DisplayName);
        if(MenuGameState != nullptr)
        {
            MenuGameState->UpdatePlayerList();
        }
    }
}

StartCountdown()

void AMenuSystemLobbyGameMode::StartCountdown

(

)

{
    NotifyPlayersCountdownStarted(StartDelay);
    GetWorldTimerManager().SetTimer(LoadMapTimerHandle, this, &AMenuSystemLobbyGameMode::StartGame, StartDelay, false);
}

StartGame()

void AMenuSystemLobbyGameMode::StartGame ( ) const

private

{
    UE_LOG(LogMenuSystem, Warning,TEXT("LoadMap"));
    IMenuSystem* MenuInterface = Cast<IMenuSystem>(GetGameInstance());
    if(MenuInterface == nullptr) return;
    MenuInterface->StartSession();
}

SwapPlayerControllers()

void AMenuSystemLobbyGameMode::SwapPlayerControllers ( APlayerController * OldPC, APlayerController * NewPC )

overrideprotectedvirtual

{
    Super::SwapPlayerControllers(OldPC, NewPC);
}

Member Data Documentation

AllPlayerControllers

TArray<class AMenuSystemPlayerController*> AMenuSystemLobbyGameMode::AllPlayerControllers

bAutoStart

bool AMenuSystemLobbyGameMode::bAutoStart = false

protected

LoadMapTimerHandle

FTimerHandle AMenuSystemLobbyGameMode::LoadMapTimerHandle

private

MenuGameState

class AMenuSystemGameState* AMenuSystemLobbyGameMode::MenuGameState = nullptr

protected

MinNumberOfPlayers

uint32 AMenuSystemLobbyGameMode::MinNumberOfPlayers = 2

private

NumberOfPlayers

uint32 AMenuSystemLobbyGameMode::NumberOfPlayers = 0

private

StartDelay

int32 AMenuSystemLobbyGameMode::StartDelay = 5

protected

---

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

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