UEpicOnlineGameInstance Class Reference

#include <EpicOnlineGameInstance.h>

Inheritance diagram for UEpicOnlineGameInstance:

Public Member Functions
	UEpicOnlineGameInstance (const FObjectInitializer &ObjectInitializer)
virtual void	Init () override
virtual void	Shutdown () override
virtual EDifficultyLevel	GetDifficultyLevel () const override
virtual void	SetDifficultyLevel (const EDifficultyLevel NewDifficultyLevel) override
virtual FString	GetAuthToken () const override
virtual void	LoginToPlayFab () override
virtual FString	GetPlayFabID () const override
virtual bool	GetIsLoggedInToPlayFab () const override
virtual float	GetPlayFabCurrency () const override
virtual TArray< UPlayFabJsonObject * >	GetPlayFabInventory () const override
virtual void	LoginToEpicOnline (FString ID="", FString Token="", FString LoginType="accountportal") override
virtual void	Logout () const override
virtual void	CreateEOSSession (FString SessionName, bool bIsDedicatedServer, bool bIsLAN, bool bIsPresence, int32 MaxNumPlayers) override
virtual void	FindSessionAndJoin () override
virtual void	DestroySession () override
virtual FString	GetPlayerUserName () const override
virtual bool	GetIsPlayerLoggedIn () const override
virtual FString	GetCurrentSessionName () const override
virtual void	LaunchInGameMenu (APlayerController *Player, const bool bOpen=true) override
virtual void	LaunchOptionsMenu (APlayerController *Player, UUserWidget *CurrentWidget=nullptr, const bool bOpen=true) override
virtual void	StartSession () override
virtual TSubclassOf< UUserWidget >	GetModalWidgetClass () override
virtual bool	GetDebuggingMode () const override
virtual void	SearchServers () override
virtual void	StartCampaign (const bool bNewGame) const override
virtual void	RestartLevel () const
virtual void	StartHorde () const override
virtual void	SetCurrentSaveSlot (const int32 NewSaveSlot) override
virtual int32	GetCurrentSaveSlot () override
virtual TArray< int32 >	GetAllSaveSlots () override
virtual FUserSaveGame	GetSaveInfoFromSlot (const int32 Slot) override
virtual bool	GetIsOnlineGame () const override
virtual bool	GetIsPublicMatch () const override
virtual EOnlineSubsystem	GetOnlineSubsystem () const override
virtual void	Host (FOnlineSessionSettings HostSessionSettings) override
virtual void	SinglePlayer () override
virtual void	Character () override
virtual void	Options () override
virtual void	Join (uint32 Index) override
virtual void	JoinManualAddress (const FString &IpAddress) override
virtual void	Quit (APlayerController *Player) override
virtual void	UpdateStats (FString StatName, int32 Amount)
virtual void	GetStats (TArray< FString > StatName)
virtual void	LoadMenu () override
TArray< uint8 >	ConvertSaveFileTouint (class USaveGame *SavedGame)
class USaveGame *	ConvertunitToSaveFile (TArray< uint8 > SavedGameArray)
void	UpdatePlayerData (const FString &FileName, TArray< uint8 > SavedGameArray)
void	GetPlayerData (const FString &FileName)
void	ReadPlayerData (const FString &FileName) const
virtual int32	GetMinNumberOfPlayersToStart () const override
virtual void	SetMinNumberOfPlayersToStart (const int32 Num) override
virtual UDataTable *	GetLevelDataTable () override
virtual void	SetSelectedLevel (const FGameLevel GameLevel, const EGameplayMode GameMode) override
virtual FGameLevel	GetSelectedLevel (const EGameplayMode GameMode) const override
virtual FUserProfile	GetOfflinePlayerProfile () const override
virtual UDataTable *	GetProfilePicturesDT () const override
virtual bool	SaveOfflinePlayerProfile () override
virtual bool	LoadOfflinePlayerProfile (FUserProfile &OfflineProfile) override

Public Attributes
FOnServersFound	OnServersFoundChanged
FOnFileDataFound	OnFileDataFound
FOnFindReplaysComplete	OnFindReplaysComplete
TSharedPtr< FOnlineSessionSearch >	OnlineSessionSearch
class IOnlineSubsystem *	OnlineSubsystem = nullptr
IOnlineSessionPtr	OnlineSessionPtr
FString	LobbyLevelText
FString	StartupLevelText
FString	DemoLevelText

Protected Member Functions
virtual void	ReturnToMainMenu () override
virtual bool	OpenReplayMenu (APlayerController *Player, const bool bOpen=true) override
virtual void	StartRecordingReplayFromBP (const FString &InName, const FString &FriendlyName) override
virtual void	CreateReplayEvent (const int32 TimeInMS, const FString &Group, const FString &Meta, const TArray< uint8 > &Data) override
virtual void	StopRecordingReplayFromBP () override
virtual void	PlayReplayFromBP (FString ReplayName) override
virtual void	FindReplays () override
virtual void	RenameReplay (const FString &ReplayName, const FString &NewFriendlyReplayName) override
virtual void	DeleteReplay (const FString &ReplayName) override
void	OnLoginEOSCompleted (int32 LocalUserNum, bool bSuccess, const FUniqueNetId &UserID, const FString &Error) const
void	OnLogoutComplete (const int32 ResultCode, const bool bSuccess) const
void	OnCreateSessionCompleted (FName SessionName, bool bSuccess) const
void	OnDestroySessionCompleted (FName SessionName, bool bSuccess) const
void	OnFindSessionCompleted (bool bSuccess)
void	OnFindSessionListCompleted (bool bSuccess) const
void	OnJoinSessionCompleted (FName SessionName, EOnJoinSessionCompleteResult::Type Result) const
void	OnUpdateStatsComplete (const FOnlineError &Result) const
void	OnGetStatsComplete (const FOnlineError &Result, const TArray< TSharedRef< const FOnlineStatsUserStats > > &UserStats)
void	OnWriteUserFileComplete (bool bSuccess, const FUniqueNetId &UserID, const FString &FileName) const
void	OnGetUserFileComplete (bool bSuccess, const FUniqueNetId &UserID, const FString &FileName) const

Protected Attributes
class UInGameMenuSystemWidget *	InGameMenuWidget = nullptr
TSubclassOf< class UUserWidget >	InGameMenuClass = nullptr
class UOptionsMenuSystemWidget *	OptionsMenuWidget = nullptr
TSubclassOf< class UUserWidget >	OptionsMenuClass = nullptr
TSubclassOf< class UUserWidget >	ModalWidgetClass = nullptr
class UMenuSystemWidget *	MainMenu = nullptr
TSubclassOf< class UUserWidget >	MenuClass = nullptr
class UReplayMenu *	ReplayMenu = nullptr
TSubclassOf< UReplayMenu >	ReplayMenuClass = nullptr
bool	bDebuggingMode = true
bool	bInGameMenuOpen = false
bool	bOptionsMenuOpen = false
class UDataTable *	ProfilePicturesDT = nullptr
class UDataTable *	LevelDataTable = nullptr
bool	bAutoLoginToPlayFab = true
FString	CurrencyCode = "PC"
FGameLevel	SelectedCampaignLevel
FGameLevel	SelectedMultiplayerLevel
FGameLevel	SelectedHordeLevel
FGameLevel	SelectedDebugLevel

Private Member Functions
IOnlineIdentityPtr	GetOnlineIdentity () const
void	SetPlayerProfileName ()
	@ TODO REMOVE AFTER Loading Player PROFILE from save,
virtual void	OnNetworkFailure (UWorld *World, UNetDriver *NewDriver, ENetworkFailure::Type FailureType, const FString &ErrorString)
void	OnEnumerateStreamsComplete (const FEnumerateStreamsResult &Result) const
void	OnDeleteFinishedStreamComplete (const FDeleteFinishedStreamResult &Result)
void	OnReplayRenameFinishedComplete (const FRenameReplayResult &Result)
void	SetPlayFabDisplayName ()
void	OnPlayFabLoginSuccess (const PlayFab::ClientModels::FLoginResult &Result)
void	OnPlayFabError (const PlayFab::FPlayFabCppError &ErrorResult)
void	OnPlayFabDisplayChangedSuccess (const PlayFab::AdminModels::FUpdateUserTitleDisplayNameResult &Result)
void	OnPlayFabLGetInventorySuccess (const PlayFab::ClientModels::FGetUserInventoryResult &Result)

Private Attributes
int32	MinNumberOfPlayersToStart = 2
FString	CurrentSessionName = "Default_Server_Name"
EDifficultyLevel	DifficultyLevel = EDifficultyLevel::Normal
FUserProfile	OfflinePlayerProfile
int32	CurrentSaveSlot = 1
TArray< int32 >	AllSaveSlots
TSharedPtr< INetworkReplayStreamer >	EnumerateStreamsPtr
FEnumerateStreamsCallback	OnEnumerateStreamsCompleteDelegate
FDeleteFinishedStreamCallback	OnDeleteFinishedStreamCompleteDelegate
FRenameReplayCallback	OnRenameReplayCompleteDelegate
PlayFabClientPtr	ClientAPI = nullptr
PlayFabAdminPtr	AdminAPI = nullptr
FString	PlayFabID = ""
float	PlayFabCurrency = 0.0f
TArray< PlayFab::ClientModels::FItemInstance >	PlayFabInventory

Constructor & Destructor Documentation

UEpicOnlineGameInstance()

UEpicOnlineGameInstance::UEpicOnlineGameInstance ( const FObjectInitializer & ObjectInitializer )

explicit

    : Super(ObjectInitializer) 
{
    //@BUG mac doesn't compile this Constructor ..
    bDebuggingMode = true;
    ConstructorHelpers::FClassFinder<UUserWidget> const InGameMenuBP(TEXT("/MenuSystem/Widgets/WBP_InGameMenuSystem"));
    if (!ensure(InGameMenuBP.Class != nullptr)) return;
    InGameMenuClass = InGameMenuBP.Class;
    ConstructorHelpers::FClassFinder<UUserWidget> const MainMenuBP(TEXT("/MenuSystem/Widgets/WBP_MainMenuSystem"));
    if (!ensure(MainMenuBP.Class != nullptr)) return;
    MenuClass = MainMenuBP.Class;
    ConstructorHelpers::FClassFinder<UUserWidget> const OptionsMenuBP(TEXT("/MenuSystem/Widgets/WBP_OptionsMenuSystem"));
    if (!ensure(OptionsMenuBP.Class != nullptr)) return;
    OptionsMenuClass = OptionsMenuBP.Class;
    ConstructorHelpers::FClassFinder<UUserWidget> const ReplayMenuBP(TEXT("/MenuSystem/Widgets/Replays/WBP_ReplayMenu"));
    if (!ensure(ReplayMenuBP.Class != nullptr)) return;
    ReplayMenuClass = ReplayMenuBP.Class;
    ConstructorHelpers::FClassFinder<UUserWidget> const ModalWidgetBP(TEXT("/MenuSystem/Widgets/CommonUI/WBP_PopupMenuSystem"));
    if (!ensure(ModalWidgetBP.Class != nullptr)) return;
    ModalWidgetClass = ModalWidgetBP.Class;
}

