ProjectXGameInstance.h

Go to the documentation of this file.

// Copyright Blue Isle Studios Inc 2018. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "CosmeticAssetBase.h"
#include "OnlineSessionInterface.h"
#include "GameInstanceLoadingScreen.h"
#include "ProjectXGameState.h"
/* Online Subsystem */
#include "OnlineIdentityInterface.h"
#include "OnlineSessionSettings.h"
#include "OnlineSessionInterface.h"
#include "Engine/DataTable.h"
/* End Online Subsystem */
#include "Stats/NakamaManager.h"
#include "System/Data/VoiceData/AnnouncerSoundDataAsset.h"
 
#if !IS_CONSOLE_PLATFORM
#include "Schemas/ModioResponse.h"
#include "ThirdParty/Steamworks/Steamv146/sdk/public/steam/steam_api.h"
#endif
 
#include "ProjectXGameInstance.generated.h"
 
class UPlayerProgressionManager;
class ULevelInfo;
class AProjectXGameSession;
class UPlatformInputSymbols;
class AProjectXCharacter;
class UWeaponInstance;
class AProjectXVehicle;
class UDataTable;
class URemoteConsole;
class AProjectXMapCamera;
class UAdvancedUserWidget;
 
UENUM()
enum class EOnlineMode : uint8
{
    Offline,
    LAN,
    Online
};
 
UENUM(BlueprintType)
enum class ESessionState : uint8
{
    NONE,
    SEARCHING,
    JOINING,
    INSESSION,
    DESTROYING,
};
 
UENUM(BlueprintType)
enum class EServerPlatform : uint8
{
    PC,
    PS,
    XBOX
};
 
UENUM(BlueprintType)
enum class EProjectXPrivileges : uint8
{
    CanPlay,
    CanPlayOnline,
    CanCommunicateOnline,
    CanUseUserGeneratedContent,
    CanUserCrossPlay
};
 
UENUM(BlueprintType)
enum class EProjectXPrivilegeResult : uint8
{
    NoFailures = 0,
    RequiredPatchAvailable = 1,
    RequiredSystemUpdate = 2,
    AgeRestrictionFailure = 3,
    AccountTypeFailure = 4,
    UserNotFound = 5,
    UserNotLoggedIn = 6,
    ChatRestriction = 7,
    UGCRestriction = 8,
    GenericFailure = 9,
    OnlinePlayRestricted = 10,
    NetworkConnectionUnavailable = 11,
};
 
namespace ProjectXGameInstanceState
{
    const FName None = FName(TEXT("None"));
    const FName WelcomeScreen = FName(TEXT("WelcomeScreen"));
    const FName MainMenu = FName(TEXT("MainMenu"));
    const FName Playing = FName(TEXT("Playing"));
    const FName PlayingSolo = FName(TEXT("PlayingSolo"));
}
 
DECLARE_DYNAMIC_DELEGATE_TwoParams(FPrivilegeSignature, bool, bAllowed, EProjectXPrivilegeResult, Result);
 
USTRUCT(Blueprintable)
struct FPermissionCheckQueue
{
    GENERATED_USTRUCT_BODY()
 
public:
    EProjectXPrivileges Privilege;
    FPrivilegeSignature Callback;
};
 
class FPXPendingInvite
{
public:
    FPXPendingInvite() : ControllerId(-1), UserId(nullptr), bPrivilegesCheckedAndAllowed(false), bUGCPrivilegesCheckedAndAllowed(false) {}
 
    int32 ControllerId;
    TSharedPtr< const FUniqueNetId > UserId;
    FOnlineSessionSearchResult InviteResult;
    bool bPrivilegesCheckedAndAllowed;
    bool bUGCPrivilegesCheckedAndAllowed;
};
 
UENUM(BlueprintType)
enum class EAvatarSize : uint8
{
    Small = 0,
    Medium = 1,
    Large = 2,
};
 
USTRUCT(BlueprintType)
struct FMatureWordsRow : public FTableRowBase
{
    GENERATED_USTRUCT_BODY()
 
public:
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = MatureWords)
    FString MatureWord;
};
 
USTRUCT(BlueprintType)
struct FLanguageDefinition
{
    GENERATED_USTRUCT_BODY()
 
public:
    UPROPERTY(EditAnywhere, BlueprintReadWrite)
    FName LanguageCode;
    UPROPERTY(EditAnywhere, BlueprintReadWrite)
    FText LanguageText;
};
 
UENUM(BlueprintType)
enum class ESortParameter : uint8
{
    NONE = 0,
    Official = 1,
    MapName = 2,
    Mode = 3,
    PlayerCount = 4,
    Region = 5,
    Ping = 6,
    AntiCheat = 7,
    MODS = 8,
    Password = 9,
    ServerName = 10,
    WhiteList = 11,
    Difficulty = 12,
};
 
