CosmeticsManager.h

Go to the documentation of this file.

// Copyright Blue Isle Studios Inc 2018. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Runtime/Json/Public/Dom/JsonObject.h"
#include "CosmeticAssetBase.h"
#include "Stats/NakamaManager.h"
#include "Components/ActorComponent.h"
#include "PlayerStructs.h"
#include "CosmeticsManager.generated.h"
 
class AProjectXCharacter;
class UCosmeticAssetBase;
class UDataTable;
class UWeaponInstance;
class UAfflictionInstance;
class UProjectXGameInstance;
class AProjectXPlayerState;
 
UENUM(BlueprintType)
enum class EEquipType : uint8
{
    Cosmetic = 0,
    Weapon = 1,
    Perk = 2,
};
 
USTRUCT(BlueprintType)
struct FEquipItem
{
    GENERATED_USTRUCT_BODY()
    FEquipItem(){}
    FEquipItem(const FString& NewShortCode, bool bMarkDirty)  : ShortCode(NewShortCode), bDirty(bMarkDirty) {}
 
    bool UpdateShortCode(const FString& NewShortCode, bool bMarkDirty = true)
    {
        if (NewShortCode == ShortCode)
        {
            return false;
        }
 
        ShortCode = NewShortCode;
 
        if (bMarkDirty)
        {
            bDirty = bMarkDirty;
        }
 
        return true;
    }
 
    UPROPERTY(BlueprintReadOnly)
    FString ShortCode = "";
    bool bDirty = false;
};
 
USTRUCT(BlueprintType)
struct FEquipsList
{
    GENERATED_USTRUCT_BODY()
    FEquipsList(){}
    
    bool GetEquipItem(const FString& Key, FEquipItem& FoundItem)
    {
        if (!WeaponEquips.Contains(Key))
        {
            return false;
        }
 
        FoundItem = WeaponEquips[Key];
        return true;
    }
 
    bool GetEquipShortCode(const FString& Key, FString& FoundShortCode) const
    {
        if (!WeaponEquips.Contains(Key))
        {
            return false;
        }
 
        FoundShortCode = WeaponEquips[Key].ShortCode;
        return true;
    }
 
    bool UpdateEquipItem(const FString& Key, const FString& ShortCode,bool bMarkDirty = true)
    {
        if (!WeaponEquips.Contains(Key))
        {
            WeaponEquips.Add(Key, FEquipItem(ShortCode, bMarkDirty));
            return true;
        }
        else
        {
            return WeaponEquips[Key].UpdateShortCode(ShortCode, bMarkDirty);
        }
    }
 
    UPROPERTY(BlueprintReadOnly)
    TMap<FString, FEquipItem> WeaponEquips = TMap<FString, FEquipItem>();
};
 
USTRUCT(BlueprintType)
struct FEquips
{
    GENERATED_USTRUCT_BODY()
    FEquips()
    {
        for (uint8 i = 0; i <= (uint8)ECosmeticType::Perk; i++)
        {
            EquipsTypes.Add((ECosmeticType)i, FEquipsList());
        }
    }
 
    bool UpdateShortCode(ECosmeticType Type,const FString& Key,const FString& ShortCode, bool bMarkDirty = true)
    {
        if (!EquipsTypes.Contains(Type))
        {
            EquipsTypes.Add(Type, FEquipsList());
        }
 
        return EquipsTypes[Type].UpdateEquipItem(Key, ShortCode, bMarkDirty);
    }
 
    bool GetShortCode(ECosmeticType Type, const FString& Key, FString& FoundKey) const
    {
        if (!EquipsTypes.Contains(Type))
        {
            return false;
        }
 
        return EquipsTypes[Type].GetEquipShortCode(Key, FoundKey);
    }
 
    bool GetEquipsList(ECosmeticType Type,FEquipsList& FoundEquipsList)
    {
        if (!EquipsTypes.Contains(Type))
        {
            return false;
        }
 
        FoundEquipsList = EquipsTypes[Type];
        return true;
    }
 
    UPROPERTY(BlueprintReadOnly)
    TMap<ECosmeticType, FEquipsList> EquipsTypes = TMap<ECosmeticType, FEquipsList>();
    bool bLoaded = false;
};
 
UENUM()
enum class EColourSlot :uint8
{
    None = 0,
};
 
