StatsTrackingManager.h

Go to the documentation of this file.

// Copyright Blue Isle Studios Inc 2018. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "PlayerStats.h"
#include "PlayerStructs.h"
#include "ProjectXGameInstance.h"
#include "Stats/NakamaManager.h"
#include "StatsTrackingManager.generated.h"
 
class AProjectXPlayerState;
class UWeaponInstance;
 
#define NULLSTRING "";
 
USTRUCT()
struct FStatEvent
{
    GENERATED_USTRUCT_BODY()
    FStatEvent() { }
    
    FStatEvent(AProjectXPlayerState* InPlayerState, EStatNames InStatName,UObject* InObject = NULL, int32 InValue = 1, EStatUpdateBehaviour InTag = EStatUpdateBehaviour::NONE, int32 DebugMapType = 0, FString DebugMapName = "");
 
    TWeakObjectPtr<AProjectXPlayerState> PlayerState = NULL;
    int32 Value = 0;
    EStatNames StatName = EStatNames::Invalid;
    EStatUpdateBehaviour Tag = EStatUpdateBehaviour::NONE;
    TWeakObjectPtr<UObject> Object = NULL;
    int32 DebugMapType = 0;
    FString DebugMapName = "";
};
 
USTRUCT(BlueprintType)
struct FLeaderBoardLocalEntry
{
    GENERATED_USTRUCT_BODY()
    FLeaderBoardLocalEntry() { }
    UPROPERTY(BlueprintReadWrite)
    int32 Value = 0;
    UPROPERTY(BlueprintReadWrite)
    int32 GlobalRank = 0;
    UPROPERTY(BlueprintReadWrite)
    int32 FriendRank = 0;
};
 
USTRUCT(BlueprintType)
struct FLeaderBoardEntry
{
    GENERATED_USTRUCT_BODY()
    FLeaderBoardEntry() { }
    FLeaderBoardEntry(const FString& PlayerIDIn,const FString& DisplayNameIn, int32 ValueIn, const FString& BannerIDIn, const FString& SteamIDIn, uint16 RankIn)
    {
        Value = ValueIn;
        PlayerID = PlayerIDIn;
        DisplayName = DisplayNameIn;
        BannerID = BannerIDIn;
        SteamID = SteamIDIn;
        Rank = RankIn;
    }
 
    UPROPERTY(BlueprintReadWrite)
    int32 Value = 0;
    UPROPERTY(BlueprintReadWrite)
    FString PlayerID = "";
    UPROPERTY(BlueprintReadWrite)
    FString DisplayName = "";
    UPROPERTY(BlueprintReadWrite)
    FString BannerID = "";
    UPROPERTY(BlueprintReadWrite)
    FString SteamID = "";
    UPROPERTY(BlueprintReadWrite)
    int32 Rank = 0;
    UPROPERTY(BlueprintReadWrite)
    int32 Level = 0;
 
    bool operator >(const FLeaderBoardEntry& Other) const
    {
        if (Value != Other.Value)
        {
            return Value > Other.Value;
        }
 
        return true;
    }
};
 
class UStatTrackingSave;
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FChallengesSignature, const FTimedChallenges&, Challenges, const FString&, PlayerID);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_FourParams(FChallengeClaimedSignature, const FString&, ChallengeID, const FString&, ItemID,int, Experience,int, Currency);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FChallengeProgressSignature, const FString&, ChallengeID, int32, Progress);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams(FLevelUpEventSignature, const FString&, PlayerID, const FString&, ClassID, int, NewLevel);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FLeaderBoardLoadedSignature, bool, bLoadSuccess);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FStatsSaveLoadedSignature, const FString&, PlayerID);
DECLARE_DYNAMIC_MULTICAST_DELEGATE(FStatsFinishedLoadingSignature);
DECLARE_DYNAMIC_MULTICAST_DELEGATE(FStatsTrackingManagerInitializedSignature);
 
UCLASS(Blueprintable)
class PROJECTX_API UStatsTrackingManager : public UObject
{
    GENERATED_BODY()
 
public:     
 
    UFUNCTION(BlueprintPure, Category = StatTracking, meta = (WorldContext = "WorldContextObject", CallableWithoutWorldContext))
    static UStatsTrackingManager* GetStatTrackingManager(const UObject* WorldContextObject);
    UFUNCTION(BlueprintPure, Category = StatsTracking)
    int GetStat(const FString& PlayerID, const EStatClassifier StatType, const EStatNames StatName,const FString& StatClassName = "");
    UFUNCTION(BlueprintPure, Category = StatsTracking)
    int GetStatDelta(const FString& PlayerID, const EStatClassifier StatType, const EStatNames StatName, const FString& StatClassName = "");
 