Member Function Documentation

Character()

void UEpicOnlineGameInstance::Character ( )

overridevirtual

Implements IMenuSystem.

Reimplemented in UMenuSystemGameInstance.

{
}

ConvertSaveFileTouint()

TArray< uint8 > UEpicOnlineGameInstance::ConvertSaveFileTouint

(

class USaveGame *

SavedGame

)

{
    TArray<uint8> SavedData;
    if(SavedGame != nullptr)
    {
        UGameplayStatics::SaveGameToMemory(SavedGame, SavedData);
    }
    return SavedData;
}

ConvertunitToSaveFile()

USaveGame * UEpicOnlineGameInstance::ConvertunitToSaveFile

(

TArray< uint8 >

SavedGameArray

)

{
    USaveGame* LocalObject = nullptr;
    if(!SavedGameArray.IsEmpty())
    {
        LocalObject = UGameplayStatics::LoadGameFromMemory(SavedGameArray);
    }
    return LocalObject;
}

CreateEOSSession()

void UEpicOnlineGameInstance::CreateEOSSession ( FString SessionName, bool bIsDedicatedServer, bool bIsLAN, bool bIsPresence, int32 MaxNumPlayers )

overridevirtual

Implements IMenuSystem.

{
    if(OnlineSessionPtr == nullptr){UE_LOG(LogOnlineGameInstance, Error, TEXT("Online Session PTR FAILED, create EOS session"));return;}
    FOnlineSessionSettings SessionSettings;
    //- Public Match    //
    SessionSettings.bShouldAdvertise = true;
    SessionSettings.bIsDedicated = bIsDedicatedServer;
    SessionSettings.bAllowJoinInProgress = true;
    SessionSettings.bAllowInvites = true;
    if(IOnlineSubsystem::Get()->GetSubsystemName() == "NULL")
    {
        SessionSettings.bIsLANMatch = true;
    }
    else
    {
        SessionSettings.bIsLANMatch = bIsLAN;
    }
    SessionSettings.bUsesPresence = bIsPresence;
    SessionSettings.bAllowJoinViaPresence = bIsPresence;
    SessionSettings.NumPublicConnections = MaxNumPlayers;
 
    if(IOnlineSubsystem::Get()->GetSubsystemName() == "STEAM")
    {
        SessionSettings.bUsesPresence = true;
        SessionSettings.bUseLobbiesIfAvailable = true; // Glitched?
        SessionSettings.bUseLobbiesVoiceChatIfAvailable = true; // Glitched?
        SessionSettings.bAllowJoinViaPresence = true;
        SessionSettings.bShouldAdvertise = true;
        SessionSettings.bIsLANMatch = false;
        SessionSettings.bIsDedicated = false;
        SessionSettings.NumPublicConnections = 5;
    }
 
    if(!SessionName.IsEmpty())
    {
        CurrentSessionName = SessionName;
    }
    const FNamedOnlineSession* ExistingSession = OnlineSessionPtr->GetNamedSession(SESSION_NAME);
    if(ExistingSession != nullptr)
    {
        OnlineSessionPtr->DestroySession(SESSION_NAME);
    }
    SessionSettings.Set(SERVER_NAME_KEY, FString(CurrentSessionName), EOnlineDataAdvertisementType::ViaOnlineServiceAndPing);
    //@TODO  Only create session after we destroy session
    SessionSettings.Set(SEARCH_KEYWORDS, FString("Lobby"), EOnlineDataAdvertisementType::ViaOnlineServiceAndPing);
    OnlineSessionPtr->OnCreateSessionCompleteDelegates.AddUObject(this, &UEpicOnlineGameInstance::OnCreateSessionCompleted);
    OnlineSessionPtr->CreateSession(0,SESSION_NAME, SessionSettings);
}

CreateReplayEvent()

void UEpicOnlineGameInstance::CreateReplayEvent ( const int32 TimeInMS, const FString & Group, const FString & Meta, const TArray< uint8 > & Data )

overrideprotectedvirtual

Implements IReplayClipInterface.

{
    // const UDemoNetDriver* DemoDriver = Cast<UDemoNetDriver>(GetWorld()->GetDemoNetDriver());
    //
    // if(DemoDriver != nullptr && DemoDriver->IsPlaying())
    // {
    //  // Get the current replay time in seconds and convert it to milliseconds
    //  uint32 Time = static_cast<uint32>(DemoDriver->GetDemoCurrentTime() * 1000);
    //  if(EnumerateStreamsPtr.Get() != nullptr)
    //  {
    //      EnumerateStreamsPtr.Get()->AddEvent(Time, Group, Meta, Data);
    //      // EnumerateStreamsPtr.Get()->GetTotalDemoTime()
    //  }
    // }
}

DeleteReplay()

void UEpicOnlineGameInstance::DeleteReplay ( const FString & ReplayName )

overrideprotectedvirtual

Delete a previously recorded replay

Implements IReplayClipInterface.

{
    if(EnumerateStreamsPtr.Get() != nullptr)
    {
        EnumerateStreamsPtr.Get()->DeleteFinishedStream(ReplayName, OnDeleteFinishedStreamCompleteDelegate);
    }
}

DestroySession()

void UEpicOnlineGameInstance::DestroySession ( )

overridevirtual

Implements IMenuSystem.

{
    if(OnlineSessionPtr != nullptr && OnlineSubsystem != nullptr)
    {
        const FNamedOnlineSession* ExistingSession = OnlineSessionPtr->GetNamedSession(SESSION_NAME);
        if(ExistingSession != nullptr)
        {
            if(ExistingSession->SessionState == EOnlineSessionState::Pending || ExistingSession->SessionState == EOnlineSessionState::InProgress || ExistingSession->SessionState == EOnlineSessionState::Starting)
            {
                OnlineSessionPtr->DestroySession(SESSION_NAME);
            }
        }
    }
}

FindReplays()

void UEpicOnlineGameInstance::FindReplays ( )

overrideprotectedvirtual

Start looking for/finding replays on the hard drive

Implements IReplayClipInterface.

{
    if(EnumerateStreamsPtr.Get() != nullptr)
    {
        //@TODO Check user Index 0 
        EnumerateStreamsPtr.Get()->EnumerateStreams(FNetworkReplayVersion(),0, FString(), TArray<FString>(), OnEnumerateStreamsCompleteDelegate);
    }
}

FindSessionAndJoin()

void UEpicOnlineGameInstance::FindSessionAndJoin ( )

overridevirtual

Implements IMenuSystem.

{
    if(OnlineSessionPtr == nullptr){UE_LOG(LogOnlineGameInstance, Error, TEXT("Online Session PTR FAILED, create EOS session"));return;}
    OnlineSessionSearch = MakeShareable(new FOnlineSessionSearch());
    if(OnlineSessionSearch.IsValid())
    {
        OnlineSessionSearch->QuerySettings.Set(SEARCH_LOBBIES, true, EOnlineComparisonOp::Equals);
        OnlineSessionSearch->QuerySettings.Set(SEARCH_PRESENCE, true, EOnlineComparisonOp::Equals);
        if(IOnlineSubsystem::Get()->GetSubsystemName() == "NULL")
        {
            OnlineSessionSearch->bIsLanQuery = true;
        }
        OnlineSessionSearch->MaxSearchResults = 20;
        // OnlineSessionSearch->QuerySettings.SearchParams.Empty();
        OnlineSessionPtr->OnFindSessionsCompleteDelegates.AddUObject(this, &UEpicOnlineGameInstance::OnFindSessionCompleted);
        OnlineSessionPtr->FindSessions(0, OnlineSessionSearch.ToSharedRef());
    }
 
}

GetAllSaveSlots()

virtual TArray< int32 > UEpicOnlineGameInstance::GetAllSaveSlots ( )

inlineoverridevirtual

Implements IMenuSystem.

{return AllSaveSlots;};

GetAuthToken()

FString UEpicOnlineGameInstance::GetAuthToken ( ) const

overridevirtual

Implements IMenuSystem.

{
    if(GetOnlineIdentity() != nullptr)
    {
        return GetOnlineIdentity()->GetAuthToken(0);
    }
    UE_LOG(LogOnlineGameInstance, Error, TEXT("UEpicOnlineGameInstance::GetAuthToken"));
    return "Null";
}

GetCurrentSaveSlot()

virtual int32 UEpicOnlineGameInstance::GetCurrentSaveSlot ( )

inlineoverridevirtual

Implements IMenuSystem.

Reimplemented in UMenuSystemGameInstance.

{return CurrentSaveSlot;};

GetCurrentSessionName()

FString UEpicOnlineGameInstance::GetCurrentSessionName ( ) const

overridevirtual

Implements IMenuSystem.

{
    if(OnlineSubsystem != nullptr)
    {
        const FName SessionName = NAME_GameSession; // Or your specific session name
        if (OnlineSessionPtr->GetNamedSession(SessionName) != nullptr)
        {
            return SessionName.ToString();
        }
    }
    if(bDebuggingMode){UE_LOG(LogOnlineGameInstance, Error, TEXT("Failed to GetCurrentSessionName from GetNamedSession"));}
    if(!CurrentSessionName.IsEmpty())
    {
        return CurrentSessionName;
    }
    if(bDebuggingMode){UE_LOG(LogOnlineGameInstance, Error, TEXT("Failed to GetCurrentSessionName"));}
    return "InvalidName";
}

GetDebuggingMode()

virtual bool UEpicOnlineGameInstance::GetDebuggingMode ( ) const

inlineoverridevirtual

Implements IMenuSystem.

{return bDebuggingMode;};

GetDifficultyLevel()

EDifficultyLevel UEpicOnlineGameInstance::GetDifficultyLevel ( ) const