USTRUCT(BlueprintType)
struct FSharedPlayerInfo
{
    GENERATED_BODY()
 
public:
    FSharedPlayerInfo() {};
    UPROPERTY(BlueprintReadWrite)
    TSubclassOf<AProjectXCharacter> FavouritedClass = NULL;
    UPROPERTY(BlueprintReadWrite)
    TSubclassOf<UWeaponInstance> FavouriteWeapon = NULL;
    UPROPERTY(BlueprintReadWrite)
    FString BannerID = "";
    UPROPERTY(BlueprintReadWrite)
    FString PlayerSkinID = "";
    UPROPERTY(BlueprintReadWrite)
    FString WeaponSkinID = "";
    bool bDirty = true;
 
    bool operator==(const FSharedPlayerInfo& Other) const;
};
 
USTRUCT(BlueprintType)
struct FCosmeticDeals
{
    GENERATED_BODY()
public:
    FCosmeticDeals() {};
 
    FCosmeticDeals(int Year,int Month,int Day,int Hour, int Minutes,int HourDuration)
    {
        DealEndTime = FDateTime(Year, Month, Day, Hour, Minutes);
        Items = TMap<FString, int>();
    }
 
    UPROPERTY(BlueprintReadOnly)
    FDateTime DealEndTime = FDateTime::MinValue();
    UPROPERTY(BlueprintReadOnly)
    TMap<FString,int> Items = TMap<FString, int>();
};
 
USTRUCT(BlueprintType)
struct FCosmeticStoreItem
{
    GENERATED_BODY()
    
    FCosmeticStoreItem() {}
    FCosmeticStoreItem(ECosmeticType TypeIn, int32 CostIn, ERarity RarityIn,const FString& WeaponNameIn) : Type(TypeIn), Cost(CostIn), Rarity(RarityIn) {}
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Item Struct")
    ECosmeticType Type = ECosmeticType(0);
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Item Struct")
    int Cost = 0;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Item Struct")
    ERarity Rarity = ERarity::NONE;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Item Struct")
    int Amount = 0;
 
    bool bDirty = false;
};
 
USTRUCT(BlueprintType)
struct FGeneralCosmetics
{
    GENERATED_USTRUCT_BODY()
 
public:
    UPROPERTY(BlueprintReadWrite)
    FString GraffitiID = "";
    UPROPERTY(BlueprintReadWrite)
    FString AvatarBorderID = "";
    UPROPERTY(BlueprintReadWrite)
    FString BannerID = "";
    UPROPERTY(BlueprintReadWrite)
    TArray<FString> TauntIDs;
 
    bool GetCosmeticID(FString& Output, const ECosmeticType Type, uint8 Slot = -1) const;
    void UpdateCosmeticID(const ECosmeticType Type, const FString& CosmeticID, uint8 Slot = -1);
};
 
USTRUCT(BlueprintType)
struct FCosmeticReward
{
    GENERATED_USTRUCT_BODY()
 
    FCosmeticReward() {};
    FCosmeticReward(const FString& IDIn, int CurrencyConversionIn) : ID(IDIn), CurrencyConversion(CurrencyConversionIn) {}
 
 
    UPROPERTY(BlueprintReadWrite)
    FString ID = "";
    UPROPERTY(BlueprintReadOnly)
    int CurrencyConversion = 0;
};
 
USTRUCT(BlueprintType)
struct FCosmeticRewards
{
    GENERATED_USTRUCT_BODY()
    FCosmeticRewards() {}
    
    UPROPERTY(BlueprintReadWrite)
    TArray<FCosmeticReward> ItemRewards;
    UPROPERTY(BlueprintReadWrite)
    int CurrencyReward = -1;
};
 
 
USTRUCT(BlueprintType)
struct FItem
{
    GENERATED_USTRUCT_BODY()
 
    FItem(){}
    FItem(ECosmeticType ItemType, const FString& ItemClassID,const FText& ItemDisplayName,UCosmeticAssetBase* ItemAsset,ERarity NewRarity,int OwnedAmount,bool bIsStackable) : Type(ItemType), ClassID(ItemClassID),DisplayName(ItemDisplayName),Asset(ItemAsset),Rarity(NewRarity),Amount(OwnedAmount),bStackable(bIsStackable) {}
 
public:
    UPROPERTY(BlueprintReadWrite)
    ECosmeticType Type = ECosmeticType::Graffiti;
    UPROPERTY(BlueprintReadWrite)
    FString ClassID = "";
    UPROPERTY(BlueprintReadWrite)
    FText DisplayName;
    UPROPERTY(BlueprintReadWrite)
    UCosmeticAssetBase* Asset = NULL;
    UPROPERTY(BlueprintReadWrite)
    ERarity Rarity = ERarity::COMMON;
    UPROPERTY(BlueprintReadWrite)
    int Amount = 0;
    UPROPERTY(BlueprintReadWrite)
    int Level = 0;
    UPROPERTY(BlueprintReadWrite)
    bool bStackable = false;
    TSet<FString> EquipKeys;
    bool bDirty = false;
};
 