UENUM(BlueprintType)
enum class EAchievementData : uint8
{
    NONE                                    = 0,
    PRIVATE_ACHIEVEMENT_1                   = 1,
    CORPORAL_ACHIEVEMENT_2                  = 2,
    SERGEANT_ACHIEVEMENT_3                  = 3,
    LIEUTENANT_ACHIEVEMENT_4                = 4,
    MAJOR_ACHIEVEMENT_5                     = 5,
    COLONEL_ACHIEVEMENT_6                   = 6,
    GENERAL_ACHIEVEMENT_7                   = 7,
    GLUTTON_FOR_PUNISHMENT_ACHIEVEMENT_8    = 8,
    SNOWBIRD_ACHIEVEMENT_9                  = 9,
    TROPICAN_ACHIEVEMENT_10                 = 10,
    HAZE_FOR_DAYS_ACHIEVEMENT_11            = 11,
    CITIZEN_OF_CHANGSHA_ACHIEVEMENT_12      = 12,
    ARCHAEOLOGIST_ACHIEVEMENT_13            = 13,
    PYROMANCER_ACHIEVEMENT_14               = 14,
    VALLEY_GIRL_ACHIEVEMENT_15              = 15,
    KING_OF_THE_HILL_ACHIEVEMENT_16         = 16,
    ACE_OF_BASES_ACHIEVEMENT_17             = 17,
    CAPTURE_THE_VICTORY_ACHIEVEMENT_18      = 18,
    VERY_IMPORTANT_ACHIEVEMENT_19           = 19,
    NO_I_IN_TEAM_ACHIEVEMENT_20             = 20,
    ALL_THAT_GLITTERS_ACHIEVEMENT_21        = 21,
    BACKUP_ACHIEVEMENT_22                   = 22,
    CENTURION_ACHIEVEMENT_23                = 23,
    HOT_POTATO_ACHIEVEMENT_24               = 24,
    GRENADIER_ACHIEVEMENT_25                = 25,
    DESTROYER_ACHIEVEMENT_26                = 26,
    BRINGER_OF_WRATH_ACHIEVEMENT_27         = 27,
    MEDIC_ACHIEVEMENT_28                    = 28,
    SURGEON_ACHIEVEMENT_29                  = 29,
    ELIMINATOR_ACHIEVEMENT_30               = 30,
    ANNIHILATOR_ACHIEVEMENT_31              = 31,
    FLYSWATTER_ACHIEVEMENT_32               = 32,
    AVERAGE_JOES_ACHIEVEMENT_33             = 33,
    VERSUS_GOLIATH_ACHIEVEMENT_34           = 34,
    MORE_LIKE_TECH_STOPS_ACHIEVEMENT_35     = 35,
    MASTER_OF_NONE_ACHIEVEMENT_36           = 36,
    MASTER_OF_ALL_ACHIEVEMENT_37            = 37,
    CRACKIN_SKULLS_ACHIEVEMENT_38           = 38,
    DEADEYE_ACHIEVEMENT_39                  = 39,
    BOOM_ACHIEVEMENT_40                     = 40,
    DINE_AND_DASH_ACHIEVEMENT_41            = 41,
    CANT_STOP_ME_NOW_ACHIEVEMENT_42         = 42,
    FLOAT_LIKE_A_BUTTERFLY_ACHIEVEMENT_43   = 43,
};
 
USTRUCT(BlueprintType)
struct FServerInfo
{
    GENERATED_USTRUCT_BODY()
 
    UPROPERTY(BlueprintReadWrite)
    FString ServerName = "";
    UPROPERTY(BlueprintReadWrite)
    bool bOfficial = false;
    UPROPERTY(BlueprintReadWrite)
    FString MapName = "";
    UPROPERTY(BlueprintReadWrite)
    int32 PlayersCurrent = -1;
    UPROPERTY(BlueprintReadWrite)
    EGameType GameType = EGameType::NONE;
    UPROPERTY(BlueprintReadWrite)
    int32 DifficultyLevel = 254;
    UPROPERTY(BlueprintReadWrite)
    int32 PlayerMaximum = -1;
    UPROPERTY(BlueprintReadWrite)
    FString Region = "";
    UPROPERTY(BlueprintReadWrite)
    int32 Ping = -1;
    UPROPERTY(BlueprintReadWrite)
    int32 VersionNumber = -1;
    UPROPERTY(BlueprintReadWrite)
    int32 BranchNumber = -1;
    UPROPERTY(BlueprintReadWrite)
    bool bAntiCheatEnabled = true;
    UPROPERTY(BlueprintReadWrite)
    bool bHasPassword = false;
    UPROPERTY(BlueprintReadWrite)
    TArray<FString> Mods;
    UPROPERTY(BlueprintReadWrite)
    bool bHasWhiteList = false;
 
    static bool CompareServer(const ESortParameter Parameter, bool bSortDescending, const FServerInfo& ServerInfoA, const FServerInfo& ServerInfoB)
    {
        switch (Parameter)
        {
        case ESortParameter::ServerName:
            if (ServerInfoA.ServerName != ServerInfoB.ServerName)
            {
                return bSortDescending ? ServerInfoA.ServerName < ServerInfoB.ServerName : ServerInfoA.ServerName > ServerInfoB.ServerName;
            }
            break;
        case ESortParameter::Official:
            if (ServerInfoA.bOfficial != ServerInfoB.bOfficial)
            {
                return  bSortDescending ? ServerInfoA.bOfficial > ServerInfoB.bOfficial : ServerInfoA.bOfficial < ServerInfoB.bOfficial;
            }
            break;
        case ESortParameter::Mode:
            if (ServerInfoA.GameType != ServerInfoB.GameType)
            {
                return bSortDescending ? ServerInfoA.GameType < ServerInfoB.GameType : ServerInfoA.GameType > ServerInfoB.GameType;
            }
            break;
        case ESortParameter::PlayerCount:
            if (ServerInfoA.PlayersCurrent != ServerInfoB.PlayersCurrent)
            {
                return bSortDescending ? ServerInfoA.PlayersCurrent > ServerInfoB.PlayersCurrent : ServerInfoA.PlayersCurrent < ServerInfoB.PlayersCurrent;
            }
            break;
        case ESortParameter::MapName:
            if (ServerInfoA.MapName != ServerInfoB.MapName)
            {
                return bSortDescending ? ServerInfoA.MapName < ServerInfoB.MapName : ServerInfoA.MapName > ServerInfoB.MapName;
            }
            break;
        case ESortParameter::Ping:
            if (ServerInfoA.Ping != ServerInfoB.Ping)
            {
                return bSortDescending ? ServerInfoA.Ping < ServerInfoB.Ping : ServerInfoA.Ping > ServerInfoB.Ping;
            }
            break;
        case ESortParameter::AntiCheat:
            if (ServerInfoA.bAntiCheatEnabled != ServerInfoB.bAntiCheatEnabled)
            {
                return bSortDescending ? ServerInfoA.bAntiCheatEnabled > ServerInfoB.bAntiCheatEnabled : ServerInfoA.bAntiCheatEnabled < ServerInfoB.bAntiCheatEnabled;
            }
        case ESortParameter::MODS:
            if (ServerInfoA.Mods.Num() != ServerInfoB.Mods.Num())
            {
                return bSortDescending ? ServerInfoA.Mods.Num() < ServerInfoB.Mods.Num() : ServerInfoA.Mods.Num() > ServerInfoB.Mods.Num();
            }
        case ESortParameter::WhiteList:
            if (ServerInfoA.bHasWhiteList != ServerInfoB.bHasWhiteList)
            {
                return bSortDescending ? ServerInfoA.bHasWhiteList > ServerInfoB.bHasWhiteList : ServerInfoA.bHasWhiteList < ServerInfoB.bHasWhiteList;
            }
        case ESortParameter::Difficulty:
            if (ServerInfoA.DifficultyLevel != ServerInfoB.DifficultyLevel)
            {
                return bSortDescending ? ServerInfoA.DifficultyLevel > ServerInfoB.DifficultyLevel : ServerInfoA.DifficultyLevel < ServerInfoB.DifficultyLevel;
            }
        }
 
        return ServerInfoA > ServerInfoB;
    }
 