overridevirtual

Implements IDifficultyInterface.

{
    return DifficultyLevel;
}

GetIsLoggedInToPlayFab()

bool UEpicOnlineGameInstance::GetIsLoggedInToPlayFab ( ) const

overridevirtual

Implements IPlayFabMenu.

{
    return PlayFabID.IsEmpty() == false;
}

GetIsOnlineGame()

bool UEpicOnlineGameInstance::GetIsOnlineGame ( ) const

overridevirtual

Implements IMenuSystem.

{
    if(GetWorld() == nullptr){return false;}
    const ENetMode NetMode = GetWorld()->GetNetMode();
    return NetMode == NM_DedicatedServer || NetMode == NM_ListenServer || NetMode == NM_Client;
}

GetIsPlayerLoggedIn()

bool UEpicOnlineGameInstance::GetIsPlayerLoggedIn ( ) const

overridevirtual

Implements IMenuSystem.

{
    if(GetOnlineIdentity() != nullptr)
    {
        if(GetOnlineIdentity()->GetLoginStatus(0) == ELoginStatus::LoggedIn)
        {
            return true;
        }
        return false;
    }
    if(bDebuggingMode){UE_LOG(LogOnlineGameInstance, Error, TEXT("Failed to GetIsPlayerLoggedIn"));}
    return false;
}

GetIsPublicMatch()

bool UEpicOnlineGameInstance::GetIsPublicMatch ( ) const

overridevirtual

Implements IMenuSystem.

{
    if(OnlineSessionPtr.IsValid() && OnlineSessionPtr->GetNamedSession(NAME_GameSession) != nullptr)
    {
        const FOnlineSessionSettings* SessionSettings = OnlineSessionPtr->GetSessionSettings(NAME_GameSession);
        if(SessionSettings)
        {
            return SessionSettings->bIsLANMatch == false && SessionSettings->bShouldAdvertise == true;
        }
    }
    return false;
}

GetLevelDataTable()

virtual UDataTable * UEpicOnlineGameInstance::GetLevelDataTable ( )

inlineoverridevirtual

Implements ILevelSelectInterface.

{return LevelDataTable;};

GetMinNumberOfPlayersToStart()

virtual int32 UEpicOnlineGameInstance::GetMinNumberOfPlayersToStart ( ) const

inlineoverridevirtual

Implements IMenuSystem.

{return MinNumberOfPlayersToStart;};

GetModalWidgetClass()

virtual TSubclassOf< UUserWidget > UEpicOnlineGameInstance::GetModalWidgetClass ( )

inlineoverridevirtual

Reimplemented from IModalInterface.

{return ModalWidgetClass;};

GetOfflinePlayerProfile()

virtual FUserProfile UEpicOnlineGameInstance::GetOfflinePlayerProfile ( ) const

inlineoverridevirtual

Implements IMenuSystem.

{return OfflinePlayerProfile;};

GetOnlineIdentity()

IOnlineIdentityPtr UEpicOnlineGameInstance::GetOnlineIdentity ( ) const

private

{
    if(OnlineSubsystem != nullptr)
    {
        return OnlineSubsystem->GetIdentityInterface();
    }
    return nullptr;
}

GetOnlineSubsystem()

EOnlineSubsystem UEpicOnlineGameInstance::GetOnlineSubsystem ( ) const

overridevirtual

Implements IMenuSystem.

{
    if(OnlineSubsystem != nullptr)
    {
        if(OnlineSubsystem->GetSubsystemName() == "STEAM")
        {
            return EOnlineSubsystem::Steam;
        }
        if(OnlineSubsystem->GetSubsystemName() == "EOS")
        {
            return EOnlineSubsystem::Epic;
        }
        if(OnlineSubsystem->GetSubsystemName() == "SWITCH")
        {
            return EOnlineSubsystem::Switch;
        }
        if(OnlineSubsystem->GetSubsystemName() == "PS4SERVER")
        {
            return EOnlineSubsystem::Ps4Server;
        }
        if(OnlineSubsystem->GetSubsystemName() == "PS4")
        {
            return EOnlineSubsystem::Ps4;
        }
        if(OnlineSubsystem->GetSubsystemName() == "FACEBOOK")
        {
            return EOnlineSubsystem::Facebook;
        }
        if(OnlineSubsystem->GetSubsystemName() == "GOOGLE")
        {
            return EOnlineSubsystem::Google;
        }
        if(OnlineSubsystem->GetSubsystemName() == "AMAZON")
        {
            return EOnlineSubsystem::Amazon;
        }
        if(OnlineSubsystem->GetSubsystemName() == "APPLE")
        {
            return EOnlineSubsystem::Apple;
        }
        if(OnlineSubsystem->GetSubsystemName() == "IOS")
        {
            return EOnlineSubsystem::Ios;
        }
        if(OnlineSubsystem->GetSubsystemName() == "GOOGLEPLAY")
        {
            return EOnlineSubsystem::GooglePlay;
        }
        if(OnlineSubsystem->GetSubsystemName() == "PlayFab")
        {
            return EOnlineSubsystem::PlayFab;
        }
        if(OnlineSubsystem->GetSubsystemName() == "NULL")
        {
            return EOnlineSubsystem::Null;
        }
    }
    return EOnlineSubsystem::Null;
}

GetPlayerData()

void UEpicOnlineGameInstance::GetPlayerData

(

const FString &

FileName

)

{
    if(GetOnlineIdentity() != nullptr)
    {
        const IOnlineUserCloudPtr UserCloud = OnlineSubsystem->GetUserCloudInterface();
        if(UserCloud != nullptr)
        {
            const TSharedPtr<const FUniqueNetId> UserID = GetOnlineIdentity()->GetUniquePlayerId(0).ToSharedRef();
            UserCloud->OnReadUserFileCompleteDelegates.AddUObject(this, &UEpicOnlineGameInstance::OnGetUserFileComplete);
            UserCloud->ReadUserFile(*UserID, FileName);
        }
    }
}

GetPlayerUserName()

FString UEpicOnlineGameInstance::GetPlayerUserName ( ) const

overridevirtual

Implements IMenuSystem.

{
    if(GetOnlineIdentity() != nullptr)
    {
        if(GetIsPlayerLoggedIn())
        {
            return GetOnlineIdentity()->GetPlayerNickname(0);
        }
    }
    if(bDebuggingMode){UE_LOG(LogOnlineGameInstance, Error, TEXT("Failed to Get Player UserName"));}
    return FString("Default Player");
}

GetPlayFabCurrency()

float UEpicOnlineGameInstance::GetPlayFabCurrency ( ) const

overridevirtual

Implements IPlayFabMenu.

{
    return PlayFabCurrency;
}

GetPlayFabID()

FString UEpicOnlineGameInstance::GetPlayFabID ( ) const

overridevirtual

Implements IPlayFabMenu.

{
    return PlayFabID;
}

GetPlayFabInventory()

TArray< UPlayFabJsonObject * > UEpicOnlineGameInstance::GetPlayFabInventory ( ) const

overridevirtual

Implements IPlayFabMenu.

{
    TArray<UPlayFabJsonObject*> Inventory;
    for(auto Item :PlayFabInventory)
    {
        // Create a string to hold the JSON data
        FString OutputString;
        // Create a JsonWriter to write to a string
        TSharedRef<TJsonWriter<TCHAR, TCondensedJsonPrintPolicy<TCHAR>>> JsonWriter = TJsonWriterFactory<TCHAR, TCondensedJsonPrintPolicy<TCHAR>>::Create(&OutputString);
        // Call the writeJSON function to serialize the FItemInstance into JSON
        Item.writeJSON(JsonWriter);
        // Close the writer to flush the contents to the string
        JsonWriter->Close();
        // Create a UPlayFabJsonObject
        UPlayFabJsonObject* JsonObject = NewObject<UPlayFabJsonObject>();
        // Convert the string into a UPlayFabJsonObject
        JsonObject->DecodeJson(OutputString);
        // Add the JsonObject to the array
        Inventory.Add(JsonObject);
    }
    return Inventory;
}

GetProfilePicturesDT()

virtual UDataTable * UEpicOnlineGameInstance::GetProfilePicturesDT ( ) const

inlineoverridevirtual

Implements IMenuSystem.

{return ProfilePicturesDT;};

GetSaveInfoFromSlot()

virtual FUserSaveGame UEpicOnlineGameInstance::GetSaveInfoFromSlot ( const int32 Slot )

inlineoverridevirtual

Implements IMenuSystem.

{return FUserSaveGame();};

GetSelectedLevel()

FGameLevel UEpicOnlineGameInstance::GetSelectedLevel ( const EGameplayMode GameMode ) const

overridevirtual

Implements ILevelSelectInterface.

{
    switch(GameMode)
    {
    case EGameplayMode::Campaign:
        return SelectedCampaignLevel;
    case EGameplayMode::Horde:
        return SelectedHordeLevel;
    case EGameplayMode::Debug:
        return SelectedDebugLevel;
    case EGameplayMode::Multiplayer:
    default:
        return SelectedMultiplayerLevel;
    }
}

GetStats()

void UEpicOnlineGameInstance::GetStats ( TArray< FString > StatName )

virtual

{
    if(GetOnlineIdentity() != nullptr)
    {
        const IOnlineStatsPtr StatsPointer = OnlineSubsystem->GetStatsInterface();
        if(StatsPointer != nullptr)
        {
            TArray<TSharedRef<const FUniqueNetId>> UserVar;
            UserVar.Add(GetOnlineIdentity()->GetUniquePlayerId(0).ToSharedRef());
            StatsPointer->QueryStats(GetOnlineIdentity()->GetUniquePlayerId(0).ToSharedRef(), UserVar, StatName, FOnlineStatsQueryUsersStatsComplete::CreateUObject(this, &UEpicOnlineGameInstance::OnGetStatsComplete));
        }
    }
}

Host()

void UEpicOnlineGameInstance::Host ( FOnlineSessionSettings HostSessionSettings )

overridevirtual

Implements IMenuSystem.

Reimplemented in UMenuSystemGameInstance.

{
    
}

Init()

void UEpicOnlineGameInstance::Init ( )

overridevirtual

Reimplemented in UMenuSystemGameInstance.