USTRUCT(BlueprintType)
struct FBestWeaponInfos
{
    GENERATED_USTRUCT_BODY()
public:
    UPROPERTY(BlueprintReadWrite)
    float Damage = 0.0f;
    UPROPERTY(BlueprintReadWrite)
    float ConeSpread= 0.0f;
    UPROPERTY(BlueprintReadWrite)
    float RateOfFire = 0.0f;
    UPROPERTY(BlueprintReadWrite)
    float MagSize = 0.0f;
};
 
USTRUCT(BlueprintType)
struct FPlayerEquipRequest
{
    GENERATED_USTRUCT_BODY()
public:
    UPROPERTY(BlueprintReadWrite)
    FString PlayerID = "";
    UPROPERTY(BlueprintReadWrite)
    FString EquipID = "";
};
 
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FLoadOutLoadedSignature, bool, bSucess);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FPurchaseSignature, bool, bSucess, const FString&, ItemID);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FEquippedCosmeticsLoadedSignature,const FString&, PlayerID);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams(FCosmeticRewardSignature, const TArray<FCosmeticReward>&, ItemIDs,int, Currency, bool, bFoundRewards);
DECLARE_DYNAMIC_MULTICAST_DELEGATE(FCosmeticsLoadedSignature);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FMenuConfigsLoadedSignature, const FSharedPlayerInfo&, PlayerInfo, const FString&, PlayerID);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FGeneralCosmeticsChangedSignature, const FGeneralCosmetics&, GeneralCosmetics, const FString&, PlayerID);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_FourParams(FChallengeRewardSignature, const FString&, ChallengeID, int32, Currency, int32, Experience, const TArray<FCosmeticReward>&, ItemList);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams(FPerksUpdatedSignature, TSubclassOf<AProjectXCharacter>, CharacterClass, TSubclassOf<UWeaponInstance>, WeaponClass, uint8, SlotID);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams(FEquipItemUpdatedSignature,ECosmeticType, Type, const FString&, ShortCode, const FString&, EquipKey);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_FourParams(FPlayerEquipItemUpdatedSignature,const FString&, PlayerID, ECosmeticType, Type, const FString&, ShortCode, const FString&, EquipKey);
 
const TMap<FString, int> Months = { {"Jan",1}, {"Feb",2}, {"Mar",3}, {"Apr",4}, {"May",5}, {"Jun",6}, {"Jul",7}, {"Aug",8}, {"Sep",9}, {"Oct",10}, {"Nov",11}, {"Dec",12} };
 