    bool operator >(const FServerInfo& Other) const
    {
        if (ServerName != Other.ServerName)
        {
            return ServerName < Other.ServerName;
        }
 
        if (bOfficial != Other.bOfficial)
        {
            return bOfficial > Other.bOfficial;
        }
 
        if (bAntiCheatEnabled != Other.bAntiCheatEnabled)
        {
            return bAntiCheatEnabled > Other.bAntiCheatEnabled;
        }
 
        if (GameType != Other.GameType)
        {
            return GameType < Other.GameType;
        }
 
        if (PlayersCurrent != PlayersCurrent)
        {
            return PlayersCurrent < Other.PlayersCurrent;
        }
 
        if (MapName != Other.MapName)
        {
            return MapName < Other.MapName;
        }
 
        if (Ping!= Other.Ping)
        {
            return Ping < Other.Ping;
        }
 
        if (bHasWhiteList != Other.bHasWhiteList)
        {
            return bHasWhiteList > Other.bHasWhiteList;
        }
 
        if (DifficultyLevel != Other.DifficultyLevel)
        {
            return DifficultyLevel > Other.DifficultyLevel;
        }
 
        return true;
    }
 
    FOnlineSessionSearchResult Session;
};
 
USTRUCT(BlueprintType)
struct FServerScore
{
    GENERATED_USTRUCT_BODY()
    FServerScore() {};
    FServerScore(const FServerInfo& InServerInfo, float InScore) { ServerInfo  = InServerInfo; Score = InScore; }
 
    UPROPERTY(BlueprintReadWrite)
    FServerInfo ServerInfo = FServerInfo();
    UPROPERTY(BlueprintReadWrite)
    float Score = 0.f;
 
    bool operator >(const FServerScore& Other) const
    {
        return Score > Other.Score;
    }
};
 
USTRUCT(BlueprintType)
struct FNakamaUser
{
    GENERATED_USTRUCT_BODY()
    FNakamaUser() {};
    FNakamaUser(const FString& NewUserName, const FString& NewSteamID) {UserName = NewUserName; SteamID = NewSteamID; }
    UPROPERTY(BlueprintReadWrite)
    FString UserName = "";
    UPROPERTY(BlueprintReadWrite)
    FString SteamID = "";
};
 
USTRUCT(BlueprintType)
struct FUsers
{
    FUsers()
    {
        Users = TMap<FString, FNakamaUser>();
    }
    GENERATED_USTRUCT_BODY()
    UPROPERTY(BlueprintReadWrite)
    TMap<FString, FNakamaUser> Users = TMap<FString, FNakamaUser>();
};
 
UENUM(BlueprintType)
enum class ERewardType :uint8 
{
    ReferAFriend = 0,
    FoundersDLC = 1,
    DailyLogin = 2,
    TwitchRewards = 3
};
 
UENUM(BlueprintType)
enum class EJoinSessionResponse :uint8
{
    Success,
    SessionIsFull,
    SessionDoesNotExist,
    CouldNotRetrieveAddress,
    AlreadyInSession,
    UnknownError
};
 
USTRUCT(BlueprintType)
struct FRewardShowcase
{   
    GENERATED_USTRUCT_BODY()
    
    FRewardShowcase() {}
    FRewardShowcase(const TArray<FString>& Items, int32 Currency, int32 Experience)
    {
        ItemUnlockShowcase = Items;
        CurrencyShowcase = Currency;
        ExpShowcase = Experience;
    }
 
    UPROPERTY(BlueprintReadWrite)
    TArray<FString> ItemUnlockShowcase;
    UPROPERTY(BlueprintReadWrite)
    int32 CurrencyShowcase = INDEX_NONE;
    UPROPERTY(BlueprintReadWrite)
    int32 ExpShowcase = INDEX_NONE;
};
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams(FOnWorldOriginChangedSignature, class UWorld*, InWorld, FIntVector, PreviousOriginLocation, FIntVector, NewOriginLocation);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnSessionSearchCompleteSignature, const TArray<FServerInfo>&, ServerInfos);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnSessionJoinCompleteSignature, EJoinSessionResponse, JoinResult);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnSessionMatchmakingSignature, bool, bIsMatchMaking);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnSessionDestroyCompleteSignature, bool, bComplete);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnSessionEventSignature, ESessionState, State);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FSettingChanged, const float, Delta);
DECLARE_DYNAMIC_MULTICAST_DELEGATE(FOnRestartPendingSignature);
DECLARE_DYNAMIC_MULTICAST_DELEGATE(FOnFounderDLCUnlockSignature);
DECLARE_DYNAMIC_MULTICAST_DELEGATE(FOnShowcaseItems);
DECLARE_DYNAMIC_MULTICAST_DELEGATE(FOnTwitchIntegrationVerified);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FOnMenuStateChanged, UAdvancedUserWidget*, Widget, bool, bToggle);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnUsersLoadedSignature, const FUsers&, FoundUsers);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FOnNakamaUserIDFoundSignature, const FString&, FoundID, const FString&, ForID);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FOnDailyRewardsSignature, int, Currency, int, Experience);
DECLARE_DYNAMIC_MULTICAST_DELEGATE(FOnNakamaManagerInitializedSignature);
DECLARE_DYNAMIC_DELEGATE_TwoParams(FOnNakamaUserIDFound, const FString&, NakamaID, const FString&, SteamID);
DECLARE_DYNAMIC_DELEGATE_OneParam(FOnNakamaDailyLoginRewardsFound, bool, bLoginBonusAvailable);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnUserInfoRequested, const FString&, ID);
DECLARE_DYNAMIC_DELEGATE_TwoParams(FUserRequestCallbackSignature, const FString&, ID, const FString&, NickName);
 