{
    Super::Init();
    OnlineSubsystem = IOnlineSubsystem::Get();
    if(OnlineSubsystem != nullptr)
    {
        if(bDebuggingMode){UE_LOG(LogOnlineGameInstance,Warning,TEXT("Found Subsystem %s"), *OnlineSubsystem->GetSubsystemName().ToString());}
        OnlineSessionPtr = OnlineSubsystem->GetSessionInterface();
        if(OnlineSessionPtr != nullptr)
        {
            if(bDebuggingMode){UE_LOG(LogOnlineGameInstance,Warning,TEXT("Found Online Session Pointer"));}
            // OnlineSessionPtr->OnFindSessionsCompleteDelegates.AddUObject(this, &UEpicOnlineGameInstance::OnFindSessionListCompleted);
            OnlineSessionPtr->OnDestroySessionCompleteDelegates.AddUObject(this, &UEpicOnlineGameInstance::OnDestroySessionCompleted);
            SetPlayerProfileName();
        }
        else{UE_LOG(LogOnlineGameInstance,Error,TEXT("Online Session Pointer FAILED"));;}
    }
    else
    {
        UE_LOG(LogOnlineGameInstance,Error,TEXT("Subsystem FAILED"));
    }
    if(GEngine != nullptr)
    {
        GEngine->OnNetworkFailure().AddUObject(this, &UEpicOnlineGameInstance::OnNetworkFailure);
    }
    if(LevelDataTable == nullptr)
    {
        if(bDebuggingMode){UE_LOG(LogOnlineGameInstance,Error,TEXT("Level Data Table Null in GameInstance"));}
    }
    //- Set Default Selected Levels //
    if(GetWorld() != nullptr)
    {
        SelectedCampaignLevel = UMenuBPLib::GetDefaultLevel(GetWorld(), EGameplayMode::Campaign);
        SelectedMultiplayerLevel = UMenuBPLib::GetDefaultLevel(GetWorld(), EGameplayMode::Multiplayer);
        SelectedHordeLevel = UMenuBPLib::GetDefaultLevel(GetWorld(), EGameplayMode::Horde);
        SelectedDebugLevel = UMenuBPLib::GetDefaultLevel(GetWorld(), EGameplayMode::Debug);
    }
 
    //TEST Activement on STEAM 
    UpdateStats("stat_beta_played", 1);
    
    //-     Replay System   //
    // create a ReplayStreamer for FindReplays() and DeleteReplay(..)
    EnumerateStreamsPtr = FNetworkReplayStreaming::Get().GetFactory().CreateReplayStreamer();
    OnEnumerateStreamsCompleteDelegate = FEnumerateStreamsCallback::CreateUObject(this, &UEpicOnlineGameInstance::OnEnumerateStreamsComplete);
    OnDeleteFinishedStreamCompleteDelegate = FDeleteFinishedStreamCallback::CreateUObject(this, &UEpicOnlineGameInstance::OnDeleteFinishedStreamComplete);
    OnRenameReplayCompleteDelegate = FRenameReplayCallback::CreateUObject(this, &UEpicOnlineGameInstance::OnReplayRenameFinishedComplete);
    if(bAutoLoginToPlayFab)
    {
        LoginToPlayFab();
    }
}

Join()

void UEpicOnlineGameInstance::Join ( uint32 Index )

overridevirtual

Implements IMenuSystem.

Reimplemented in UMenuSystemGameInstance.

{
    if(!OnlineSessionPtr.IsValid()) return;
    if(!OnlineSessionSearch.IsValid()) return;
    OnlineSessionPtr->OnJoinSessionCompleteDelegates.AddUObject(this, &UEpicOnlineGameInstance::OnJoinSessionCompleted);
    OnlineSessionPtr->JoinSession(0, SESSION_NAME, OnlineSessionSearch->SearchResults[Index]);
}

JoinManualAddress()

void UEpicOnlineGameInstance::JoinManualAddress ( const FString & IpAddress )

overridevirtual

Implements IMenuSystem.

Reimplemented in UMenuSystemGameInstance.

{
}

LaunchInGameMenu()

void UEpicOnlineGameInstance::LaunchInGameMenu ( APlayerController * Player, const bool bOpen = true )

overridevirtual

Implements IMenuSystem.

Reimplemented in UMenuSystemGameInstance.

{
    if(Player == nullptr){UE_LOG(LogOnlineGameInstance,Warning,TEXT("Player Controller NULL in Launch In Game Menu"));return;}
    if(InGameMenuClass == nullptr){return;}
    if(!Player->IsLocalController()){return;}
    //-     Create Widget   //
    if(InGameMenuWidget == nullptr || !InGameMenuWidget->IsInViewport())
    {
        InGameMenuWidget = CreateWidget<UInGameMenuSystemWidget>(Player, InGameMenuClass);
        if(InGameMenuWidget == nullptr){UE_LOG(LogOnlineGameInstance,Warning,TEXT("InGameMenuWidget NULL in Launch In Game Menu")); return;}
        //@TODO Check if Local Player works 
        InGameMenuWidget->SetOwningLocalPlayer(Player->GetLocalPlayer());
        InGameMenuWidget->AddToViewport();
    }
    if(bInGameMenuOpen || !bOpen)
    {
        if(bOptionsMenuOpen)
        {
            LaunchOptionsMenu(Player, InGameMenuWidget, false);
            return;
        }
        InGameMenuWidget->SetOwningLocalPlayer(Player->GetLocalPlayer());
        InGameMenuWidget->DeactivateWidget();
        InGameMenuWidget->SetVisibility(ESlateVisibility::Collapsed);
        const FInputModeGameOnly InputMode;
        Player->SetInputMode(InputMode);
        Player->bShowMouseCursor = false;
        bInGameMenuOpen = false;
    }
    else
    {
        InGameMenuWidget->SetOwningLocalPlayer(Player->GetLocalPlayer());
        InGameMenuWidget->SetVisibility(ESlateVisibility::Visible);
        InGameMenuWidget->ActivateWidget();
        const FInputModeGameAndUI InputMode;
        Player->SetInputMode(InputMode);
        Player->bShowMouseCursor = true;
        bInGameMenuOpen = true;
    }
    if(!GetIsPublicMatch() || !GetIsPlayerLoggedIn() || GetOnlineSubsystem() == EOnlineSubsystem::Null)
    {
        const bool bGamePaused = UGameplayStatics::IsGamePaused(Player);
        UGameplayStatics::SetGamePaused(Player, !bGamePaused);
    }
    //@bug Doesn't work 
    if(InGameMenuWidget != nullptr)
    {
        InGameMenuWidget->SetOwningLocalPlayer(Player->GetLocalPlayer());
    }
}

LaunchOptionsMenu()

void UEpicOnlineGameInstance::LaunchOptionsMenu ( APlayerController * Player, UUserWidget * CurrentWidget = nullptr, const bool bOpen = true )

overridevirtual

Implements IMenuSystem.

{
    if(Player == nullptr){UE_LOG(LogOnlineGameInstance,Warning,TEXT("Player Controller NULL in UEpicOnlineGameInstance::LaunchOptionsMenu"));return;}
    if(OptionsMenuClass == nullptr){return;}
    if(!Player->IsLocalController()){return;}
    //-     Create Widget   //
    if(OptionsMenuWidget == nullptr || !OptionsMenuWidget->IsInViewport())
    {
        OptionsMenuWidget = CreateWidget<UOptionsMenuSystemWidget>(Player, OptionsMenuClass);
        if(OptionsMenuWidget == nullptr){UE_LOG(LogOnlineGameInstance,Warning,TEXT("Options Menu NULL in UEpicOnlineGameInstance::LaunchOptionsMenu")); return;}
        OptionsMenuWidget->AddToViewport();
    }
    if(CurrentWidget != nullptr && bOpen)
    {
        OptionsMenuWidget->SetOwnerWidget(CurrentWidget);
    }
    if(bOptionsMenuOpen || !bOpen)
    {
        UCommonActivatableWidget* CurrentActivatable = Cast<UCommonActivatableWidget>(CurrentWidget);
        if(CurrentActivatable != nullptr)
        {
            CurrentActivatable->SetVisibility(ESlateVisibility::Visible);
            CurrentActivatable->ActivateWidget();
        }
        OptionsMenuWidget->DeactivateWidget();
        OptionsMenuWidget->SetVisibility(ESlateVisibility::Collapsed);
        bOptionsMenuOpen = false;
    }
    else
    {
        UCommonActivatableWidget* CurrentActivatable = Cast<UCommonActivatableWidget>(CurrentWidget);
        if(CurrentActivatable != nullptr)
        {
            CurrentActivatable->DeactivateWidget();
            CurrentActivatable->SetVisibility(ESlateVisibility::Collapsed);
        }
        OptionsMenuWidget->SetVisibility(ESlateVisibility::Visible);
        OptionsMenuWidget->ActivateWidget();
        bOptionsMenuOpen = true;
    }
    //@bug Doesn't work 
    if(OptionsMenuWidget != nullptr)
    {
        OptionsMenuWidget->SetOwningPlayer(Player);
    }
}

LoadMenu()

void UEpicOnlineGameInstance::LoadMenu ( )

overridevirtual

Implements IMenuSystem.

Reimplemented in UMenuSystemGameInstance.

{
    if (!ensure(MenuClass != nullptr)) return;
    MainMenu = CreateWidget<UMenuSystemWidget>(GetFirstLocalPlayerController(), MenuClass);
    if (!ensure(MainMenu != nullptr)) return;
    MainMenu->Setup();
    MainMenu->SetMenuInterface(this);
    //@TODO ADd Dynamic for, Playfab Login, Player Loaded, etc.
    //? Add dynamic to Menu Class
    OnServersFoundChanged.AddDynamic(MainMenu, &UMenuSystemWidget::SetServerList);
}

LoadOfflinePlayerProfile()

bool UEpicOnlineGameInstance::LoadOfflinePlayerProfile ( FUserProfile & OfflineProfile )

overridevirtual

Implements IMenuSystem.