UCLASS( ClassGroup=(Custom), meta=(BlueprintSpawnableComponent) )
class PROJECTX_API UCosmeticsManager : public UActorComponent
{
    GENERATED_BODY()
 
public:
    UCosmeticsManager();
    void Init(UProjectXGameInstance* GameInstance);
    UFUNCTION(BlueprintPure, Category = PlayerProgressionManager, meta = (WorldContext = "WorldContextObject", CallableWithoutWorldContext))
    static UCosmeticsManager* GetCosmeticManager(const UObject* WorldContextObject);
    UFUNCTION()
    void EquipDefaults(bool bPostLoadEquip);
    UFUNCTION()
    virtual void OnNakamaConnected();
    UFUNCTION(BlueprintPure)
    const TMap<FString, FItem>& GetItemList() const { return InventoryItemList; }
    UFUNCTION(BlueprintPure)
    const FItem GetItemByShortCode(const FString& Shortcode) const { return InventoryItemList.Contains(Shortcode) ? InventoryItemList[Shortcode] : FItem(); }
    UFUNCTION(BlueprintPure)
    const bool DoesItemExist(const FString& Shortcode) const { return InventoryItemList.Contains(Shortcode); }
    UFUNCTION(BlueprintPure)
    const FEquips& GetEquips() const {return Equips;}
    UFUNCTION(BlueprintPure)
    void GetPlayerEquipItem(const TArray<FPlayerEquipRequest>& PlayerEquipRequests);
    UFUNCTION(BlueprintPure)
    const FString& GetLocalPlayerID() const { return CachedLocalPlayerID; }
    UFUNCTION(BlueprintCallable)
    const FCosmeticDeals& GetDailyDeal() const { return DailyDeals; }
    UFUNCTION(BlueprintCallable)
    const FCosmeticDeals& GetFeatureDeal() const { return FeatureDeals; }
    UFUNCTION(BlueprintCallable)
    const FBestWeaponInfos& GetBestWeaponInfos() const {return BestweaponInfos;}
    UFUNCTION(BlueprintCallable, BlueprintPure)
    bool GetEarnedRewards(FCosmeticRewards& Rewards) const;
    UFUNCTION(BlueprintCallable)
    void ClearEarnedRewards() { NewEarnedRewards = FCosmeticRewards(); }
    UFUNCTION(BlueprintCallable)
    bool GetPlayerInfo(const FString& PlayerID, FSharedPlayerInfo& FoundPlayerInfo) const;
    UFUNCTION(BlueprintCallable)
    void UpdateLocalPlayerInfo(const FSharedPlayerInfo& UpdatedPlayerInfo);
    UFUNCTION(BlueprintCallable)
    void UpdateLocalPlayerInfoFavouriteClass(TSubclassOf<AProjectXCharacter> CharacterClass);
    UFUNCTION(BlueprintCallable)
    void SaveLocalPlayerInfo();
    UFUNCTION(BlueprintCallable)
    void LoadSharedPlayerInfo(const TArray<FString>& PlayerIDs);
    UFUNCTION(BlueprintCallable)
    void LoadEarnedRewards(const FString& PlayerID) const;
    UFUNCTION(BlueprintCallable)
    void LoadAllCosmeticData(const FString& PlayerID);
    UFUNCTION(BlueprintCallable)
    void SavePlayerInventory();
    UFUNCTION(BlueprintCallable)
    bool PurchaseItemRequest(const FString& ItemID);
    UFUNCTION(BlueprintCallable)
    bool IsItemUnlocked(const FString& ItemID) const;
    UFUNCTION(BlueprintCallable)
    TSubclassOf<AProjectXCharacter> GetCharacterClassFromID(const FString& PlayerID) const;
    UFUNCTION(BlueprintCallable)
    void EquipItem(const FString& ShortCode, const FString& EquipCode);
    UFUNCTION(BlueprintCallable)
    void AddItemToUnlockList(const FString& ShortCode, bool bMaxOne);
    UFUNCTION(BlueprintCallable)
    void OnMatchComplete();
    void LoadInventoryFromItemList(const TArray<FString>& ShortCodes);
    void LoadPlayerInventory(std::string cursor = "");
    void UpdateSessionID(const FString& PlayerID,const FString& SessionID, const FString& ShortCode);
    void LoadStore();
    void ClearCosmeticData();
    void GetRandomCosmetic(FString& FoundID, const TArray<ECosmeticType>& IgnoredTypes, FItem& FoundCosmetic);
    const FString& GetShortCodeFromList(uint16 Number) const { return ShortCodesList.IsValidIndex(Number) ? ShortCodesList[Number] : FallBackCode; }
    const FString& GetEquipCodeFromList(uint16 Number) const { return EquipCodesList.IsValidIndex(Number) ? EquipCodesList[Number] : FallBackCode; }
    uint16 GetEquipCodeNumber(const FString& EquipCode) const;
    uint16 GetShortCodeNumber(const FString& ShortCode) const;
    bool CanLockCosmeticToThisSession(const FString& PlayerID,const FString& ShortCode, const FString& SessionId) const;
    const TMap<FString, FString>& GetSessionLockedCosmetics(const FString& PlayerID) const;
    UFUNCTION(BlueprintPure)
    static FString BuildCosmeticKeyFromClass(ECosmeticType Type, TSubclassOf<AProjectXCharacter> CharacterClass, TSubclassOf<UWeaponInstance> WeaponClass, uint8 SlotID = 0, EPerkType PerkType = EPerkType::NONE);
    UFUNCTION(BlueprintPure)
    static FString BuildCosmeticKeyFromString(ECosmeticType Type, const FString& ClassID, const FString& WeaponClassID, uint8 SlotID = 0, EPerkType PerkType = EPerkType::NONE);
    static void ParseCosmeticKey(ECosmeticType Type, const FString& EquipKey, FString& ClassID, FString& WeaponClassID, uint8& SlotID, EPerkType& PerkType);
    UFUNCTION(BlueprintPure)
    static bool GetEquippedItem(UPARAM(ref) const FEquips& Equips, ECosmeticType Type, UPARAM(ref) const FString& Key, FString& FoundItem);
    UFUNCTION(BlueprintPure)
    TSubclassOf<UWeaponInstance> GetEquippedWeaponInSlot(EEquipSlot Slot, TSubclassOf<AProjectXCharacter> CharacterClass, AProjectXPlayerState* const PlayerState);
    static void NakamaDateParser(const FString& DateIn, FDateTime& DateOut);
    static FCosmeticTable* FindRowByShortCode(const FString& ShortCode, UDataTable* Table);
    