DECLARE_DELEGATE_TwoParams(FOnNakamaUserIDsFoundSignature, const TArray<FString>&, const TSharedPtr<FJsonObject>&);
 
 
UCLASS(Config = Game)
class PROJECTX_API UProjectXGameInstance : public UGameInstanceLoadingScreen
{
    GENERATED_BODY()
 
public:
    void SetServerPendingRestart();
    virtual void Shutdown() override;
    virtual void Init() override;
    virtual void OnStart() override;
    virtual void CheckForInstanceRestart();
    void DownloadModsHeadless();
#if !IS_CONSOLE_PLATFORM
    void ModDownloadCompleteHeadless(FModioResponse Response, bool bSuccess);
#endif
    void InstallModsHeadless();
    void OnClientTravel(const FString& PendingURL, ETravelType TravelType, bool bIsSeamlessTravel);
    void OnBackBufferReady_RenderThread(SWindow& SlateWindow, const FTexture2DRHIRef& BackBuffer);
    void CopyTextureImpl(const FTexture2DRHIRef& Src, FTexture2DRHIRef& Dst, FRHIGPUFence* GPUFence);
    void DisableSoftwareCursor();
    void BeginClientAntiCheatSession();
    void EndClientAntiCheatSession();
 
    void OnAntiCheatMessageToServer(TArrayView<const uint8> Message);
    void OnAntiCheatClientViolation(const FString& Reason);
 
    UFUNCTION(BlueprintCallable)
    bool GetUnlockedItemsPlayerMayHaveMissed(ERewardType Type, FRewardShowcase& FoundReward);
    UFUNCTION(BlueprintCallable, Category="Online Subsystem")
    void FindAllSessions(bool bLan);
    UFUNCTION(BlueprintCallable, Category="Online Subsystem")
    void CancelJoinSession();
    UFUNCTION(BlueprintCallable, Category = "Online Subsystem")
    void LeaveSession();
    UFUNCTION(BlueprintCallable, Category = "Online Subsystem")
    void FindAndJoinBestSession(EGameType GameType);
    UFUNCTION(BlueprintCallable, Category = "Online Subsystem" , meta = (AutoCreateRefTerm = "Difficultylevels"))
    void FindAndJoinBestSessionForTypes(const TArray<EGameType> GameTypes, TArray<EDifficultyLevel> Difficultylevels, bool bShouldSearchFreshServersOnly = false);
    UFUNCTION(BlueprintCallable, Category = "Online Subsystem")
    void JoinSession(const FServerInfo& SessionInfo);
    bool FinishJoinSession(ULocalPlayer* LocalPlayer, const FOnlineSessionSearchResult& SearchResult);
    
    UFUNCTION(BlueprintPure, Category = "Online Subsystem")
    bool CanUpdateSessionState() const;
    UFUNCTION(BlueprintPure, Category = "Online Subsystem")
    float GetInstanceUptime() const { return UpTime; }
    UFUNCTION(BlueprintCallable)
    const TArray<FServerInfo>& GetServerInfos() const { return SavedServerInfos; }
 
    UFUNCTION(BlueprintPure, Category = GameInstance)
    FORCEINLINE FIntVector GetLastOriginShiftDelta() const { return LastOriginShiftDelta; }
    UFUNCTION(BlueprintPure, Category = GameInstance)
    FORCEINLINE class UStatsTrackingManager* GetStatsTrackingManager() const { return StatsTracker; }
    UFUNCTION(BlueprintPure, Category = GameInstance)
    FORCEINLINE UNakamaManager* GetNakamaManager() { return NakamaManager; }
    UFUNCTION(BlueprintPure, Category = GameInstance)
    FORCEINLINE UCosmeticsManager* GetCosmeticsManager() { return CosmeticManager; }
    UFUNCTION(BlueprintPure, Category = Cosmetics)
    FORCEINLINE UDataTable* GetCosmeticsTable() const { return MasterCosmeticTable; }
    UFUNCTION(BlueprintPure, Category = Cosmetics)
    FORCEINLINE UDataTable* GetPerkTable() const {return PerksTable;}
    UFUNCTION(BlueprintPure, Category = Cosmetics)
    FORCEINLINE UDataTable* GetChallengeTable() const { return ChallengeTable; }
    UFUNCTION(BlueprintPure, Category = Cosmetics)
    FORCEINLINE bool IsLoginBonusAvailable() const { return bLoginBonusAvailable; }
    UFUNCTION(BlueprintPure, Category = Cosmetics)
    FORCEINLINE UDataTable* GetRarityWeightTable() const {return RarityWeightTable;}
    UFUNCTION(BlueprintPure, Category = GameState)
    const TArray<TSubclassOf<class AProjectXCharacter>>& GetPlayerClassList() const { return PlayerClassList; }
    UFUNCTION(BlueprintPure, Category = GameState)
    const TArray<TSubclassOf<class AProjectXVehicle>>& GetVehicleClassList() const { return VehicleClassList; }
    UFUNCTION(BlueprintPure, Category = GameState)
    const TArray<FString>& GetAchievementMapNameList() const { return AchievementMapNameList; }
    UFUNCTION(BlueprintPure, Category = GameState)
    TSubclassOf<AProjectXMapCamera> GetMapCameraClass() const { return MapCameraClass; }
    UFUNCTION(BlueprintPure, Category = GameState)
    void GetWeaponList(TArray<TSubclassOf<class UWeaponInstance>>& WeaponList,EEquipSlot Slot) const;
    UFUNCTION(BlueprintCallable)
    const FLinearColor& GetRarityColour(ERarity Rarity) const { return RarityColours.Contains(Rarity) ? RarityColours[Rarity] : FLinearColor::Black; }
    UFUNCTION(BlueprintPure)
    const FLinearColor& GetAllyColour(const FName& ColourName = NAME_None) const;
    UFUNCTION(BlueprintPure)
    const FLinearColor& GetEnemyColour(const FName& ColourName = NAME_None) const;
    UFUNCTION(BlueprintPure)
    const FLinearColor& GetSquadmateColour() const;
    UFUNCTION(BlueprintPure)
    ESessionState GetSessionState() const {return SessionState;}
    UFUNCTION(BlueprintCallable)
    bool IsMatchmaking() const { return bIsMatchMaking; }
    UFUNCTION(BlueprintCallable)
    void SetCaptureBackBuffer(bool bCaptureBackBuffer) { bCaptureBackBufferAndStream.AtomicSet(bCaptureBackBuffer); }
    UFUNCTION(BlueprintPure)
    static void GetCurrentLevelName(FString& LevelName);
    UFUNCTION(BlueprintPure)
    static void GetCurrentLevelNameForClients(FString& LevelName);
    UFUNCTION(BlueprintCallable)
    void UpdateClientPassword(UPARAM(ref)const FString& NewPassword) { ClientPassword = NewPassword; }
    UFUNCTION(BlueprintCallable)
    void LoadNakamaUsers(const TArray<FString>& NakamaIds);
    const FString& GetClientPassword() { return ClientPassword; }
    UFUNCTION(BlueprintCallable)
    void AskForNakamaIdFromSteamID(const FString& SteamID,FOnNakamaUserIDFound Callback);
    UFUNCTION(BlueprintCallable)
    const TArray<FString>& GetFriendsList() const {return Friends;}
    UFUNCTION(BlueprintCallable)
    void RequestUserInfo(const FString& PlayerID, FUserRequestCallbackSignature Callback);
    UFUNCTION(BlueprintCallable)
    bool IsRewardLoaded(ERewardType Type) const;
    UPlayerProgressionManager* GetPlayerProgression() const { return PlayerProgression; }
    static UProjectXGameInstance* GetGameInstance(int32 bServer = INDEX_NONE);
    AProjectXGameSession* GetGameSession() const;
    const TArray<TSubclassOf<ULevelInfo>>& GetMapList() const { return MapList; }
    const void GetMapNameList(TArray<FString>& MapNameList, bool bShowMode = false, bool bShowSize = false) const;
 