{
    if(GetFirstLocalPlayerController() == nullptr){UE_LOG(LogOnlineGameInstance, Error, TEXT("Load OFFLINE Controller ERROR"));return false;}
    const FString SlotName = GetSaveInfoFromSlot(CurrentSaveSlot).Name;
    if(UGameplayStatics::DoesSaveGameExist(SlotName, 0))
    {
        USaveGame* LoadedSaveGame = UGameplayStatics::LoadGameFromSlot(SlotName, 0);
        const UPlayerProfileSaveGame* LoadedPlayerSaveGame = Cast<UPlayerProfileSaveGame>(LoadedSaveGame);
        if(LoadedPlayerSaveGame != nullptr)
        {
            //@ TODO Check for alterations  //
            //- Check Online profile vs fetched online profile  .
            
            //- Add Any other extras that have been saved   //
            OfflinePlayerProfile = LoadedPlayerSaveGame->OfflineProfile;
            // OnlinePlayerProfile = LoadedPlayerSaveGame->OnlineProfile;
            SetDifficultyLevel(LoadedPlayerSaveGame->DifficultyLevel);
            SetPlayerProfileName();
            OfflineProfile = OfflinePlayerProfile;
            if(bDebuggingMode){UE_LOG(LogOnlineGameInstance, Warning, TEXT("Loaded Offline Profile Save Game Into Player State"));}
            return true;
            // IOnlinePlayerState* OnlinePlayer = Cast<IOnlinePlayerState>(GetFirstLocalPlayerController()->PlayerState);
            // if(OnlinePlayer != nullptr)
            // {
            //  OnlinePlayer->SetUserProfile(OfflinePlayerProfile);
            //  if(bDebuggingMode){UE_LOG(LogOnlineGameInstance, Warning, TEXT("Loaded Offline Profile Save Game Into Player State"));}
            //  return true;
            // }
        }
    }
    else
    {
        //- No Save Game    //
        if(bDebuggingMode){UE_LOG(LogOnlineGameInstance, Error, TEXT("No Save File Exists"));}
        return false;
    }
    if(bDebuggingMode){UE_LOG(LogOnlineGameInstance, Error, TEXT("LOAD OFFLINE PROFILE ERROR"));}
    return false;
}

LoginToEpicOnline()

void UEpicOnlineGameInstance::LoginToEpicOnline ( FString ID = "", FString Token = "", FString LoginType = "accountportal" )

overridevirtual

Implements IMenuSystem.

{
    if(GetOnlineIdentity() != nullptr)
    {
        FOnlineAccountCredentials AccountDetails;
        AccountDetails.Id = ID;
        AccountDetails.Token = Token;
        AccountDetails.Type = LoginType;
        GetOnlineIdentity()->OnLoginCompleteDelegates->AddUObject(this, &UEpicOnlineGameInstance::OnLoginEOSCompleted);
        GetOnlineIdentity()->Login(0, AccountDetails);
    }
}

LoginToPlayFab()

void UEpicOnlineGameInstance::LoginToPlayFab ( )

overridevirtual

Implements IPlayFabMenu.

{
    ClientAPI = IPlayFabModuleInterface::Get().GetClientAPI();
    if(ClientAPI == nullptr){return;}
    PlayFab::ClientModels::FLoginWithSteamRequest Request;
    Request.CreateAccount = true;
    Request.SteamTicket = GetAuthToken();
    ClientAPI->LoginWithSteam(Request,
        PlayFab::UPlayFabClientAPI::FLoginWithSteamDelegate::CreateUObject(this, &UEpicOnlineGameInstance::OnPlayFabLoginSuccess),
        PlayFab::FPlayFabErrorDelegate::CreateUObject(this, &UEpicOnlineGameInstance::OnPlayFabError)
    );
}

Logout()

void UEpicOnlineGameInstance::Logout ( ) const

overridevirtual

Implements IMenuSystem.

{
    if(!GetIsPlayerLoggedIn()){if(bDebuggingMode){UE_LOG(LogOnlineGameInstance, Warning, TEXT("Player Already Logged out"));}return;}
    if(OnlineSubsystem != nullptr)
    {
        const IOnlineIdentityPtr OnlineIdentity = OnlineSubsystem->GetIdentityInterface();
        if(OnlineIdentity != nullptr)
        {
            OnlineIdentity->OnLogoutCompleteDelegates->AddUObject(this, &UEpicOnlineGameInstance::OnLogoutComplete);
            OnlineIdentity->Logout(0);
        }
    }
}

OnCreateSessionCompleted()

void UEpicOnlineGameInstance::OnCreateSessionCompleted ( FName SessionName, bool bSuccess ) const

protected

{
    if(bDebuggingMode){UE_LOG(LogOnlineGameInstance,Warning,TEXT("Session Name: %s"), *SessionName.ToString());}
    if(bSuccess)
    {
        GetWorld()->ServerTravel(LobbyLevelText);
    }
    else
    {
        UE_LOG(LogOnlineGameInstance,Error,TEXT("Failed to create session"));
    }
}

OnDeleteFinishedStreamComplete()

void UEpicOnlineGameInstance::OnDeleteFinishedStreamComplete ( const FDeleteFinishedStreamResult & Result )

private

{
    FindReplays();
}

OnDestroySessionCompleted()

void UEpicOnlineGameInstance::OnDestroySessionCompleted ( FName SessionName, bool bSuccess ) const

protected

{
    if(bSuccess)
    {
        if(bDebuggingMode){UE_LOG(LogOnlineGameInstance,Warning,TEXT("%s Session Destroyed"), *SessionName.ToString());}
    }
    else{UE_LOG(LogOnlineGameInstance,Error,TEXT("%s Session FAILED to destroy"), *SessionName.ToString());}
}

OnEnumerateStreamsComplete()

void UEpicOnlineGameInstance::OnEnumerateStreamsComplete ( const FEnumerateStreamsResult & Result ) const

private

{
    TArray<FReplayInfo> AllReplays;  
    for (const FNetworkReplayStreamInfo& StreamInfo : Result.FoundStreams)  
    {
        if(!StreamInfo.bIsLive)  
        {  
            AllReplays.Add(FReplayInfo(StreamInfo.Name, StreamInfo.FriendlyName, StreamInfo.Timestamp, StreamInfo.LengthInMS, StreamInfo.SizeInBytes));  
        }  
    }  
    OnFindReplaysComplete.Broadcast(AllReplays);  
}

OnFindSessionCompleted()

void UEpicOnlineGameInstance::OnFindSessionCompleted ( bool bSuccess )

protected

{
    if(OnlineSessionPtr != nullptr)
    {
        OnlineSessionPtr->OnFindSessionsCompleteDelegates.RemoveAll(this);
    }
    if(bSuccess)
    {
        if(OnlineSessionPtr == nullptr){UE_LOG(LogOnlineGameInstance, Error, TEXT("Online Session PTR FAILED, create EOS session"));return;}
        OnlineSessionPtr->OnJoinSessionCompleteDelegates.AddUObject(this, &UEpicOnlineGameInstance::OnJoinSessionCompleted);
        if(OnlineSessionSearch->SearchResults.IsValidIndex(0))
        {
            OnlineSessionPtr->JoinSession(0, SESSION_NAME, OnlineSessionSearch->SearchResults[0]);
            return;
        }
    }
    if(MainMenu != nullptr)
    {
        const FModalData QuickMatchModal = FModalData(EMenuSystemModalAlert::General, EMenuSystemModalType::Popup1, "Search Complete", "No Matches Found", "", "Close");
        MainMenu->OpenConfirmationMessage(QuickMatchModal);
    }
}

OnFindSessionListCompleted()

void UEpicOnlineGameInstance::OnFindSessionListCompleted ( bool bSuccess ) const

protected

Remove Delegate

{
    if(OnlineSessionPtr != nullptr)
    {
        OnlineSessionPtr->OnFindSessionsCompleteDelegates.RemoveAll(this);
    }
    if(bSuccess && OnlineSessionSearch.IsValid())
    {
        if(bDebuggingMode){UE_LOG(LogOnlineGameInstance,Warning, TEXT("Find Session Complete"));}
        TArray<FServerRow> ServerInfo;
        FServerRow TestData;
        for(const FOnlineSessionSearchResult& It : OnlineSessionSearch->SearchResults)
        {
            FServerRow ServerData;
            ServerData.MaxPlayers = It.Session.SessionSettings.NumPublicConnections;
            ServerData.CurrentPlayers = (ServerData.MaxPlayers - It.Session.NumOpenPublicConnections);
            ServerData.HostUsername = It.Session.OwningUserName;
            ServerData.Ping = It.PingInMs;
            ServerData.ServerName = It.GetSessionIdStr();
            FString ServerName;
            if(It.Session.SessionSettings.Get(SERVER_NAME_KEY, ServerName))
            {
                ServerData.ServerName = ServerName;
            }
            // else
            // {
            //  ServerData.ServerName = "Error in Server Name";
            // }
            if(bDebuggingMode){UE_LOG(LogOnlineGameInstance,Warning, TEXT("Session Found: %s"), *ServerData.ServerName);}
            ServerInfo.Add(ServerData);
        }
        if(MainMenu != nullptr)
        {
            if(OnlineSessionSearch->SearchResults.IsEmpty())
            {
                const FModalData NoServersModal = FModalData(EMenuSystemModalAlert::General, EMenuSystemModalType::Popup1, "Search Complete", "No Servers Found", "", "Close");
                MainMenu->OpenConfirmationMessage(NoServersModal);
                if(bDebuggingMode){UE_LOG(LogOnlineGameInstance, Warning, TEXT("No Servers Found"));}
            }
            MainMenu->SetServerList(ServerInfo);
        }
        // OnServersFoundChanged.Broadcast(ServerInfo);
    }
    else
    {
        if(bDebuggingMode){UE_LOG(LogOnlineGameInstance,Warning, TEXT("Find Session Failed"));}
    }
}

OnGetStatsComplete()

void UEpicOnlineGameInstance::OnGetStatsComplete ( const FOnlineError & Result, const TArray< TSharedRef< const FOnlineStatsUserStats > > & UserStats )

protected

{
    if(Result.WasSuccessful())
    {
        for(const auto StatsVar : UserStats)
        {
            for(auto StoredValueRef : StatsVar->Stats)
            {
                const FString KeyName = StoredValueRef.Key;
                int32 Value;
                StoredValueRef.Value.GetValue(Value);
                if(bDebuggingMode){UE_LOG(LogOnlineGameInstance, Warning, TEXT("Stat with name %s is %i"), *KeyName, Value);}
            }
        }
    }
    else
    {
        UE_LOG(LogOnlineGameInstance, Error, TEXT("Get Stats Failed"));
    }
}

OnGetUserFileComplete()

void UEpicOnlineGameInstance::OnGetUserFileComplete ( bool bSuccess, const FUniqueNetId & UserID, const FString & FileName ) const

protected

