EpicOnlineGameInstance.h

Go to the documentation of this file.

// Fill out your copyright notice in the Description page of Project Settings.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Interfaces/OnlineStatsInterface.h"
// #include "OnlineError.h"
#include "NetworkReplayStreaming.h"
#include "Engine/GameInstance.h"
#include "Interfaces/OnlineSessionInterface.h"
#include "OnlineSessionSettings.h"
#include "Data/BaseData.h"
#include "Interfaces/DifficultyInterface.h"
#include "Interfaces/ModalInterface.h"
#include "Interfaces/LevelSelectInterface.h"
#include "Interfaces/MenuSystem.h"
#include "Interfaces/OnlineIdentityInterface.h"
#include "Interfaces/ReplayClipInterface.h"
#include "Widgets/MenuSystemWidget.h"
// #include "VoiceChat.h"
#include "Interfaces/PlayFabMenu.h"
#include "PlayFab.h"
#include "PlayFabAdminDataModels.h"
#include "Core/PlayFabError.h"
#include "Core/PlayFabClientDataModels.h"
#include "EpicOnlineGameInstance.generated.h"
 
namespace PlayFab::ServerModels
{
    struct FItemInstance;
}
 
DECLARE_LOG_CATEGORY_EXTERN(LogOnlineGameInstance, Display, All);
 
class UReplayMenu;
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnServersFound, const TArray<FServerRow>&, ServerInfo);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FOnFileDataFound, FString, FileName,const TArray<uint8>&, FileContents);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnFindReplaysComplete, const TArray<FReplayInfo>&, AllReplays);
 