    TSubclassOf<class UOnlineSession> GetOnlineSessionClass() override;
 
    const FString& GetSessionID() const { return SessionID; }
    template <class T>
    FORCEINLINE static T* GetGameInstance() { return Cast<T>(GetGameInstance()); }
 
    void SetPendingInvite(const FPXPendingInvite& NewPendingInvite) { PendingInvite = NewPendingInvite; }
    void ToggleLevelLighting(bool bActiveLighting);
    void AskForNakamaIdsFromSteamIDs(const TArray<FString>& SteamIDs, FOnNakamaUserIDsFoundSignature FoundNakamaUsersCallback);
 
    UFUNCTION()
    virtual void SetKickReason(const FString& InKickReason);
    UFUNCTION(BlueprintCallable, Category = GameInstance)
    virtual void ConsumeKickReason(FString& OutKickReason);
    UFUNCTION()
    virtual void OnNakamaConnected();
    UFUNCTION(BlueprintPure)
    static void UpdateSortParameters(ESortParameter SortParamater,bool bSortDescending, const TArray<FServerInfo>& Info, TArray<FServerInfo>& SortedInfos);
    UFUNCTION(BlueprintPure)
    bool DoesServerOnlyAllowWhitelistedPlayers() const { return WhitelistedPlayers.Num() != 0; }
    UFUNCTION(Exec)
    void OverrideAuthoritativeStat(const FString& StatKey, int Value);
    UFUNCTION(Exec)
    void LevelToTarget(const FString& StatKey, int Value);
    bool IsServerRestarting() const { return bServerRestartPending; }
 
    //This one could eventually become a voice pack. Consider it player-mutable
    UAnnouncerSoundDataAsset* GetAnnouncerData() const { return AnnouncementDataSet; }
    //This one isn't meant to change and covers things like the store
    UAnnouncerSoundDataAsset* GetGeneralAnnouncerData() const { return GeneralAnnouncementDataSet; }
 
    UPROPERTY(BlueprintAssignable)
    FOnWorldOriginChangedSignature WorldOriginChangedEvent;
    UPROPERTY(BlueprintAssignable)
    FOnSessionSearchCompleteSignature SessionSearchCompleteEvent;
    UPROPERTY(BlueprintAssignable)
    FOnSessionSearchCompleteSignature OnSessionsListUpdatedEvent;
    UPROPERTY(BlueprintAssignable)
    FOnSessionJoinCompleteSignature SessionJoinCompleteEvent;
    UPROPERTY(BlueprintAssignable)
    FOnSessionDestroyCompleteSignature SessionDestroyCompleteEvent;
    UPROPERTY(BlueprintAssignable)
    FOnSessionEventSignature OnSessionStateUpdatedEvent;
    UPROPERTY(BlueprintAssignable)
    FOnSessionMatchmakingSignature OnSessionMatchmakingUpdated;
    UPROPERTY(BlueprintAssignable)
    FOnRestartPendingSignature OnServerRestartPending;
    UPROPERTY(BlueprintAssignable)
    FOnFounderDLCUnlockSignature OnShowFoundersPrompt;
    UPROPERTY(BlueprintAssignable)
    FOnShowcaseItems OnShowcaseUnlockedItems;
    UPROPERTY(BlueprintAssignable)
    FOnTwitchIntegrationVerified OnTwitchIntegrationVerified;
    UPROPERTY(BlueprintAssignable)
    FOnTwitchIntegrationVerified OnTwitchIntegrationRemoved;
    UPROPERTY(BlueprintAssignable)
    FOnMenuStateChanged OnMenuStateChanged;
    UPROPERTY(BlueprintAssignable)
    FOnUsersLoadedSignature OnNakamaUsersFoundEvent;
    UPROPERTY(BlueprintAssignable)
    FOnNakamaUserIDFoundSignature OnNakamaUserIDFoundEvent;
    UPROPERTY(BlueprintAssignable)
    FOnNakamaManagerInitializedSignature OnNakamaManagerInitializedEvent;
    UPROPERTY(BlueprintAssignable)
    FOnNakamaManagerInitializedSignature OnDailyLoginEvent;
    UPROPERTY(BlueprintAssignable, BlueprintCallable)
    FSettingChanged OnFOVSettingChanged;
    UPROPERTY(BlueprintAssignable)
    FOnUserInfoRequested OnUserInfoReceivedEvent;
 
    FOnNakamaUserIDsFoundSignature OnNakamaUserIDsFoundEvent;
 
    UPROPERTY(EditDefaultsOnly, Category = Configuration)
    USoundAttenuation* ShooterSoundAttenuation = nullptr;
    UPROPERTY(EditDefaultsOnly, Category = Configuration)
    USoundConcurrency* HitConcurrency = nullptr;
 