    UFUNCTION(BlueprintCallable, Category = StatsTrackingManager)
    UStatTrackingSave* GetStatInstance(const FString& PlayerID);
    UFUNCTION(BlueprintCallable, Category = StatsTrackingManager)
    void SaveAllInstances();
    UFUNCTION(BlueprintCallable, Category = StatsTrackingManager)
    void SaveInstance(const FString& PlayerID,bool bChallengesOnly = false);
    UFUNCTION(BlueprintCallable,BlueprintPure, Category = StatsTrackingManager)
    void GetChallenges(const FString& PlayerID,FTimedChallenges& Challenges);
    UFUNCTION(BlueprintCallable, Category = StatsTracking)
    UStatTrackingSave* LoadStatInstance(const FString& PlayerID);
    UFUNCTION(BlueprintCallable, Category = StatsTracking)
    const FLeaderBoardLocalEntry& GetLocalLeaderboardEntry() { return LocalLeaderboardEntry; }
    UFUNCTION(BlueprintCallable, Category = StatsTracking)
    void MarkStatSaveForReload(const FString& PlayerID,bool bAuthorityOnly = false);
    UFUNCTION(BlueprintCallable)
    void LoadChallenges(const FString& PlayerID);
    UFUNCTION(BlueprintCallable)
    void RerollChallenge(const FString& ChallengeID);
    UFUNCTION(BlueprintCallable)
    void ClaimChallenge(const FString& ChallengeID);
    UFUNCTION(BlueprintCallable)
    void LoadLeaderBoardForStat(EStatNames Name, EStatClassifier Type, const FString& Class, int NumberOfEntries, int PageNumber,bool bFriendsOnly = false);
    UFUNCTION(BlueprintCallable)
    const TMap<int32, FLeaderBoardEntry>& GetLeaderboard() const { return CurrentLeaderboard; };
    UFUNCTION(BlueprintCallable)
    bool IsValidStatCheck(EStatClassifier Class, EStatNames Name) const;
    UFUNCTION(BlueprintCallable,BlueprintPure)
    bool AreStatsSynced(const FString& PlayerID);
    UFUNCTION(BlueprintPure)
    bool HasChallengeReroll() const{ return bHasChallengeReroll;}
    UFUNCTION()
    void OnNakamaConnected();
    UFUNCTION(BlueprintCallable, BlueprintPure)
    const FString& GetNakamaLocalPlayerID() { return LocalPlayerID; }
    UFUNCTION()
    void OnPurchaseEvent(bool bPurchaseSucess, const FString& ItemID);
    UFUNCTION(BlueprintCallable)
    void BPUpdateStat(AProjectXPlayerState* PlayerState, EStatNames InStatName);
    UFUNCTION(BlueprintCallable)
    bool IsValidLeaderboardPage(int32 PageNumber,int32 Entries) const;
    
    bool IsAuthoritativeState(EStatNames StatName);
    void LoadAllStats(const FString& PlayerID,bool bForceReload = false);
    void LoadAuthoritativeStats(const FString& PlayerID, const TArray<FString>& StatNames, bool bForceReload = false);
 
    UFUNCTION(BlueprintCallable, Category = "Stats")
    void LoadRequestedPlayerStats(const FString& PlayerID, const TArray<FString>& StatNames, bool bForceReload);
 
    void UpdateStat(struct FStatEvent const& StatEvent);
    void ShotComplete(struct FStatEvent const& StatEvent, const uint16 ID);
    void UpdateChallengeComplete(const FString& PlayerID, const FString& ChallengeID);
    void UpdateChallengePredictiveProgressFromChallengeNumber(AProjectXPlayerState* const PlayerState, uint8 ChallengeID);
    void Init(UProjectXGameInstance* GameInstance);
    void InitStatType(UStatTrackingSave* Save, const TArray<FString>& ClassNames, EStatClassifier Class);
    void RemoveStatInstance(const FString& PlayerID);
    void LoadFriendsLeaderboardResponse(const TArray<TSharedPtr<FJsonValue>>& LeaderboardEntryList);
    void LeaderboardLoadedResponse(const TArray<TSharedPtr<FJsonValue>>& LeaderboardEntryList);
    void LoadLeaderBoard(const FString& StatKey, int NumberOfEntries, int PageNumber);
    void LoadPersonalLeaderBoard(const FString& StatKey);
    void LoadLeaderBoardForFriends(const FString& StatKey, int PageNumber = 0);
    void ApplyMatchBonus(AProjectXPlayerState* const PlayerState);
 