    UPROPERTY(BlueprintAssignable)
    FPurchaseSignature PurchaseResponseEvent;
    UPROPERTY(BlueprintAssignable)
    FCosmeticRewardSignature OnNewRewardsEarned;
    UPROPERTY(BlueprintAssignable)
    FMenuConfigsLoadedSignature OnSharedPlayerInfoLoaded;
    UPROPERTY(BlueprintAssignable)
    FGeneralCosmeticsChangedSignature OnGeneralCosmeticsChangedEvent;
    UPROPERTY(BlueprintAssignable)
    FChallengeRewardSignature OnChallengeRewardsReceived;
    UPROPERTY(BlueprintAssignable)
    FLoadOutLoadedSignature OnPlayerInventoryLoaded;
    UPROPERTY(BlueprintAssignable)
    FCosmeticsLoadedSignature OnItemsInitialized;
    UPROPERTY(BlueprintAssignable)
    FCosmeticsLoadedSignature OnStoreLoaded;
    UPROPERTY(BlueprintAssignable)
    FEquipItemUpdatedSignature OnItemEquipped;
    UPROPERTY(BlueprintAssignable)
    FPlayerEquipItemUpdatedSignature OnOtherUserEquipsUpdated;
 
    TMap<FString, FSharedPlayerInfo> PlayerInfoList = TMap<FString, FSharedPlayerInfo>();
    TMap<ERarity, uint8> RarityWeights = TMap<ERarity, uint8>();
    FCosmeticRewards NewEarnedRewards = FCosmeticRewards();
    TMap<FString, FItem> InventoryItemList; 
    FCosmeticDeals DailyDeals = FCosmeticDeals();
    FCosmeticDeals FeatureDeals = FCosmeticDeals();
    FEquips Equips = FEquips();
    FBestWeaponInfos BestweaponInfos = FBestWeaponInfos();
    TMap<ECosmeticCategory, TArray<ECosmeticType>> CosmeticTypes = TMap<ECosmeticCategory, TArray<ECosmeticType>>();
    TMap<FString, TMap<FString,FString>> SessionLockedCosmetics = TMap<FString, TMap<FString, FString>>();
    TMap<FString, FEquips> UserEquips = TMap<FString, FEquips>();
 
protected:
    void InitializeItems();
    void InitializeEquips();
    void InitializeRarityWeights();
    void UpdateBestWeaponStat(UWeaponInstance* const Weapon);
    void PerkTableToInventory(UDataTable* const Table, TSubclassOf<AProjectXCharacter> Class,TSubclassOf<UWeaponInstance> WeaponClas, EPerkType Type);
    void PurchaseItemResponse(bool bSuccess,const FString& ItemID);
    void LoadStoreResponse(TSharedPtr<FJsonObject> StoreJson);
    void LoadPlayerInventoryResponse(std::vector<NAKAMA_NAMESPACE::NStorageObject> Inventory);
    void UnpackInventory(std::vector<NAKAMA_NAMESPACE::NStorageObject> Inventory);
    void RefreshFavouriteClassCosmetics();
 
    UFUNCTION(BlueprintCallable,BlueprintPure)
    static UDataTable* GetPerksList(UDataTable* const PerksTable, TSubclassOf<AProjectXCharacter> CharacterClass, TSubclassOf<UWeaponInstance> WeaponInstanceClass, EPerkType Type);
 
    FString CachedLocalPlayerID = "";   
    bool bUnlocksInitialized = false;
    bool bLoadoutsLoaded = false;
    bool bInventoryInitialized = false;
    FString FallBackCode = "";
    TArray<FString> ShortCodesList;
    TArray<FString> EquipCodesList;
    TWeakObjectPtr<UProjectXGameInstance> GameInstance;
    TMap<FString, FString> DefaultFoundLockedCosmetics = TMap<FString, FString>();
public:
    UFUNCTION(BlueprintCallable)
    static UDataTable* const GetDataTableByType(ECosmeticType Type, UObject* WorldContextObject);
};