DamageHistoryComponent.h

Go to the documentation of this file.

// Copyright Blue Isle Studios Inc 2018. All Rights Reserved.
 
#pragma once
 
#include "ProjectX.h"
#include "CoreMinimal.h"
#include "Components/ActorComponent.h"
#include "ProjectXDamageType.h"
#include "DamageHistoryComponent.generated.h"
 
class AActor;
struct FDamageEvent;
class APlayerState;
 
USTRUCT(BlueprintType)
struct FKillHistory
{
    GENERATED_USTRUCT_BODY()
public:
    FKillHistory()
    {
    }
 
    FKillHistory(APlayerState* InKilled, const float InTime);
 
    float GetKillTime() const { return KillTime; }
    TWeakObjectPtr<APlayerState> GetKillHistoryPlayer() const { return KillHistoryPlayer; }
 
protected:
    float KillTime = 0.0f;
    TWeakObjectPtr<APlayerState> KillHistoryPlayer = NULL;
};
 
USTRUCT(Blueprintable)
struct FHistoryEntry
{
    GENERATED_USTRUCT_BODY()
 
public:
    FHistoryEntry()
    {
 
    }
 
    FHistoryEntry(const float InDamage, const AController* InInstigator, const float InLastHitTime, TSubclassOf<UProjectXDamageType> InDamageType)
    {
        Damage = InDamage;
        Instigator = const_cast<AController*>(InInstigator);
        LastHitTime = InLastHitTime;
        MostRecentDamage = InDamageType;
        UpdateMostRecentDamage(InDamage, InDamageType);
    }
 
    void UpdateMostRecentDamage(const float InDamage,const TSubclassOf<UProjectXDamageType>& InDamageType)
    {
        if (InDamageType == NULL)
        {
            return;
        }
        if (DamageTypesMap.Contains(InDamageType))
        {
            DamageTypesMap[InDamageType] += Damage;
        }
        else
        {
            DamageTypesMap.Add(InDamageType, Damage);
        }
        MostRecentDamage = InDamageType;
    }
 
    TSubclassOf<UProjectXDamageType> GetHighestDamageType() const
    {
        float HighestDamage = 0;
        TSubclassOf<UProjectXDamageType> DamageTypeOut = NULL;
        for (auto& Elem : DamageTypesMap)
        {
            if (Elem.Value > HighestDamage)
            {
                HighestDamage = Elem.Value;
                DamageTypeOut = Elem.Key;
            }
        }
        return DamageTypeOut;
    }
 
    //The damage event associated with this entry
    FDamageEvent DamageEvent;
 
    //Total damage this player has caused
    float Damage = 0.f;
 
    //The damage instigator
    TWeakObjectPtr<AController> Instigator = NULL;
    
    TMap<TSubclassOf<UProjectXDamageType>, float> DamageTypesMap;
 
    //The damage type
    TSubclassOf<UProjectXDamageType> MostRecentDamage = NULL;
 
    //The last time this player caused damage
    float LastHitTime = 0.f;
 
    //Was this player responsible for the kill?
    bool bKiller = false;
 
    static FHistoryEntry InvalidEntry;
 
    FORCEINLINE bool IsValid() const { return Instigator != NULL; }
};
 
UCLASS( ClassGroup=(Custom), HideCategories = (ComponentTick, Collision, Tags, Variable, Activation, ComponentReplication, Cooking), meta=(BlueprintSpawnableComponent) )
class PROJECTX_API UDamageHistoryComponent : public UActorComponent
{
    GENERATED_UCLASS_BODY()
 
public:
    UFUNCTION(BlueprintPure)
    float GetKillHistoryDuration() { return KillHistoryDuration; }
 
    /* returns false if there is no event for this instigator */
    virtual FHistoryEntry& GetEventForInstigator(const AController* Instigator);
    /* returns false if there is no event for this instigator */
    virtual FHistoryEntry& GetDamageDoneEventForInstigator(const AController* Instigator);
 
    /* return false if we cannot find an event */
    virtual FHistoryEntry& GetHighestDamageEvent();
 
    virtual void AddNewKillHistory(APlayerState* Kill);
    const TArray<FKillHistory>& GetKillHistory() { return KillHistory; }
    int32 GetKillCount() const { return KillHistory.Num(); }
 
    UFUNCTION()
    virtual void Die(AActor* Victim, const float Damage, struct FDamageEvent const& DamageEvent, const AController* EventInstigator, const AActor* DamageCauser, bool bFromHeadshot = false);
    UFUNCTION()
    virtual void DamageDone(class AActor* Victim, const float Damage, struct FDamageEvent const& DamageEvent, const AController* EventInstigator, const AActor* DamageCauser);
 
protected:
    virtual void BeginPlay() override;
 
    UFUNCTION()
    virtual void TakeDamage(class AActor* Victim, const float Damage, struct FDamageEvent const& DamageEvent, const AController* EventInstigator, const AActor* DamageCauser, const APlayerState* InstigatorPlayerState);
 
 
    virtual void BroadcastParticipation();
    virtual void BroadcastKillModifiers(AActor* Victim, float Damage, FDamageEvent const& DamageEvent, const AController* EventInstigator, const AActor* DamageCauser);
 
    UFUNCTION()
    void ClearKillHistory();
 
protected:
    UPROPERTY()
    TArray<FHistoryEntry> DamageHistory;
    TArray<FHistoryEntry> DamageDoneHistory;
 
    FTimerHandle KillHistoryClearHandle;
    
    UPROPERTY()
    TArray<FKillHistory> KillHistory;
    
    UPROPERTY(EditDefaultsOnly, Category = DamageHistory)
    float KillHistoryDuration = 1.0f;
 
    UPROPERTY(EditDefaultsOnly, Category = DamageHistory)
    float ParticipationDuration = 15.f;
    //The max time an entry will be considered for awarding the Saviour bonus.
    UPROPERTY(EditDefaultsOnly, Category = DamageHistory)
    float SaviourMaxDuration = 2.f;
 
    FString Saviour = "VO_Saviour";
    FString Avenger = "VO_Avenger";
    FString HeadShot = "VO_HeadshotKill";
};