UCLASS()
class MENUSYSTEM_API UEpicOnlineGameInstance : public UGameInstance, public IMenuSystem, public IDifficultyInterface,
public IReplayClipInterface, public ILevelSelectInterface, public IModalInterface, public IPlayFabMenu
{
    GENERATED_BODY()
 
public:
    //-     Delegates       //
    UPROPERTY(BlueprintAssignable, Category = "EOS") 
    FOnServersFound OnServersFoundChanged;
    UPROPERTY(BlueprintAssignable, Category = "EOS")
    FOnFileDataFound OnFileDataFound;
    UPROPERTY(BlueprintAssignable, Category = "EOS")
    FOnFindReplaysComplete OnFindReplaysComplete;
 
    explicit UEpicOnlineGameInstance(const FObjectInitializer& ObjectInitializer);
 
    
    virtual void Init() override;
    virtual void Shutdown() override;
 
    //-     Difficulty Interface    //
    UFUNCTION(BlueprintCallable, Category="Difficulty")
    virtual EDifficultyLevel GetDifficultyLevel() const override;
    //-     Difficulty  //
    UFUNCTION(BlueprintCallable, Category="EOS")    
    virtual void SetDifficultyLevel(const EDifficultyLevel NewDifficultyLevel) override;
 
    
    virtual FString GetAuthToken() const override;
    
    //@ TODO Move to Playfab Component 
    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;
 
 
    //- Interface Functions //
    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 {return ModalWidgetClass;};
 
    virtual bool GetDebuggingMode() const override {return bDebuggingMode;};
 
    //- Possibly Take from Old  //
    virtual void SearchServers() override;
 
 
    virtual void StartCampaign(const bool bNewGame) const override;
    virtual void RestartLevel() const;
 
    virtual void StartHorde() const override;
 
    //- Save Slots  //
    virtual void SetCurrentSaveSlot(const int32 NewSaveSlot) override{CurrentSaveSlot = NewSaveSlot;};
 
    virtual int32 GetCurrentSaveSlot() override {return CurrentSaveSlot;};
    virtual TArray<int32> GetAllSaveSlots() override {return AllSaveSlots;};
    //@TODO Saave Slot info
    virtual FUserSaveGame GetSaveInfoFromSlot(const int32 Slot) override {return FUserSaveGame();};
 
    // virtual void CreatePopup(APlayerController* PlayerController, FModalData ModalData) override;
    virtual bool GetIsOnlineGame() const override;
    virtual bool GetIsPublicMatch() const override;
    virtual EOnlineSubsystem GetOnlineSubsystem() const override;
 
 
 
 
    
    //- Old interface functions     //
    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;
 
 
    //-     New stuff   / to add to interface
    UFUNCTION(BlueprintCallable, Category="EOS")    
    virtual void UpdateStats(FString StatName, int32 Amount);
    // virtual void UpdateStats(FString StatName, int32 Amount, FOnlineStatUpdate::EOnlineStatModificationType Type);
    UFUNCTION(BlueprintCallable, Category="EOS")    
    virtual void GetStats(TArray<FString> StatName);
    
    UFUNCTION(BlueprintCallable, Category="EOS")    
    virtual void LoadMenu() override;
 
    UFUNCTION(BlueprintCallable, Category="EOS")    
    TArray<uint8> ConvertSaveFileTouint(class USaveGame* SavedGame);
    UFUNCTION(BlueprintCallable, Category="EOS")    
    class USaveGame* ConvertunitToSaveFile(TArray<uint8> SavedGameArray);
    UFUNCTION(BlueprintCallable, Category="EOS")    
    void UpdatePlayerData(const FString& FileName, TArray<uint8> SavedGameArray);
    UFUNCTION(BlueprintCallable, Category="EOS")    
    void GetPlayerData(const FString& FileName);
 
    UFUNCTION(Category="EOS")   
    void ReadPlayerData(const FString& FileName) const;
 
    virtual int32 GetMinNumberOfPlayersToStart() const override {return MinNumberOfPlayersToStart;};
    virtual void SetMinNumberOfPlayersToStart(const int32 Num) override {MinNumberOfPlayersToStart = Num;};
 
    
    TSharedPtr<FOnlineSessionSearch> OnlineSessionSearch;
    class IOnlineSubsystem* OnlineSubsystem = nullptr;
    IOnlineSessionPtr OnlineSessionPtr;
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="EOS")
    FString LobbyLevelText;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="EOS")
    FString StartupLevelText;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="EOS")
    FString DemoLevelText;
 
 
    
 
    //- Voice Chat  //
    // UFUNCTION(BlueprintCallable, Category="EOS")
    // void EOSVoiceChatLogin();
    // void OnVoiceChatLoginCompleted(const FString& PlayerName,const FVoiceChatResult& Result);
    // IVoiceChatUser* VoiceChatUser;
    // UFUNCTION(BlueprintCallable, Category="EOS")
    // void SetInputVolumeEOS(float NewVolume);
    // UFUNCTION(BlueprintCallable, Category="EOS")
    // void SetMuteInputVolumeEOS(bool bIsMuted);
    // UFUNCTION(BlueprintCallable, Category="EOS")
    // void SetInputOutputMode(int32 Value);
 
 
    //- Level Select Interface  //
    virtual UDataTable* GetLevelDataTable() override{return LevelDataTable;};
 
    // UFUNCTION(BlueprintCallable, Category="Menu System|Levels")
    virtual void SetSelectedLevel(const FGameLevel GameLevel, const EGameplayMode GameMode) override;
    // UFUNCTION(BlueprintCallable, Category="Menu System|Levels")
    virtual FGameLevel GetSelectedLevel(const EGameplayMode GameMode) const override;
 
    //- Online Profile  //
 
    // virtual FUserProfile GetOnlinePlayerProfile() const override {return OnlinePlayerProfile;};
    virtual FUserProfile GetOfflinePlayerProfile() const override {return OfflinePlayerProfile;};
    virtual UDataTable* GetProfilePicturesDT() const override{return ProfilePicturesDT;};
 
    UFUNCTION(BlueprintCallable, Category="Player Profile")
    virtual bool SaveOfflinePlayerProfile() override;
    UFUNCTION(BlueprintCallable, Category="Player Profile")
    virtual bool LoadOfflinePlayerProfile(FUserProfile& OfflineProfile) override;
 