    void CheckAchievementList(const FStatEvent AchievementStatEvent);
    static FString BuildStatKey(EStatClassifier StatClass, const FString& ClassID, EStatNames StatName);
    static void ParseStatKey(const FString& Key, EStatClassifier& StatClass, FString& ClassID, EStatNames& StatName);
    void OverrideAuthoritativeStat(const FString& StatKey, int Value);
    void ForceLevelToTarget(const FString& StatKey, int Value);
 
    UPROPERTY(BlueprintAssignable)
    FChallengesSignature OnChallengesLoadedEvent;
    UPROPERTY(BlueprintAssignable)
    FChallengeClaimedSignature OnChallengeClaimedEvent;
    UPROPERTY(BlueprintAssignable)
    FChallengeProgressSignature OnChallengeProgressUpdated;
    UPROPERTY(BlueprintAssignable)
    FLeaderBoardLoadedSignature OnLeaderBoardLoaded;
    UPROPERTY(BlueprintAssignable)
    FLeaderBoardLoadedSignature OnLocalLeaderboardUpdatedEvent;
    UPROPERTY(BlueprintAssignable)
    FStatsSaveLoadedSignature OnStatsLoaded;
    UPROPERTY(BlueprintAssignable)
    FStatsFinishedLoadingSignature OnStatsFinishedLoading;
    UPROPERTY(BlueprintAssignable)
    FStatsSaveLoadedSignature OnAuthoritativeStastLoaded;
    UPROPERTY(BlueprintAssignable)
    FLevelUpEventSignature OnPlayerLeveledUp;
    UPROPERTY(BlueprintAssignable)
    FStatsTrackingManagerInitializedSignature OnStatsTrackingManagerInitialized;
 
protected:
    UPROPERTY()
    TMap<FString, UStatTrackingSave*> StatSaves = TMap<FString, UStatTrackingSave*>();
    FTimerHandle RetryConnectionHandle;
 
    void UpdateChallengeProgressFromStat(TWeakObjectPtr<AProjectXPlayerState> PlayerState,const EStatClassifier ClassType, const EStatNames StatName, const FString& ClassName = "");
    void InitializeAllStats(UStatTrackingSave* StatSaveObject);
    void InitializeProgressionStats(UStatTrackingSave* StatSaveObject);
    void LoadChallengesResponse(TSharedPtr<FJsonObject> FoundChallengesJson,const FString& PlayerID);
    void CheckForLevelUpAchievement(const int32 Level, AProjectXPlayerState* PlayerState);
    void SaveStatIntance(UStatTrackingSave* const Save);
    void SaveChallenges(UStatTrackingSave* const Save);
    void SaveExperience(UStatTrackingSave* const Save);
    void ConsumeMatchEndBonus(UStatTrackingSave* const Save);
    void OnExperienceUpdatedResponse(UStatTrackingSave* const Save, const TArray<TSharedPtr<FJsonValue>>& LevelingResults);
    void ResetCurrentLeaderboard(const FString& StatKey, bool bFriends);
    TSharedPtr<FJsonObject> MakeExperienceUpdate(EStatClassifier Classifier, const FString& ClassID, const FString& PlayerID);
    FString GetGameTypeStringFromEnum(EGameType GameTypeEnum);
 
    int32 GetChallengNumberFromID(const FString& ChallengeID);
    const FString& GetChallengeIDFromNumber(int32 Number);
 
    UFUNCTION(BlueprintPure, Category = "Stats")
    int32 GetPlayerLevelFromPlayerID(const FString& PlayerID);
 
    std::string LeaderboardCursor;
    FString CurrentLeaderboardStatKey = "";
    int32 HighestLoadedLeaderboardPage = 0;
 
    TMap<EStatClassifier,TSet<EStatNames>> ValidClassStats;
    TMap <int32, FLeaderBoardEntry> CurrentLeaderboard;
    FLeaderBoardLocalEntry LocalLeaderboardEntry = FLeaderBoardLocalEntry();
    TArray<TSharedPtr<FJsonValue>> LeaderboardEntries;
    
    bool bFriendsOnlyLoaded = false;
    FString LocalPlayerID = "";
 
    FString ChallengeComplete = "VO_ChallengeCompleted";
 
    TMap<FString, float> AnalyticStatsToSend;
 
    bool bHasChallengeReroll = false;
 
    FString EmptyChallengeID = "";
 
    TArray<FString>ChallengeIDs;
    TSet<FString> AuthoritativeStats = TSet<FString>();
    TSet<FString> LeaderboardStats = TSet<FString>();
};