{
    if(bSuccess)
    {
        if(bDebuggingMode){UE_LOG(LogOnlineGameInstance, Warning, TEXT("On Read File Success"));}
        ReadPlayerData(FileName);
    }
    else{UE_LOG(LogOnlineGameInstance, Warning, TEXT("On Read File Failed"));}
}

OnJoinSessionCompleted()

void UEpicOnlineGameInstance::OnJoinSessionCompleted ( FName SessionName, EOnJoinSessionCompleteResult::Type Result ) const

protected

{
    if(Result == EOnJoinSessionCompleteResult::Success)
    {
        if(OnlineSessionPtr == nullptr){UE_LOG(LogOnlineGameInstance, Error, TEXT("Online Session PTR FAILED, create EOS session"));return;}
        if(APlayerController* PlayerController = GetFirstLocalPlayerController())
        {
            FString JoinAddress;
            OnlineSessionPtr->GetResolvedConnectString(SESSION_NAME, JoinAddress);
            if(bDebuggingMode){UE_LOG(LogOnlineGameInstance,Warning,TEXT("Join Address: %s"), *JoinAddress);}
            if(!JoinAddress.IsEmpty())
            {
                PlayerController->ClientTravel(JoinAddress, ETravelType::TRAVEL_Absolute);
            }
        }
    }
}

OnLoginEOSCompleted()

void UEpicOnlineGameInstance::OnLoginEOSCompleted ( int32 LocalUserNum, bool bSuccess, const FUniqueNetId & UserID, const FString & Error ) const

protected

{
    if(bDebuggingMode)
    {
        if(bSuccess){UE_LOG(LogOnlineGameInstance, Warning, TEXT("Login Success - UserID - %s"), *UserID.ToString());}
        else{UE_LOG(LogOnlineGameInstance, Error, TEXT("Login Failed - %s"), *Error);}      
    }
}

OnLogoutComplete()

void UEpicOnlineGameInstance::OnLogoutComplete ( const int32 ResultCode, const bool bSuccess ) const

protected

{
    if(bSuccess)
    {
        if(bDebuggingMode){UE_LOG(LogOnlineGameInstance, Warning, TEXT("Logout Success"));}
    }
    else
    {
        UE_LOG(LogOnlineGameInstance, Error, TEXT("Logout Failed, Result Code: %i"), ResultCode);
    }
}

OnNetworkFailure()

void UEpicOnlineGameInstance::OnNetworkFailure ( UWorld * World, UNetDriver * NewDriver, ENetworkFailure::Type FailureType, const FString & ErrorString )

privatevirtual

{
    FString ErrorType = "Connection Lost ";
    switch (FailureType)
    {
    case (ENetworkFailure::ConnectionLost):
        ErrorType = "Connection Lost ";
        break;
    case (ENetworkFailure::ConnectionTimeout):
        ErrorType = "Connection Timeout ";
        break;
    case (ENetworkFailure::FailureReceived):
        ErrorType = "Failure Received ";
        break;
    case (ENetworkFailure::OutdatedClient):
        ErrorType = "Outdated Client ";
        break;
    case (ENetworkFailure::OutdatedServer):
        ErrorType = "Outdated Server ";
        break;
    case (ENetworkFailure::NetChecksumMismatch):
        ErrorType = "Net Checksum Mismatch ";
        break;
    case (ENetworkFailure::NetGuidMismatch):
        ErrorType = "Net Guid Mismatch ";
        break;
    case (ENetworkFailure::PendingConnectionFailure):
        ErrorType = "Pending Connection Failure ";
        break;
    case (ENetworkFailure::NetDriverAlreadyExists):
        ErrorType = "Net Driver Already Exists ";
        break;
    case (ENetworkFailure::NetDriverCreateFailure):
        ErrorType = "Net Driver Create Failure ";
        break;
    case (ENetworkFailure::NetDriverListenFailure):
        ErrorType = "Net Driver Listen Failure ";
        break;
    default:
        ErrorType = "Unknown Error ";
        break;
    }
    if(bDebuggingMode){UE_LOG(LogOnlineGameInstance,Error,TEXT("%s %s "), *ErrorType, *ErrorString);}
    if(MainMenu != nullptr)
    {
        const FModalData NetworkModal = FModalData(EMenuSystemModalAlert::Error, EMenuSystemModalType::Popup1, "Network Error", (ErrorType + ErrorString), "", "Close"); 
        MainMenu->OpenConfirmationMessage(NetworkModal);
    }
}

OnPlayFabDisplayChangedSuccess()

void UEpicOnlineGameInstance::OnPlayFabDisplayChangedSuccess ( const PlayFab::AdminModels::FUpdateUserTitleDisplayNameResult & Result )

private

{
    UE_LOG(LogOnlineGameInstance, Warning, TEXT("Display Name Changed To: %s!"), *Result.DisplayName);
}

OnPlayFabError()

void UEpicOnlineGameInstance::OnPlayFabError ( const PlayFab::FPlayFabCppError & ErrorResult )

private

{
    UE_LOG(LogTemp, Error, TEXT("Something went wrong with your first API call.\nHere's some debug information:\n%s"), *ErrorResult.GenerateErrorReport());
}

OnPlayFabLGetInventorySuccess()

void UEpicOnlineGameInstance::OnPlayFabLGetInventorySuccess ( const PlayFab::ClientModels::FGetUserInventoryResult & Result )

private

{
    const int32* CurrencyPtr = Result.VirtualCurrency.Find(CurrencyCode);
    PlayFabInventory = Result.Inventory;
    if(CurrencyPtr == nullptr){UE_LOG(LogOnlineGameInstance, Error, TEXT("Currency NOT FOUND"));return;}
    PlayFabCurrency = *CurrencyPtr;
    if(bDebuggingMode){UE_LOG(LogOnlineGameInstance, Warning, TEXT("Currency: %.2f!"), PlayFabCurrency);}
}

OnPlayFabLoginSuccess()

void UEpicOnlineGameInstance::OnPlayFabLoginSuccess ( const PlayFab::ClientModels::FLoginResult & Result )

private

{
    if(bDebuggingMode){UE_LOG(LogOnlineGameInstance, Warning, TEXT("Congratulations, you made your first successful API call!"));}
    PlayFabID = Result.PlayFabId;
    if(bDebuggingMode){UE_LOG(LogOnlineGameInstance, Warning, TEXT("PlayFab ID: %s"), *PlayFabID);}
    if(Result.NewlyCreated)
    {
        UE_LOG(LogTemp, Warning, TEXT("New Account Created!"));
        SetPlayFabDisplayName();
    }
    PlayFab::ClientModels::FGetUserInventoryRequest Request;
    ClientAPI->GetUserInventory(Request, PlayFab::UPlayFabClientAPI::FGetUserInventoryDelegate::CreateUObject(this, &UEpicOnlineGameInstance::OnPlayFabLGetInventorySuccess),
        PlayFab::FPlayFabErrorDelegate::CreateUObject(this, &UEpicOnlineGameInstance::OnPlayFabError));
}

OnReplayRenameFinishedComplete()

void UEpicOnlineGameInstance::OnReplayRenameFinishedComplete ( const FRenameReplayResult & Result )

private

{
    if(Result.WasSuccessful())
    {
        if(bDebuggingMode){UE_LOG(LogOnlineGameInstance,Warning, TEXT("Replay Renamed Successfully"));}
    }
    FindReplays();
}

OnUpdateStatsComplete()

void UEpicOnlineGameInstance::OnUpdateStatsComplete ( const FOnlineError & Result ) const

protected

{
    if(Result == FOnlineError::Success())
    {
        if(bDebuggingMode){UE_LOG(LogOnlineGameInstance, Warning, TEXT("Update Stats Success"));}
    }
    else
    {
        UE_LOG(LogOnlineGameInstance, Error, TEXT("Update Stats Failed"));
    }
}

OnWriteUserFileComplete()

void UEpicOnlineGameInstance::OnWriteUserFileComplete ( bool bSuccess, const FUniqueNetId & UserID, const FString & FileName ) const

protected

{
    if(bSuccess)
    {
        if(bDebuggingMode){UE_LOG(LogOnlineGameInstance,Warning,TEXT("Uploading File Success %s"), *FileName);}
    }
    else{UE_LOG(LogOnlineGameInstance, Warning, TEXT("Uploading Failed"));}
}

OpenReplayMenu()

bool UEpicOnlineGameInstance::OpenReplayMenu ( APlayerController * Player, const bool bOpen = true )

overrideprotectedvirtual

Implements IReplayClipInterface.

{
    if(Player == nullptr){UE_LOG(LogOnlineGameInstance,Warning,TEXT("Player Controller NULL in OpenReplayMenu"));return false;}
    if(ReplayMenuClass == nullptr){return false;}
    if(!Player->IsLocalController()){return false;}
    //-     Create Widget   //
    if(ReplayMenu == nullptr || !ReplayMenu->IsInViewport())
    {
        ReplayMenu = CreateWidget<UReplayMenu>(Player, ReplayMenuClass);
        if(ReplayMenu == nullptr){UE_LOG(LogOnlineGameInstance,Warning,TEXT("ReplayMenu NULL OpenReplayMenu")); return false;}
        OnFindReplaysComplete.AddUniqueDynamic(ReplayMenu, &UReplayMenu::OnFindReplays);
        ReplayMenu->AddToViewport();
        FindReplays();
    }
    if(!bOpen)
    {
        ReplayMenu->SetVisibility(ESlateVisibility::Collapsed);
        return false;
    }
    
    ReplayMenu->SetVisibility(ESlateVisibility::Visible);
    const FInputModeGameAndUI InputMode;
    Player->SetInputMode(InputMode);
    Player->bShowMouseCursor = true;
    return true;
}

Options()

void UEpicOnlineGameInstance::Options ( )

overridevirtual

Implements IMenuSystem.

Reimplemented in UMenuSystemGameInstance.

{
}

PlayReplayFromBP()

void UEpicOnlineGameInstance::PlayReplayFromBP ( FString ReplayName )

overrideprotectedvirtual

Start playback for a previously recorded Replay, from blueprint

Implements IReplayClipInterface.

{
    PlayReplay(ReplayName);
}

Quit()

void UEpicOnlineGameInstance::Quit ( APlayerController * Player )

overridevirtual

Implements IMenuSystem.

Reimplemented in UMenuSystemGameInstance.

{
    if (!ensure(Player != nullptr)) return;
    UKismetSystemLibrary::QuitGame(GetWorld(), Player, EQuitPreference::Quit, false);
}