protected:
 
    virtual void ReturnToMainMenu() override;
    
    UPROPERTY()
    class UInGameMenuSystemWidget* InGameMenuWidget = nullptr;
    UPROPERTY(EditAnywhere, Category="Game Instance|Widgets")
    TSubclassOf<class UUserWidget>  InGameMenuClass = nullptr;
    UPROPERTY()
    class UOptionsMenuSystemWidget* OptionsMenuWidget = nullptr;
    UPROPERTY(EditAnywhere, Category="Game Instance|Widgets")
    TSubclassOf<class UUserWidget>  OptionsMenuClass = nullptr;
 
    TSubclassOf<class UUserWidget>  ModalWidgetClass = nullptr;
 
    UPROPERTY()
    class UMenuSystemWidget* MainMenu = nullptr;
    UPROPERTY(EditAnywhere, Category="Game Instance|Widgets")
    TSubclassOf<class UUserWidget>  MenuClass = nullptr;
    
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="Replay")
    class UReplayMenu* ReplayMenu = nullptr;
    UPROPERTY(EditAnywhere, Category="Game Instance|Widgets")
    TSubclassOf<UReplayMenu> ReplayMenuClass = nullptr;
 
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Menu System")
    bool bDebuggingMode = true;
    bool bInGameMenuOpen = false;
    bool bOptionsMenuOpen = false;
 
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Menu System")
    class UDataTable* ProfilePicturesDT = nullptr;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Menu System")
    class UDataTable* LevelDataTable = nullptr;
 
 
    
    //-     Gameplay Replays    //
    UFUNCTION(BlueprintCallable, Category = "Replays")
    virtual bool OpenReplayMenu(APlayerController* Player, const bool bOpen = true) override;
    UFUNCTION(BlueprintCallable, Category = "Replays")   
    virtual void StartRecordingReplayFromBP(const FString& InName, const FString& FriendlyName) override;
 
    //- Does nothing ATM    //
    UFUNCTION(BlueprintCallable, Category = "Replays")   
    virtual void CreateReplayEvent(const int32 TimeInMS, const FString& Group, const FString& Meta, const TArray<uint8>& Data) override;
 
    UFUNCTION(BlueprintCallable, Category = "Replays")   
    virtual void StopRecordingReplayFromBP() override;
    UFUNCTION(BlueprintCallable, Category = "Replays")   
    virtual void PlayReplayFromBP(FString ReplayName) override;   
    UFUNCTION(BlueprintCallable, Category = "Replays")  
    virtual void FindReplays() override; 
    UFUNCTION(BlueprintCallable, Category = "Replays")  
    virtual void RenameReplay(const FString &ReplayName, const FString &NewFriendlyReplayName) override;   
    UFUNCTION(BlueprintCallable, Category = "Replays")
    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;
 
    //- New //
    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;
 
    
    //- Extras to add?  //
    //bool PlayReplayPlaylist(const struct FReplayPlaylistParams& PlaylistParams);
    // virtual void AddUserToReplay(const FString& UserString);
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="Menu System|PlayFab")
    bool bAutoLoginToPlayFab = true;
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="Menu System|PlayFab")
    FString CurrencyCode = "PC";
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Menu System|Levels")
    FGameLevel SelectedCampaignLevel;
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Menu System|Levels")
    FGameLevel SelectedMultiplayerLevel;
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Menu System|Levels")
    FGameLevel SelectedHordeLevel;
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Menu System|Levels")
    FGameLevel SelectedDebugLevel;
 
    
private:
 
    IOnlineIdentityPtr GetOnlineIdentity() const;
 
 
    
    int32 MinNumberOfPlayersToStart = 2;
    FString CurrentSessionName = "Default_Server_Name";
    EDifficultyLevel DifficultyLevel = EDifficultyLevel::Normal;
 
 
 
    void SetPlayerProfileName();
 
    // FUserProfile OnlinePlayerProfile;
    FUserProfile OfflinePlayerProfile;
    
    int32 CurrentSaveSlot = 1;
    TArray<int32> AllSaveSlots;
 
 
 
 
    
    virtual void OnNetworkFailure(UWorld* World, UNetDriver* NewDriver, ENetworkFailure::Type FailureType, const FString& ErrorString);
 
    //-     Gameplay Replays    //
    TSharedPtr<INetworkReplayStreamer> EnumerateStreamsPtr;  
    FEnumerateStreamsCallback OnEnumerateStreamsCompleteDelegate;  
    FDeleteFinishedStreamCallback OnDeleteFinishedStreamCompleteDelegate;
    
    FRenameReplayCallback OnRenameReplayCompleteDelegate;
 
    
    void OnEnumerateStreamsComplete(const FEnumerateStreamsResult& Result) const;
    void OnDeleteFinishedStreamComplete(const FDeleteFinishedStreamResult& Result);
    void OnReplayRenameFinishedComplete(const FRenameReplayResult& Result);
 
 
    //@TODO Move to Playfab Component //
    PlayFabClientPtr ClientAPI = nullptr;
    PlayFabAdminPtr AdminAPI = nullptr;
    FString PlayFabID = "";
    float PlayFabCurrency = 0.0f;
    TArray<PlayFab::ClientModels::FItemInstance> PlayFabInventory;
    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);
 
    
};