    UFUNCTION(BlueprintPure, Category = "Culture")
    TArray<FText> GetSupportedLanguages() const;
    UFUNCTION(BlueprintPure, Category = "Culture")
    FName GetCurrentCulture() const { return CurrentLanguage; }
    UFUNCTION(BlueprintCallable, Category = "Culture")
    void ChangeCulture(FName LanguageCode, bool bPromptRestart = false, bool bForce = false);
    void FinishChangeCulture(FName InLanguageOverride, bool bRestartToMenu = false);
 
    UFUNCTION(BlueprintPure)
    void GetTwitchAccountInfo(FString& Username, FString& Avatar) const { Username = TwitchUserName; Avatar = TwitchAvatar; }
    UFUNCTION(BlueprintPure)
    bool HasValidTwitchAccountLinked() const { return bIsTwitchIntegratedOnThisAccount; }
    UFUNCTION(BlueprintCallable)
    void LinkTwitchAccount();
    UFUNCTION(BlueprintCallable)
    void UnlinkTwitchAccount();
    UFUNCTION()
    void InitTwitch();
    UFUNCTION()
    void CheckReferAFriend();
    UFUNCTION()
    void CheckLoginBonus();
    UFUNCTION(BlueprintCallable)
    void ConsumeLoginBonus(FOnNakamaDailyLoginRewardsFound OnLoginBonusFound);
    void VerifyTwitchIntegration(bool bCheckInBackground = true);
    void OnTwitchIntegrationFailed();
    void CheckForTwitchRewards(bool ShowRewardsImmediately = false);
    void OnTwitchIntegrationSuccess();
 
    void RewardLoadResponse(ERewardType Type,const FRewardShowcase& Rewards);
 
    void GotoState(FName NewState, bool bInitiateLevelLoad = true, bool bForce = false);
    void Open(FString OpenString);
    void Open(FName LevelName, bool bAbsolute = true, FString Options = "");
    void FinishOpen(FString OpenString);
    void FinishOpen(FName LevelName, bool bAbsolute, FString Options);
    void SetPresenceForPlayer(const FString& StatusStr, const FVariantData& PresenceData);
    void AdvancePlatformDependentEngagement(bool bAllowed, EProjectXPrivilegeResult Result);
    void AdvancePlatformDependentEngagement2(bool bAllowed, EProjectXPrivilegeResult Result);
    UFUNCTION(BlueprintCallable, Category = Permission)
    void HasOnlinePermissions(EProjectXPrivileges PrivelegeToCheck, const FPrivilegeSignature& Callback);
    FPrivilegeSignature OnlinePermissionsCallback;
    TArray<FPermissionCheckQueue> PermissionChecks;
 
    void OnPermissionsChecked(const FUniqueNetId& UserId, EUserPrivileges::Type Privilege, uint32 PrivilegeResults);
    FName CurrentLanguage = NAME_None;
    bool bIsTwitchIntegratedOnThisAccount = false;
    FString TwitchUserName = "";
    FString TwitchAvatar = "";
 
    FName CurrentState = ProjectXGameInstanceState::WelcomeScreen;
    EOnlineMode OnlineMode;
    bool bIsLicensed = false;
    int PendingControllerIndex = INDEX_NONE;
    FPXPendingInvite PendingInvite;
    bool bMightBeSilver = false;
 
