DamageEvents.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Templates/SubclassOf.h"
#include "Engine/NetSerialization.h"
#include "Engine/HitResult.h"
#include "DamageEvents.generated.h"
 
class UDamageType;
 
USTRUCT(BlueprintType)
struct FDamageEvent
{
    GENERATED_BODY()
 
public:
    FDamageEvent() { }
 
    FDamageEvent(FDamageEvent const& InDamageEvent)
        : DamageTypeClass(InDamageEvent.DamageTypeClass)
    { }
    
    virtual ~FDamageEvent() { }
 
    explicit FDamageEvent(TSubclassOf<UDamageType> InDamageTypeClass)
        : DamageTypeClass(InDamageTypeClass)
    { }
 
    UPROPERTY()
    TSubclassOf<UDamageType> DamageTypeClass;
 
    static const int32 ClassID = 0;
 
    virtual int32 GetTypeID() const { return FDamageEvent::ClassID; }
    virtual bool IsOfType(int32 InID) const { return FDamageEvent::ClassID == InID; };
 
    ENGINE_API virtual void GetBestHitInfo(AActor const* HitActor, AActor const* HitInstigator, FHitResult& OutHitInfo, FVector& OutImpulseDir) const;
};
 
USTRUCT()
struct FPointDamageEvent : public FDamageEvent
{
    GENERATED_BODY()
 
    
    UPROPERTY()
    float Damage;
    
    UPROPERTY()
    FVector_NetQuantizeNormal ShotDirection;
    
    UPROPERTY()
    FHitResult HitInfo;
 
    FPointDamageEvent() : Damage(0.0f), ShotDirection(ForceInitToZero), HitInfo() {}
    FPointDamageEvent(float InDamage, const FHitResult& InHitInfo, FVector const& InShotDirection, TSubclassOf<UDamageType> InDamageTypeClass)
        : FDamageEvent(InDamageTypeClass), Damage(InDamage), ShotDirection(InShotDirection), HitInfo(InHitInfo)
    {}
    
    static const int32 ClassID = 1;
    
    virtual int32 GetTypeID() const override { return FPointDamageEvent::ClassID; };
    virtual bool IsOfType(int32 InID) const override { return (FPointDamageEvent::ClassID == InID) || FDamageEvent::IsOfType(InID); };
 
    ENGINE_API virtual void GetBestHitInfo(AActor const* HitActor, AActor const* HitInstigator, FHitResult& OutHitInfo, FVector& OutImpulseDir) const override;
};
 
USTRUCT(BlueprintType)
struct FRadialDamageParams
{
    GENERATED_BODY()
 
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=RadialDamageParams)
    float BaseDamage;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=RadialDamageParams)
    float MinimumDamage;
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=RadialDamageParams)
    float InnerRadius;
        
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=RadialDamageParams)
    float OuterRadius;
        
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=RadialDamageParams)
    float DamageFalloff;
 
    FRadialDamageParams()
        : BaseDamage(0.f), MinimumDamage(0.f), InnerRadius(0.f), OuterRadius(0.f), DamageFalloff(1.f)
    {}
    FRadialDamageParams(float InBaseDamage, float InInnerRadius, float InOuterRadius, float InDamageFalloff)
        : BaseDamage(InBaseDamage), MinimumDamage(0.f), InnerRadius(InInnerRadius), OuterRadius(InOuterRadius), DamageFalloff(InDamageFalloff)
    {}
    FRadialDamageParams(float InBaseDamage, float InMinimumDamage, float InInnerRadius, float InOuterRadius, float InDamageFalloff)
        : BaseDamage(InBaseDamage), MinimumDamage(InMinimumDamage), InnerRadius(InInnerRadius), OuterRadius(InOuterRadius), DamageFalloff(InDamageFalloff)
    {}
    FRadialDamageParams(float InBaseDamage, float InRadius)
        : BaseDamage(InBaseDamage), MinimumDamage(0.f), InnerRadius(0.f), OuterRadius(InRadius), DamageFalloff(1.f)
    {}
 
    ENGINE_API float GetDamageScale(float DistanceFromEpicenter) const;
 
    float GetMaxRadius() const { return FMath::Max( FMath::Max(InnerRadius, OuterRadius), 0.f ); }
};
 
USTRUCT()
struct FRadialDamageEvent : public FDamageEvent
{
    GENERATED_BODY()
 
    
    UPROPERTY()
    FRadialDamageParams Params;
    
    UPROPERTY()
    FVector Origin;
 
    UPROPERTY()
    TArray<FHitResult> ComponentHits;
 
    static const int32 ClassID = 2;
 
    virtual int32 GetTypeID() const override { return FRadialDamageEvent::ClassID; };
    virtual bool IsOfType(int32 InID) const override { return (FRadialDamageEvent::ClassID == InID) || FDamageEvent::IsOfType(InID); };
 
    ENGINE_API virtual void GetBestHitInfo(AActor const* HitActor, AActor const* HitInstigator, FHitResult& OutHitInfo, FVector& OutImpulseDir) const override;
 
    FRadialDamageEvent()
        : Origin(ForceInitToZero)
    {}
};