AfflictionInstance.h

Go to the documentation of this file.

// Copyright Blue Isle Studios Inc 2018. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Components/ActorComponent.h"
#include "AfflictionInstance.generated.h"
 
class AProjectXCharacter;
class AProjectXVehicle;
 
UENUM(BlueprintType)
enum class EApplicationType : uint8
{
    Stacking = 0,
    Override = 1,
    OverrideAndClearOtherAfflictions = 2,
};
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE(FAfflictionEventSignature);
 
UCLASS(Blueprintable, ClassGroup=(Custom), meta=(BlueprintSpawnableComponent) )
class PROJECTX_API UAfflictionInstance : public UActorComponent
{
    GENERATED_UCLASS_BODY()
 
public:
    /*The time that the affliction will last for*/
    UPROPERTY(EditDefaultsOnly, Category = Affliction)
    float AfflictionDuration = 0.0f;
    /*The amount this affliction will affect stats*/
    UPROPERTY(EditDefaultsOnly, Category = Affliction)
    EApplicationType Type = EApplicationType::Stacking;
    /*Additional afflicitons triggered by this affliction, need to be careful here to not create endless loops*/
    UPROPERTY(EditDefaultsOnly, Category = Affliction)
    TArray<TSubclassOf<UAfflictionInstance>> ChildAfflictions;
    /*Priority used to determine most relevant affliction if multiple*/
    UPROPERTY(EditDefaultsOnly, Category = "Affliction")
    int32 Priority = 0;
    /*Is this affliction a perk,Perks are never removed*/
    UPROPERTY(EditDefaultsOnly, Category = "Affliction")
    bool bPerk = false;
 
    virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;
 
    //returns false if initialization failed (already initialized)
    UFUNCTION()
    virtual bool Initialize(UAfflictionComponent* OwningComponent, AActor* AfflictionInstigator = NULL);
    UFUNCTION(BlueprintImplementableEvent, Category = Affliction)
    void OnInitialization();
 
    UFUNCTION()
    virtual void Start();
 
    UFUNCTION(BlueprintPure)
    FORCEINLINE EApplicationType GetApplicationType() { return Type; }
    UFUNCTION(BlueprintPure)
    FORCEINLINE float GetEffectDelayDuration() const { return EffectTriggerDelayDuration; }
    UFUNCTION(BlueprintPure)
    FORCEINLINE int32 GetPriority() { return Priority; }
    UFUNCTION(BlueprintPure)
    FORCEINLINE bool GetIsEffectActive() const { return bEffectActive; }
    UFUNCTION(BlueprintPure)
    FORCEINLINE float GetTimeStamp() { return TimeStamp; }
 
    UFUNCTION(BlueprintCallable, Category = "Affliction")
    UAfflictionComponent* GetAfflictionComponent() const { return AfflictionComponent; }
 
    UFUNCTION(BlueprintCallable, Category = "Affliction")
    AActor* GetInstigator() const { return Instigator; }
 
    UFUNCTION(BlueprintCallable, Category = "Affliction")
    AProjectXCharacter* GetOwningCharacter() const { return OwningCharacter; }
    UFUNCTION(BlueprintCallable, Category = "Affliction")
    AProjectXVehicle* GetOwningVehicle() const { return OwningVehicle; }
    UFUNCTION(BlueprintCallable, Category = Affliction)
    FORCEINLINE FHitResult GetInitializationHitInfo() const { return InitializationHitInfo; }
    void SetInitializationHitInfo(FHitResult HitResult) { InitializationHitInfo = HitResult; MarkComponentDirtyForReplication(); }
 
    void ResetDurationTimer();
    void UpdateEffectDelayDuration(float NewEffectDelay) { EffectTriggerDelayDuration = NewEffectDelay; }
    const TArray<TSubclassOf<UAfflictionInstance>>& GetChildAfflictions() { return ChildAfflictions; }
 
    UFUNCTION(BlueprintNativeEvent, Category = "Affliction")
    float TakeDamage(float Damage, struct FDamageEvent const& DamageEvent, AController* EventInstigator, AActor* DamageCauser);
 
    void ClearAffliction();
 
 
    //Returns false if this affliction affects others' ability to see them
    UFUNCTION(BlueprintNativeEvent, Category = "Affliction")
    bool IsVisible() const;
 
    UPROPERTY(BlueprintAssignable, Category = "Affliction")
    FAfflictionEventSignature OnAfflictionStart;
    UPROPERTY(BlueprintAssignable, Category = "Affliction")
    FAfflictionEventSignature OnAfflictionEnd;
    UPROPERTY(BlueprintAssignable, Category = "Affliction")
    FAfflictionEventSignature OnInitializationHitInfoReplicated;
 
    static bool ValidOverride(const TWeakObjectPtr<UAfflictionInstance> Affliction, int32& HighestPriority, float& Time, EApplicationType& HighestApplicationLevel);
 
    bool bCallAfflictionEndEvents = true;
    bool bEffectActive = false;
 
protected:
    UFUNCTION()
    virtual void End(bool bIgnoreApplyModifier = false);
    UFUNCTION(BlueprintImplementableEvent, Category = Affliction, meta = (DisplayName="Start",ScriptName="Start"))
    void K2_Start();
    UFUNCTION(BlueprintImplementableEvent, Category = Affliction, meta = (DisplayName="End", ScriptName="End"))
    void K2_End();
    UFUNCTION(BlueprintImplementableEvent, Category = Affliction, meta = (DisplayName = "OnHitInfoInitialized", ScriptName = "OnHitInfoInitialized"))
    void K2_HitInfoInitialized();
    UFUNCTION(BlueprintImplementableEvent)
    void K2_ApplyModifier();
 
    void TriggerModifier();
 
    virtual void ApplyModifier() {}
    virtual void GetTotalModifier(const TArray<UAfflictionInstance*>& Afflictions) {}
    UFUNCTION()
    void OnRep_InitializationHitInfo();
 
    UPROPERTY()
    UAfflictionComponent* AfflictionComponent = NULL;
    UPROPERTY(Replicated)
    AActor* Instigator = NULL;
    UPROPERTY()
    AProjectXCharacter* OwningCharacter = NULL;
    UPROPERTY()
    AProjectXVehicle* OwningVehicle = NULL; //TODOLEAP: Refactor to Baseclass instead of having a Character and Vehicle
    UPROPERTY()
    bool bInitialized = false;
    int Counter = 0;
    float TimeStamp = 0;
    FTimerHandle DurationHandle;
    //The FHitResult information that was used to initialize this affliction, if any
    UPROPERTY(ReplicatedUsing = OnRep_InitializationHitInfo)
    FHitResult InitializationHitInfo = FHitResult();
 
    FTimerHandle EffectTriggerDelayHandle;
    /* delay before the affliction takes affect*/
    UPROPERTY(EditDefaultsOnly)
    float EffectTriggerDelayDuration;
};