    /* Game Mode Defaults */
    UPROPERTY(EditDefaultsOnly, Category = GameState)
    TArray<FLanguageDefinition> SupportedLanguages;
    UPROPERTY(EditDefaultsOnly, Category = GameState)
    TMap<EGameType, FText> GameModeNames;
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = GameState)
    TMap<FString, FText> EnumStringMap;
    UPROPERTY(EditDefaultsOnly, GlobalConfig, Category = GameState)
    TMap<FName, FLinearColor> AllyColours;
    UPROPERTY(EditDefaultsOnly, GlobalConfig, Category = GameState)
    TMap<FName, FLinearColor> EnemyColours;
    UPROPERTY(EditDefaultsOnly, Category = GameState)
    TMap<ERarity, FLinearColor> RarityColours;
    UPROPERTY(EditDefaultsOnly, GlobalConfig, Category = GameState)
    FLinearColor NeutralColor = FLinearColor::Gray;
    UPROPERTY(EditDefaultsOnly, GlobalConfig, Category = GameState)
    FLinearColor SquadmateColour = FLinearColor::Green;
    UPROPERTY(EditDefaultsOnly, GlobalConfig, Category = GameState)
    TArray<FText> TeamNames;
    UPROPERTY(EditDefaultsOnly, GlobalConfig, Category = GameState)
    TArray<FString> AchievementMapNameList;
    UPROPERTY(EditDefaultsOnly, GlobalConfig, Category = GameState)
    TArray<TSubclassOf<class AProjectXCharacter>> PlayerClassList;
    UPROPERTY(EditDefaultsOnly, GlobalConfig, Category = GameState)
    TArray<TSubclassOf<class AProjectXVehicle>> VehicleClassList;
    UPROPERTY(EditDefaultsOnly, GlobalConfig, Category = GameState)
    TSubclassOf<AProjectXMapCamera> MapCameraClass;
    UPROPERTY(EditDefaultsOnly, GlobalConfig, Category = AntiCheat)
    bool bEnableAntiCheatForServer = true;
    /* How long does this instance can stay alive before asking for restart? (seconds). Ignored if time is < 0
     After several hours, servers can start to show issues due to floating points imprecisions, it's important at this time that instances can restart to reset those increasing values. */
    UPROPERTY(EditDefaultsOnly, GlobalConfig, BlueprintReadOnly, Category = "Server Health")
    float InstanceRestartTime = 0.f;
    UPROPERTY(GlobalConfig)
    TArray<int32> ModIds;
    UPROPERTY(GlobalConfig)
    TArray<FString> WhitelistedAdmins;
    UPROPERTY(GlobalConfig)
    TArray<FString> WhitelistedPlayers;
 
    /* End Game Mode Defaults */
    UPROPERTY(EditDefaultsOnly, Category = GameState)
    TSoftObjectPtr<UDataTable> MatureWordsDatabase;
    UPROPERTY(EditDefaultsOnly, Category = GameState)
    TSubclassOf<UPlatformInputSymbols> PlatformInputSymbols;
    static TArray<FString> MatureWords;
    UPROPERTY(EditDefaultsOnly, Category = "AnnouncerData")
    UAnnouncerSoundDataAsset* AnnouncementDataSet = nullptr;
    UPROPERTY(EditDefaultsOnly, Category = "AnnouncerData")
    UAnnouncerSoundDataAsset* GeneralAnnouncementDataSet = nullptr;
    UPROPERTY(EditDefaultsOnly, Category = "AnnouncerData")
    USoundEffectSourcePresetChain* HelmetRadioEffect = nullptr;
    UPROPERTY(EditDefaultsOnly, Category = "Sound")
    USoundClass* LocalWeaponSoundClass = nullptr;
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly)
    class UTextureRenderTarget2D* FrameBufferAsRenderTexture = nullptr;
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly)
    UCurveFloat* NavLinkApproachCurve = nullptr;
 
    /*When Matchmaking, anything below this threshold will award the maximum ping score for the server*/
    UPROPERTY(EditDefaultsOnly, Category = Server)
    int AcceptablePingRange = 50;
    /* When matchmaking, any ping after this maximum will start to heavily impact on the ping score (negatively)*/
    UPROPERTY(EditDefaultsOnly, Category = Server)
    int MaximumPingRange = 150;
    /* When comparing the current player count of the server, if this value is > 0 we will use it as the ceiling instead of the server's max population to drive the playercount scoring */
    UPROPERTY(EditDefaultsOnly, Category = Server)
    int MatchmakingMaxPlayerCount = 60;
    UPROPERTY(EditDefaultsOnly, Category = Session)
    float SessionEventDelayLength = 5.0f;
    UPROPERTY(EditDefaultsOnly, Category = Session)
    float PartyHostSessionJoinDelay = 3.0f;
 
    UPROPERTY(EditDefaultsOnly)
    TSubclassOf<AProjectXCharacter> DefaultFavouriteCharacter;
    UPROPERTY(EditDefaultsOnly)
    TSubclassOf<UAfflictionInstance> DefaultMarkRemainingEnemiesAffliction = NULL;
    UPROPERTY(BlueprintReadOnly)
    bool bIsFoundersEdition = true;
    UFUNCTION(BlueprintPure)
    bool ShowFoundersPrompt();
 
    UFUNCTION(BlueprintNativeEvent)
    void OnPlatformDependentEngagementCompleted();
 
    bool bShowFoundersPrompt = false;
    UPROPERTY()
    FText CancelText = NSLOCTEXT("LEAP", "Cancel", "Cancel");
    UPROPERTY()
    FText OkText = NSLOCTEXT("LEAP", "OK", "Ok");
 
    FString GetModIdsAsString() const
    {
        FString Output = "";
        for (int32 ModId : ModIds)
        {
            Output += FString::FromInt(ModId) + ":";
        }
        Output = Output.LeftChop(1);
        return MoveTemp(Output);
    }
 
    const TMap<EAchievementData, int32>& GetAchievementMap() const { return AchievementMap; }
    TMap<ERewardType,FRewardShowcase> RewardShowcaseQue = TMap<ERewardType, FRewardShowcase>();
    uint8 LoadedRewards = 0;
protected:
    void OnNetworkTravelFailure(UWorld* InWorld, ETravelFailure::Type FailureType, const FString& ErrorString);
    void OnNetworkFailure(UWorld* InWorld, class UNetDriver* NetDriver, ENetworkFailure::Type FailureType, const FString& ErrorString);
    void SetOnlineMode(EOnlineMode InOnlineMode);
    void FindSessions(bool blan, bool bDelayResult, bool bMatchMaking);
    void UpdateSessionState(ESessionState NewSessionState);
 
    UFUNCTION()
    void JoinBestSession(const TArray<FServerInfo>& ServerInfos);
    UFUNCTION()
    void FindAllSessionsResponse(const TArray<FServerInfo>& ServerInfos);
    UPROPERTY()
    UPlayerProgressionManager* PlayerProgression = NULL;
 
private:
    /* Online Subsystem */
    TSharedPtr<class FOnlineSessionSearch> SessionSearch;
    FOnFindSessionsCompleteDelegate OnFindSessionsCompleteDelegate;
    FOnReadFriendsListComplete OnReadFriendsListComplete;
    FDelegateHandle OnFindSessionsCompleteDelegateHandle;
    FDelegateHandle OnJoinSessionsCompleteDelegateHandle;
    FDelegateHandle OnSearchSessionsCompleteDelegateHandle;
    FOnJoinSessionComplete::FDelegate OnJoinSessionCompleteDelegate;
    FDelegateHandle OnCreatePresenceSessionCompleteDelegateHandle;
    FOnDestroySessionCompleteDelegate OnDestroySessionCompleteDelegate;
    FDelegateHandle OnDestroySessionCompleteDelegateHandle;
    
    FTickerDelegate TickDelegate;
 
    FDelegateHandle TickDelegateHandle;
 
    void PostInit();
    void InitNakama();
    void OnlineSubsystemInit();
    void BeginAntiCheatSession(const FUniqueNetId& LocalUserId, ELoginStatus::Type Status);
 
    bool Tick(float DeltaSeconds);
#if !IS_CONSOLE_PLATFORM
    void ModDownloadsComplete(struct FModioResponse Response, bool bSuccess);