ReadPlayerData()

void UEpicOnlineGameInstance::ReadPlayerData

(

const FString &

FileName

)

const

{
    if(GetOnlineIdentity() != nullptr)
    {
        const IOnlineUserCloudPtr UserCloud = OnlineSubsystem->GetUserCloudInterface();
        if(UserCloud != nullptr)
        {
            const TSharedPtr<const FUniqueNetId> UserID = GetOnlineIdentity()->GetUniquePlayerId(0).ToSharedRef();
            TArray<uint8> UserData;
            UserCloud->GetFileContents(*UserID, FileName, UserData);
            OnFileDataFound.Broadcast(FileName, UserData);
        }
    }
}

RenameReplay()

void UEpicOnlineGameInstance::RenameReplay ( const FString & ReplayName, const FString & NewFriendlyReplayName )

overrideprotectedvirtual

Apply a new custom name to the replay (for UI only)

Implements IReplayClipInterface.

{
    if(EnumerateStreamsPtr.Get() != nullptr)
    {
        EnumerateStreamsPtr.Get()->RenameReplayFriendlyName(ReplayName, NewFriendlyReplayName, OnRenameReplayCompleteDelegate);
    }
}

RestartLevel()

void UEpicOnlineGameInstance::RestartLevel ( ) const

virtual

Implements IMenuSystem.

{
    if(GetWorld() == nullptr){if(bDebuggingMode){UE_LOG(LogOnlineGameInstance, Error, TEXT("GetWorld Failed UEpicOnlineGameInstance::RestartLevel"));}return;}
    const FName LevelName = FName(UGameplayStatics::GetCurrentLevelName(this));
    UGameplayStatics::OpenLevel(GetWorld(), LevelName);
}

ReturnToMainMenu()

void UEpicOnlineGameInstance::ReturnToMainMenu ( )

overrideprotectedvirtual

{
    Super::ReturnToMainMenu();
    //-@ TODO Extract this to function, RemoveSplitscreenPlayers() 
    const int MaxSplitScreenPlayers = 4;
    ULocalPlayer* PlayersToRemove[MaxSplitScreenPlayers];
    int RemIndex = 0;
 
    for (FConstPlayerControllerIterator Iterator = GEngine->GameViewport->GetWorld()->GetPlayerControllerIterator(); Iterator; ++Iterator)
    {
        // Remove only local split screen players
        const TWeakObjectPtr<APlayerController> Controller = *Iterator;
        if (Controller.Get() && Controller->IsLocalController() && !Controller->IsPrimaryPlayer())
        {
            
            ULocalPlayer* ExPlayer = Cast<ULocalPlayer>(Controller->Player);
            if (ExPlayer)
            {
                PlayersToRemove[RemIndex++] = ExPlayer;
                Controller->PawnPendingDestroy(Controller->GetPawn());
            }
        }
    }
    for (int i = 0; i < RemIndex; ++i)
    {
        RemoveLocalPlayer(PlayersToRemove[i]);
    }
    //- 
    bInGameMenuOpen = false;
    bOptionsMenuOpen = false;
}

SaveOfflinePlayerProfile()

bool UEpicOnlineGameInstance::SaveOfflinePlayerProfile ( )

overridevirtual

Implements IMenuSystem.

{
    //- TODO Slot 
    if(GetFirstLocalPlayerController() == nullptr){UE_LOG(LogOnlineGameInstance, Error, TEXT("Save OFFLINE Controller ERROR"));return false;}
    const IOnlinePlayerState* OnlinePlayer = Cast<IOnlinePlayerState>(GetFirstLocalPlayerController()->PlayerState);
    if(OnlinePlayer != nullptr)
    {
        if(bDebuggingMode){UE_LOG(LogOnlineGameInstance, Warning, TEXT("Got Player State From Controller"));}
        OfflinePlayerProfile = OnlinePlayer->GetUserProfile();
    }
    //- TODO Check this actually gets something 
    const FString SlotName = GetSaveInfoFromSlot(CurrentSaveSlot).Name;
    if(UGameplayStatics::DoesSaveGameExist(SlotName, 0))
    {
        USaveGame* LoadedSaveGame = UGameplayStatics::LoadGameFromSlot(SlotName, 0);
        UPlayerProfileSaveGame* LoadedPlayerSaveGame = Cast<UPlayerProfileSaveGame>(LoadedSaveGame);
        if(LoadedPlayerSaveGame != nullptr)
        {
            LoadedPlayerSaveGame->OfflineProfile = OfflinePlayerProfile;
            // LoadedPlayerSaveGame->OnlineProfile = OnlinePlayerProfile;
            LoadedPlayerSaveGame->DifficultyLevel = GetDifficultyLevel();
            if(bDebuggingMode){UE_LOG(LogOnlineGameInstance, Warning, TEXT("Saved Offline Profile Save Game"));}
            return UGameplayStatics::SaveGameToSlot(LoadedPlayerSaveGame, SlotName, 0);
        }
    }
    else
    {
        USaveGame* NewSaveGame = UGameplayStatics::CreateSaveGameObject(UPlayerProfileSaveGame::StaticClass());
        UPlayerProfileSaveGame* NewOfflineProfileSaveGame = Cast<UPlayerProfileSaveGame>(NewSaveGame);
        if(NewOfflineProfileSaveGame != nullptr)
        {
            NewOfflineProfileSaveGame->OfflineProfile = OfflinePlayerProfile;
            // NewOfflineProfileSaveGame->OnlineProfile = OnlinePlayerProfile;
            NewOfflineProfileSaveGame->DifficultyLevel = GetDifficultyLevel();
            if(bDebuggingMode){UE_LOG(LogOnlineGameInstance, Warning, TEXT("Created New Offline Profile Save Game"));}
            return UGameplayStatics::SaveGameToSlot(NewOfflineProfileSaveGame, SlotName, 0);
        }
    }
    if(bDebuggingMode){UE_LOG(LogOnlineGameInstance, Error, TEXT("Save OFFLINE PROFILE ERROR"));}
    return false;
}

SearchServers()

void UEpicOnlineGameInstance::SearchServers ( )

overridevirtual

Implements IMenuSystem.

Reimplemented in UMenuSystemGameInstance.

{
    if(OnlineSessionPtr == nullptr){UE_LOG(LogOnlineGameInstance, Error, TEXT("Online Session PTR FAILED, SearchServers"));return;}
    OnlineSessionSearch = MakeShareable(new FOnlineSessionSearch());
    if(OnlineSessionSearch.IsValid())
    {
        if(IOnlineSubsystem::Get()->GetSubsystemName() == "NULL")
        {
            OnlineSessionSearch->bIsLanQuery = true;
        }
        OnlineSessionSearch->MaxSearchResults = 100;
        OnlineSessionSearch->QuerySettings.Set(SEARCH_PRESENCE, true, EOnlineComparisonOp::Equals);
        OnlineSessionPtr->OnFindSessionsCompleteDelegates.AddUObject(this, &UEpicOnlineGameInstance::OnFindSessionListCompleted);
        OnlineSessionPtr->FindSessions(0, OnlineSessionSearch.ToSharedRef());
        if(bDebuggingMode){UE_LOG(LogOnlineGameInstance, Warning, TEXT("Searching For sessions..."));}
    }
}

SetCurrentSaveSlot()

virtual void UEpicOnlineGameInstance::SetCurrentSaveSlot ( const int32 NewSaveSlot )

inlineoverridevirtual

Implements IMenuSystem.

{CurrentSaveSlot = NewSaveSlot;};

SetDifficultyLevel()

void UEpicOnlineGameInstance::SetDifficultyLevel ( const EDifficultyLevel NewDifficultyLevel )

overridevirtual

Implements IDifficultyInterface.

{
    DifficultyLevel = NewDifficultyLevel;
}

SetMinNumberOfPlayersToStart()

virtual void UEpicOnlineGameInstance::SetMinNumberOfPlayersToStart ( const int32 Num )

inlineoverridevirtual

Implements IMenuSystem.

{MinNumberOfPlayersToStart = Num;};

SetPlayerProfileName()

void UEpicOnlineGameInstance::SetPlayerProfileName ( )

private

@ TODO REMOVE AFTER Loading Player PROFILE from save,

Temp Use for Offline AS well //

{
    OfflinePlayerProfile.DisplayName = GetPlayerUserName();
    //@ TODO Fill out the rest of the player profile items
}

SetPlayFabDisplayName()

void UEpicOnlineGameInstance::SetPlayFabDisplayName ( )

private

{
    AdminAPI = IPlayFabModuleInterface::Get().GetAdminAPI();
    PlayFab::AdminModels::FUpdateUserTitleDisplayNameRequest Request;
    Request.DisplayName = GetPlayerUserName();
    Request.PlayFabId = PlayFabID;
    AdminAPI->UpdateUserTitleDisplayName(Request,
        PlayFab::UPlayFabAdminAPI::FUpdateUserTitleDisplayNameDelegate::CreateUObject(this, &UEpicOnlineGameInstance::OnPlayFabDisplayChangedSuccess),
        PlayFab::FPlayFabErrorDelegate::CreateUObject(this, &UEpicOnlineGameInstance::OnPlayFabError));
}

SetSelectedLevel()

void UEpicOnlineGameInstance::SetSelectedLevel ( const FGameLevel GameLevel, const EGameplayMode GameMode )

overridevirtual

Implements ILevelSelectInterface.

{
    switch(GameMode)
    {
    case EGameplayMode::Campaign:
        SelectedCampaignLevel = GameLevel;
        break;
    case EGameplayMode::Horde:
        SelectedHordeLevel = GameLevel;
        break;
    case EGameplayMode::Debug:
        SelectedDebugLevel = GameLevel;
        break;
    case EGameplayMode::Multiplayer:
    default:
        SelectedMultiplayerLevel = GameLevel;
        break;
    }
}

Shutdown()

void UEpicOnlineGameInstance::Shutdown ( )

overridevirtual

{
    if(!UKismetSystemLibrary::IsStandalone(this))
    {
        DestroySession();
    }
    Super::Shutdown();
}

SinglePlayer()

void UEpicOnlineGameInstance::SinglePlayer ( )

overridevirtual

Implements IMenuSystem.

Reimplemented in UMenuSystemGameInstance.

{
}

StartCampaign()

void UEpicOnlineGameInstance::StartCampaign ( const bool bNewGame ) const

overridevirtual

Implements IMenuSystem.