#endif
    void InstallMods();
    void OnModsInstalled();
 
    UFUNCTION()
    void GetFoundersDLC();
    UFUNCTION()
    void OnPostWorldOriginOffset(UWorld* InWorld, FIntVector PreviousOriginLocation, FIntVector NewOriginLocation);
 
    void LoadMods(TArray<int32>& ModsToLoad, bool bRefreshPluginDirectory = false);
    void OnJoinSessionComplete(FName SessionName, EOnJoinSessionCompleteResult::Type JoinCompletionResult);
    void JoinPartyToSearchResult(const FOnlineSessionSearchResult& SearchResult);
 
    void OnDestroySessionComplete(FName Sessionname, bool bSucessful);
    virtual bool JoinSession(ULocalPlayer* LocalPlayer, int32 SessionIndexInSearchResults) override;
    virtual bool JoinSession(ULocalPlayer* LocalPlayer, const FOnlineSessionSearchResult& SearchResult) override;
    bool HostGame(ULocalPlayer* LocalPlayer, const FString& GameType, const FString& InTravelURL);
    void OnCreatePresenceSessionComplete(FName SessionName, bool bWasSuccessful);
    void OnRegisterLocalPlayerComplete(const FUniqueNetId& PlayerId, EOnJoinSessionCompleteResult::Type Result);
    void FinishSessionCreation(EOnJoinSessionCompleteResult::Type Result);
    
    void OnSearchSessionCompleteDelay(bool bWasSuccessful);
    UFUNCTION()
    void OnSearchSessionsComplete(bool bWasSuccessful);
    
    void OnSessionUserInviteAcceptedClient(const bool bSuccess, const int32 ControllerId, TSharedPtr<const FUniqueNetId> UserId, const FOnlineSessionSearchResult& InviteSessionData);
    void OnSessionUserInviteReceivedClient(const FUniqueNetId& UserId, const FUniqueNetId& FromId, const FString& AppID, const FOnlineSessionSearchResult& InviteResult);
    void HandleSessionFailureServer(const FUniqueNetId& NetId, ESessionFailure::Type FailureType);
    void HandleSessionFailureClient(const FUniqueNetId& NetId, ESessionFailure::Type FailureType);
    void OnCreateGameSessionCompleted(FName InSessionName, bool bWasSuccessful);
    UFUNCTION()
    void OnFriendsChanged();
    UFUNCTION()
    void OnReadFriendListCompleteResponse(int32 LocalUserNum, bool bWasSuccessful, const FString& ListName, const FString& ErrorStr);
    void OnNakamaIdsFoundResponse(const TArray<FString>& SteamIds, const TSharedPtr<FJsonObject>& FoundNakamaUsers);
    void LoadFriendsListFromInterface();
#if !IS_CONSOLE_PLATFORM
    STEAM_CALLBACK(UProjectXGameInstance, OnRequestInfoResponse, PersonaStateChange_t);
#endif
    bool LoadFrontEndMap();
    void JoinFoundSession(int32 Id, bool Success, const FOnlineSessionSearchResult& Session);
    /* Use PlayerState->GetPlayerName() to get the replicated nickname. This should be used for debugging purposes only */
    FString GetPlayerNickname() const;
    static IOnlineIdentityPtr GetOnlineIdentity();
    /* End Online Subsystem */
 
    UPROPERTY();
    TArray<TSubclassOf<ULevelInfo>> MapList;
    UPROPERTY(GlobalConfig, EditDefaultsOnly, Category = Maps)
    TArray<TSoftClassPtr<ULevelInfo>> MapListConfig;
    UPROPERTY(EditDefaultsOnly, Category = Cosmetics)
    UDataTable* MasterCosmeticTable = NULL;
    UPROPERTY(EditDefaultsOnly, Category = Cosmetics)
    UDataTable* PerksTable = NULL;
    UPROPERTY(EditDefaultsOnly, Category = Cosmetics)
    UDataTable* ChallengeTable = NULL;
    UPROPERTY(EditDefaultsOnly, Category = Cosmetics)
    UDataTable* RarityWeightTable = NULL;
    //Current reason we were kicked from the server.
    UPROPERTY()
    FString KickReason = "";
 
    FString TravelURL = "";
 
    bool bAntiCheatClientSessionActive = false;
    TWeakObjectPtr<class UContextMenuWidget> ModDownloadWidget = nullptr;
    bool bStarted = false;
protected:
    UPROPERTY()
    class UStatsTrackingManager* StatsTracker = NULL;
    UPROPERTY()
    class UNakamaManager* NakamaManager = NULL;
    UPROPERTY()
    class UCosmeticsManager* CosmeticManager = NULL;
 
    UPROPERTY()
    URemoteConsole* RemoteConsole = NULL;
 
    UPROPERTY(BlueprintReadOnly, Category = "SimpleUGC")
    class UUGCRegistry* UGCRegistry = nullptr;
 
    int32 IgnorePairingChangeForControllerId;
    EOnlineServerConnectionStatus::Type CurrentConnectionStatus;
    FString ConsoleServerPort = "";
    FString ServerSecret = "";
    EServerPlatform ServerPlatform = EServerPlatform::PC;
    TArray<ELoginStatus::Type> LocalPlayerOnlineStatus;
 
    FString SessionID = "";
    FString ClientPassword = "";
    TArray<FString> Friends;
    TArray<FServerInfo> SavedServerInfos;
    FTimerHandle FindSessionDelayTimer;
    FTimerHandle JoiningSessionDelayTimer;
    FTimerHandle InstanceResetCheckTimer;
    FDelegateHandle WorldOriginDelegateHandle;
    FUsers UsersAccounts = FUsers();
    bool bIsMatchMaking = false;
    bool bLoadedFriendsListInterface = false;
    float UpTime = 0.0f;
    bool bLoginBonusAvailable = false;
    FThreadSafeBool bCaptureBackBufferAndStream = true;
 
    ESessionState SessionState = ESessionState::NONE;
    TArray<EGameType> GameTypesSearchParameter = TArray<EGameType>();
    TArray<EDifficultyLevel> DifficultyLevelsSearchParameter = TArray<EDifficultyLevel>();
    bool bSearchFreshServersOnly = false;
    bool bServerRestartPending = false;
    FIntVector LastOriginShiftDelta = FIntVector::ZeroValue;
 
    TMap<FString, FUserRequestCallbackSignature> UserInfoCallbackRequests;
    TMap<FString,FString> UserIDtoNicknameMap = TMap<FString,FString>();
    TArray<int32> ServerModsToLoad;
    FOnlineSessionSearchResult PostModDownloadSessionToJoin;
 
    UPROPERTY(EditDefaultsOnly, Category = Matchmaking)
    UCurveFloat* MatchmakingPingWeightCurve = nullptr;
    UPROPERTY(EditDefaultsOnly, Category = Matchmaking)
    UCurveFloat* MatchmakingPlayerWeightCurve = nullptr;
    UPROPERTY(EditDefaultsOnly, Category = Achievement)
    TMap<EAchievementData, int32> AchievementMap;
    bool bIsDownloadingMods = false;
};