{
    if(bNewGame)
    {
        
    }
    else
    {
        //Load Save Games
    }
    if(GetWorld() == nullptr){if(bDebuggingMode){UE_LOG(LogOnlineGameInstance, Error, TEXT("GetWorld Failed in Start Campaign"));}return;}
    if(SelectedCampaignLevel.IsValid())
    {
        if(GetIsPlayerLoggedIn())
        {
            GetWorld()->ServerTravel(SelectedCampaignLevel.LevelLocation);
        }
        else
        {
            UGameplayStatics::OpenLevel(GetWorld(), FName(SelectedCampaignLevel.LevelLocation));
        }
    }
    else
    {
        if(!DemoLevelText.IsEmpty())
        {
            GetWorld()->ServerTravel(DemoLevelText);
        }       
    }
}

StartHorde()

void UEpicOnlineGameInstance::StartHorde ( ) const

overridevirtual

Reimplemented from IMenuSystem.

{
    if(GetWorld() == nullptr){if(bDebuggingMode){UE_LOG(LogOnlineGameInstance, Error, TEXT("GetWorld Failed in StartHorde"));}return;}
    if(SelectedHordeLevel.IsValid())
    {
        if(GetIsPlayerLoggedIn())
        {
            GetWorld()->ServerTravel(SelectedHordeLevel.LevelLocation);
        }
        else
        {
            UGameplayStatics::OpenLevel(GetWorld(), FName(SelectedHordeLevel.LevelLocation));
        }
    }
    else
    {
        GetWorld()->ServerTravel("/Game/Levels/Debug/HordeTestMap");
    }
}

StartRecordingReplayFromBP()

void UEpicOnlineGameInstance::StartRecordingReplayFromBP ( const FString & InName, const FString & FriendlyName )

overrideprotectedvirtual

Start recording a replay from blueprint. ReplayName = Name of file on disk, FriendlyName = Name of replay in UI

Implements IReplayClipInterface.

{
    StartRecordingReplay(InName, FriendlyName);
    //@ Todo Server Chat Message - Recording Started
    if(bDebuggingMode){UE_LOG(LogOnlineGameInstance, Error, TEXT("Recording Started"));}
}

StartSession()

void UEpicOnlineGameInstance::StartSession ( )

overridevirtual

Implements IMenuSystem.

Reimplemented in UMenuSystemGameInstance.

{
    if(OnlineSubsystem == nullptr || OnlineSessionPtr == nullptr){return;}
    OnlineSessionPtr->StartSession(SESSION_NAME);
    if(GetWorld() != nullptr)
    {
        if(SelectedMultiplayerLevel.IsValid())
        {
            GetWorld()->ServerTravel(SelectedMultiplayerLevel.LevelLocation);
        }
        else
        {
            GetWorld()->ServerTravel(StartupLevelText);
        }
    }
}

StopRecordingReplayFromBP()

void UEpicOnlineGameInstance::StopRecordingReplayFromBP ( )

overrideprotectedvirtual

Start recording a running replay and save it, from blueprint.

Implements IReplayClipInterface.

{
    StopRecordingReplay();
    if(bDebuggingMode){UE_LOG(LogOnlineGameInstance, Error, TEXT("Recording Stopped"));}
}

UpdatePlayerData()

void UEpicOnlineGameInstance::UpdatePlayerData	(	const FString &	FileName,
		TArray< uint8 >	SavedGameArray )

{
    if(!SavedGameArray.IsEmpty() && GetOnlineIdentity() != nullptr)
    {
        const IOnlineUserCloudPtr UserCloud = OnlineSubsystem->GetUserCloudInterface();
        if(UserCloud != nullptr)
        {
            const TSharedPtr<const FUniqueNetId> UserID = GetOnlineIdentity()->GetUniquePlayerId(0).ToSharedRef();
            UserCloud->OnWriteUserFileCompleteDelegates.AddUObject(this, &UEpicOnlineGameInstance::OnWriteUserFileComplete);
            UserCloud->WriteUserFile(*UserID, FileName, SavedGameArray);
        }
    }
}

UpdateStats()

void UEpicOnlineGameInstance::UpdateStats ( FString StatName, int32 Amount )

virtual

{
    if(GetOnlineIdentity() != nullptr)
    {
        const IOnlineStatsPtr StatsPointer = OnlineSubsystem->GetStatsInterface();
        if(StatsPointer != nullptr)
        {
            FOnlineStatsUserUpdatedStats StatVar = FOnlineStatsUserUpdatedStats(GetOnlineIdentity()->GetUniquePlayerId(0).ToSharedRef());
            StatVar.Stats.Add(StatName, FOnlineStatUpdate(Amount,FOnlineStatUpdate::EOnlineStatModificationType::Sum));
            TArray<FOnlineStatsUserUpdatedStats> StatArray;
            StatArray.Add(StatVar);
            StatsPointer->UpdateStats(GetOnlineIdentity()->GetUniquePlayerId(0).ToSharedRef(), StatArray, FOnlineStatsUpdateStatsComplete::CreateUObject(this, &UEpicOnlineGameInstance::OnUpdateStatsComplete));
        }
    }
}

Member Data Documentation

AdminAPI

PlayFabAdminPtr UEpicOnlineGameInstance::AdminAPI = nullptr

private

AllSaveSlots

TArray<int32> UEpicOnlineGameInstance::AllSaveSlots

private

bAutoLoginToPlayFab

bool UEpicOnlineGameInstance::bAutoLoginToPlayFab = true

protected

bDebuggingMode

bool UEpicOnlineGameInstance::bDebuggingMode = true

protected

bInGameMenuOpen

bool UEpicOnlineGameInstance::bInGameMenuOpen = false

protected

bOptionsMenuOpen

bool UEpicOnlineGameInstance::bOptionsMenuOpen = false

protected

ClientAPI

PlayFabClientPtr UEpicOnlineGameInstance::ClientAPI = nullptr

private

CurrencyCode

FString UEpicOnlineGameInstance::CurrencyCode = "PC"

protected

CurrentSaveSlot

int32 UEpicOnlineGameInstance::CurrentSaveSlot = 1

private

CurrentSessionName

FString UEpicOnlineGameInstance::CurrentSessionName = "Default_Server_Name"

private

DemoLevelText

FString UEpicOnlineGameInstance::DemoLevelText

DifficultyLevel

EDifficultyLevel UEpicOnlineGameInstance::DifficultyLevel = EDifficultyLevel::Normal

private

EnumerateStreamsPtr

TSharedPtr<INetworkReplayStreamer> UEpicOnlineGameInstance::EnumerateStreamsPtr

private

InGameMenuClass

TSubclassOf<class UUserWidget> UEpicOnlineGameInstance::InGameMenuClass = nullptr

protected

InGameMenuWidget

class UInGameMenuSystemWidget* UEpicOnlineGameInstance::InGameMenuWidget = nullptr

protected

LevelDataTable

class UDataTable* UEpicOnlineGameInstance::LevelDataTable = nullptr

protected

LobbyLevelText

FString UEpicOnlineGameInstance::LobbyLevelText

MainMenu

class UMenuSystemWidget* UEpicOnlineGameInstance::MainMenu = nullptr

protected

MenuClass

TSubclassOf<class UUserWidget> UEpicOnlineGameInstance::MenuClass = nullptr

protected

MinNumberOfPlayersToStart

int32 UEpicOnlineGameInstance::MinNumberOfPlayersToStart = 2

private

ModalWidgetClass

TSubclassOf<class UUserWidget> UEpicOnlineGameInstance::ModalWidgetClass = nullptr

protected

OfflinePlayerProfile

FUserProfile UEpicOnlineGameInstance::OfflinePlayerProfile

private

OnDeleteFinishedStreamCompleteDelegate

FDeleteFinishedStreamCallback UEpicOnlineGameInstance::OnDeleteFinishedStreamCompleteDelegate

private

OnEnumerateStreamsCompleteDelegate

FEnumerateStreamsCallback UEpicOnlineGameInstance::OnEnumerateStreamsCompleteDelegate

private

OnFileDataFound

FOnFileDataFound UEpicOnlineGameInstance::OnFileDataFound

OnFindReplaysComplete

FOnFindReplaysComplete UEpicOnlineGameInstance::OnFindReplaysComplete

OnlineSessionPtr

IOnlineSessionPtr UEpicOnlineGameInstance::OnlineSessionPtr

OnlineSessionSearch

TSharedPtr<FOnlineSessionSearch> UEpicOnlineGameInstance::OnlineSessionSearch

OnlineSubsystem

class IOnlineSubsystem* UEpicOnlineGameInstance::OnlineSubsystem = nullptr

OnRenameReplayCompleteDelegate

FRenameReplayCallback UEpicOnlineGameInstance::OnRenameReplayCompleteDelegate

private

OnServersFoundChanged

FOnServersFound UEpicOnlineGameInstance::OnServersFoundChanged

OptionsMenuClass

TSubclassOf<class UUserWidget> UEpicOnlineGameInstance::OptionsMenuClass = nullptr

protected

OptionsMenuWidget

class UOptionsMenuSystemWidget* UEpicOnlineGameInstance::OptionsMenuWidget = nullptr

protected

PlayFabCurrency

float UEpicOnlineGameInstance::PlayFabCurrency = 0.0f

private

PlayFabID

FString UEpicOnlineGameInstance::PlayFabID = ""

private

PlayFabInventory

TArray<PlayFab::ClientModels::FItemInstance> UEpicOnlineGameInstance::PlayFabInventory

private

ProfilePicturesDT

class UDataTable* UEpicOnlineGameInstance::ProfilePicturesDT = nullptr

protected

ReplayMenu

class UReplayMenu* UEpicOnlineGameInstance::ReplayMenu = nullptr

protected

ReplayMenuClass

TSubclassOf<UReplayMenu> UEpicOnlineGameInstance::ReplayMenuClass = nullptr

protected

SelectedCampaignLevel

FGameLevel UEpicOnlineGameInstance::SelectedCampaignLevel

protected

SelectedDebugLevel

FGameLevel UEpicOnlineGameInstance::SelectedDebugLevel

protected

SelectedHordeLevel

FGameLevel UEpicOnlineGameInstance::SelectedHordeLevel

protected

SelectedMultiplayerLevel

FGameLevel UEpicOnlineGameInstance::SelectedMultiplayerLevel

protected

StartupLevelText

FString UEpicOnlineGameInstance::StartupLevelText

---

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

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