Deployable.h

Go to the documentation of this file.

// Copyright Blue Isle Studios Inc 2018. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "WeaponInstanceActor.h"
#include "HealthInterface.h"
#include "LockOnTargetInterface.h"
#include "SpottableInterface.h"
#include "TrackableInterface.h"
#include "ReactsToMatchEvents.h"
#include "ObjectInfoInterface.h"
#include "Deployable.generated.h"
 
class APlayerState;
class AContainer;
class UWeaponInstance;
class UAfflictionComponent;
 
UENUM(BlueprintType)
enum class EDeployableState : uint8
{
    None,
    Deactivated,
    StartingUp,
    Activated
};
 
/* Categories might be used for querying deployables that belong to the same category but don't share the same classes */
UENUM(BlueprintType)
enum class EDeployableCategory : uint8
{
    None,
    AutoTurret,
    Projector,
    Explosive,
    Controllable
};
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FDeploymentBeginSignature, ADeployable*, Deployable);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FDeploymentCompleteSignature, ADeployable*, Deployable);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FDeployableCompleteSignature, ADeployable*, Deployable);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnDeployableLifeTimeStartSignature, float, LifeTime);
 
UCLASS(Blueprintable)
class PROJECTX_API ADeployable : public AWeaponInstanceActor, public IHealthInterface, public ILockOnTargetInterface, public ISpottableInterface, public ITrackableInterface, public IReactsToMatchEvents, public IObjectInfoInterface
{
    GENERATED_UCLASS_BODY()
 
public:
    virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;
    UFUNCTION(BlueprintCallable)
    virtual void Init();
    virtual void MatchEnded() override;
    virtual bool CanOwningWeaponInstanceFire() const { return false; }
 
    UFUNCTION(BlueprintCallable, Category = Deployable)
    bool IsDeployed() const { return DeployState == EDeployableState::Activated || DeployState == EDeployableState::Deactivated; }
    UFUNCTION(BlueprintCallable, Category = Deployable)
    bool IsDeploying() const { return !IsDeployed(); }
    UFUNCTION()
    FORCEINLINE EDeployableCategory GetDeployableCategory() const { return DeployableCategory; }
 
    virtual float GetHealth() const override;
    virtual float GetMaxHealth() const override;
    virtual bool BlocksExplosions() const override { return bBlocksExplosionDamage; }
 
    virtual float GetTimeSinceLastDamage() const override;
    virtual bool IsArmored() const override { return bArmored; }
    virtual bool IsDead() const override;
    virtual void SetMaxHealth(const float NewMaxHealth) override;
    virtual void SetHealth(const float NewHealth) override;
    virtual bool CanBeLockedOn(const AActor* LockInstigator) const override;
    virtual bool CanBeRepaired(const AActor* RepairInstigator) const override;
    virtual float GetLockOnMaxDistance() override { return MaxLockOnRange; }
    virtual FVector2D GetLockOnScreenPercentage() override { return LockOnScreenPercentage; }
    void SetHealthRegenRate(float NewRate) override { HealthRegenRate = NewRate; }
    virtual ESpotReply CanBeSpotted(const AActor* SpotInstigator, ESpotType SpotType) const override;
    virtual AActor* GetTrackableInterfaceActor() override { return this; }
    virtual TSoftObjectPtr<UTexture2D> GetMapIcon() const override { return DeployableMapIcon; }
    virtual TSoftObjectPtr<UTexture2D> GetRadarIcon() const override { return DeployableRadarIcon; }
    virtual TSoftObjectPtr<UTexture2D> GetHudIcon() const override { return DeployableHudIcon; }
    virtual float GetRadarIconSize() const override { return 750.0f; }
    virtual float GetRadarIconOpacity() const override { return 0.6f; }
    virtual const FText& GetObjectName() const { return GetDeployableName(); };
    virtual const FString GetOwnerName() const;
    virtual const FText& GetObjectDescription() const;
    
    UFUNCTION(BlueprintCallable, Category = Deployable)
    const FText& GetDeployableName() const { return DeployableName; }
    
    UFUNCTION(BlueprintCallable, Category = Deployable)
    TAssetPtr<UTexture2D> GetDeployableIcon() const { return DeployableIcon; }
    UFUNCTION(BlueprintCallable, Category = Deployable)
    EDeployableState GetDeployableState() const { return DeployState; } 
    UFUNCTION(BlueprintCallable, Category = Deployable)
    float GetLifeTimeDurationStartTime() const {return LifeTimeDurationStartTime;}
    UFUNCTION(BlueprintCallable,BlueprintPure, Category = Deployable)
    float GetTimeUntilDeploy() const { return FMath::Max(0.f, GetWorld()->GetTimerManager().GetTimerRemaining(DeployTimer)); }
 
    FVector GetSpottingTraceOffset() const override { return FVector(GetActorLocation().X, GetActorLocation().Y, GetActorLocation().Z + SpottingZOffset); }
 
    void SetDeployableLifeTime(const float NewLifeTime);
 
    virtual void OnOwnerLeave() override;
    virtual void OnOwnerDied() override {}
 
    //Returns a list of deployables owned by provided a pawn/controller/player state (anything implementing IPlayerOwnedInterface). If a Category is provided, it will only search for the ones that belong to that category and if a filter is provided, will only return actors matching the class specified.
    UFUNCTION(BlueprintCallable, Category = Deployable)
    static TArray<ADeployable*> GetAllDeployablesForActor(AActor* Actor, EDeployableCategory CategoryFilter = EDeployableCategory::None, TSubclassOf<ADeployable> DeployableFilter = NULL);
 
    UFUNCTION(BlueprintCallable)
    virtual void DeployStart(bool bForce = false);
    UFUNCTION(BlueprintCallable)
    virtual void DeactivateDeployable();
    UFUNCTION(BlueprintCallable)
    virtual void ActivateDeployable();
    UFUNCTION(BlueprintCallable)
    virtual void ClearDeployable();
 
    virtual void DeployComplete();
    virtual float TakeDamage(float Damage, struct FDamageEvent const& DamageEvent, AController* EventInstigator, AActor* DamageCauser) override;
    virtual bool ShouldTakeDamage(float Damage, FDamageEvent const& DamageEvent, AController* EventInstigator, AActor* DamageCauser) const;
    virtual float InternalTakeRadialDamage(float Damage, FRadialDamageEvent const& RadialDamageEvent, class AController* EventInstigator, class AActor* DamageCauser) override;
    virtual void Died(float Damage, FDamageEvent const& DamageEvent, AController* EventInstigator, AActor* DamageCauser, APlayerState* InstigatorPlayerState);
    virtual UAfflictionComponent* GetAfflictionComponent() const override { return AfflictionComponent; }
 
    UPROPERTY(BlueprintAssignable)
    FDeploymentBeginSignature OnDeploymentBegin;
    UPROPERTY(BlueprintAssignable)
    FDeploymentCompleteSignature OnDeploymentComplete;
    UPROPERTY(BlueprintAssignable)
    FDeployableCompleteSignature OnDeployableComplete;
    UPROPERTY(BlueprintAssignable)
    FOnDeployableLifeTimeStartSignature OnDeployableLifeTimeStarted;
 
    UFUNCTION(NetMulticast, Reliable)
    void Multicast_Reliable_Died(float Damage, FDamageEvent const& DamageEvent, AActor* DamageCauser, APlayerState* InstigatorPlayerState);
    
    UFUNCTION(BlueprintImplementableEvent, Category = Deployable)
    void InitializeForTeam(int32 Team);
 
    UFUNCTION(BlueprintImplementableEvent, Category = Deployable)
    void OnDeployableDied();
    UFUNCTION(BlueprintImplementableEvent, Category = Deployable)
    void OnDeployStart();
    UFUNCTION(BlueprintImplementableEvent, Category = Deployable)
    void OnDeployDeactivated();
    UFUNCTION(BlueprintImplementableEvent, Category = Deployable)
    void OnDeployReActivated();
    UFUNCTION(BlueprintImplementableEvent, Category = Deployable)
    void OnDeployComplete();
    UFUNCTION(BlueprintCallable)
    void SetDeployTransform(const FTransform& Transform);
    UFUNCTION(BlueprintCallable)
    void UpdateState(EDeployableState NewDeployState);
    
    UFUNCTION()
    void OnRep_StateChanged();
    UFUNCTION()
    void OnRep_LifeTimeDurationStart();
    UFUNCTION()
    virtual void OnRep_Health(float PreviousHealth);
    UFUNCTION()
    virtual void OnRep_DeployTransform();
    
    UFUNCTION()
    virtual void OnTeamsChanged(class AProjectXPlayerState* PlayerState, uint8 Team);
    
    virtual void BeginPlay() override;
    UPROPERTY(ReplicatedUsing = OnRep_StateChanged)
    EDeployableState DeployState  = EDeployableState::None;
    UPROPERTY(EditDefaultsOnly, Category = Afflictions)
    UAfflictionComponent* AfflictionComponent = NULL;
    /* Can this deployable be targeted by AI systems? */
    UPROPERTY(EditDefaultsOnly, Category = Deployable)
    bool bTargetable = true;
    /* Should we treat this as an armored target? Affects HUD, hitmarkers etc */
    UPROPERTY(EditDefaultsOnly, Category = Deployable)
    bool bArmored = true;
    /* Maximum Health of the deployable*/
    UPROPERTY(Replicated, EditDefaultsOnly, Category = Deployable)
    float MaxHealth = 100.f;
    /* Current Health of the deployable*/
    UPROPERTY(ReplicatedUsing = OnRep_Health)
    float Health = 0.f;
    UPROPERTY(ReplicatedUsing = OnRep_LifeTimeDurationStart)
    float LifeTimeDurationStartTime = 0.0f;
    /* does the deployable block Explosion Damage*/
    UPROPERTY(EditDefaultsOnly, Category = Deployable)
    bool bBlocksExplosionDamage = false;
    /* This deployable's category */
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = Deployable)
    EDeployableCategory DeployableCategory = EDeployableCategory::None;
    /* does the deployable deploy automatically*/
    UPROPERTY(EditDefaultsOnly, Category = Deployable)
    bool bAutoDeploy = false;
    /* time to finish deploying*/
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = Deployable)
    float DeployTime = 2.5f;
    /* life time of the deployable after finished deployment*/
    UPROPERTY(Replicated, EditDefaultsOnly, BlueprintReadOnly, Category = Deployable)
    float DeployableLifeTime = 0.0f;
    UPROPERTY(ReplicatedUsing = OnRep_DeployTransform)
    FTransform DeployTransform;
    /* Should health charge up over the duration of the deploy? */
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = Deployable)
    bool bHealthDuringDeploy = true;
    /* Starting health of the deployable if health charges up on deploy */
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = Deployable, meta = (EditCondition = "bHealthDuringDeploy"))
    float DeployableStartingHealth = 1.0f;
    UPROPERTY(Replicated)
    float LastDamageTime = -MAX_FLT;
    /* Widget that will be added to the deployed list widget when this deployable is spawned */
    UPROPERTY(EditDefaultsOnly, Category = Deployable)
    TAssetPtr<UTexture2D> DeployableIcon = NULL;
    UPROPERTY()
    bool bIsDead = false;
    /* How Long will it take for the deployable to finish its death effects*/
    UPROPERTY(EditDefaultsOnly, Category = Deployable)
    float DiedEffectDuration = 2.0f;
    /* Name of the deployable*/
    UPROPERTY(EditDefaultsOnly, Category = Deployable)
    FText DeployableName;
    /* does it destory automaticly on death*/
    UPROPERTY(EditDefaultsOnly, Category = Deployable)
    bool bDestroyImmediatelyOnDeath = true;
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Deployable|LockOn")
    bool bCanBeLockedOn = false;
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Deployable|Repair")
    bool bCanBeRepaired = false;
    /*Returns the max distance this deployable can be to be considered for locking-into. This means that if
    we scan for 20km targets but this actor has a MaxLockOnRange of 100m and this actor is further away than
    100m it won't be considered as a candidate during the target-finding.
    A returned value of 0 is by default ignored by target-finding systems */
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Deployable|LockOn", meta = (EditCondition = "bCanBeLockedOn"))
    float MaxLockOnRange = 15000.f;
    /* Returns the Screen percentage that this deployable is required to have to be considered for Locking-onto (In both vertical and horizontal axis of the viewport).
    A value of FVector2D(0,0) will by default be ignored by weapons when deciding locking-into candidates. For example, when scanning for a 20km range, if this deployable
    has a screen percentage bigger than GetLockOnScreenPercentage() (in any axis) it is going to be considered as a candidate to be locked into. This is useful as
    deployable that are really far away can still look big on the screen and feels like they should be locked into */
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Deployable|LockOn", meta = (EditCondition = "bCanBeLockedOn"))
    FVector2D LockOnScreenPercentage = FVector2D::ZeroVector;
 
    /*This is used for offsetting the Z location from a deployable for a more favorable spotting location on the deployable*/
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Deployable")
    float SpottingZOffset = 0.0f;
 
    /* This Deployable's icon that is to be displayed on the map*/
    UPROPERTY(EditDefaultsOnly, Category = "UI")
    TSoftObjectPtr<UTexture2D> DeployableMapIcon = NULL;
    /* This Deployable's icon that is to be displayed on enemies' huds when spotted*/
    UPROPERTY(EditDefaultsOnly, Category = "UI")
    TSoftObjectPtr<UTexture2D> DeployableHudIcon = NULL;
    /* This Deployable's icon that is to be displayed on enemies' radars when spotted*/
    UPROPERTY(EditDefaultsOnly, Category = "UI")
    TSoftObjectPtr<UTexture2D> DeployableRadarIcon = NULL;
 
    FTimerHandle DeployTimer;
    FTimerHandle LifeTimerHandle;
 
    int32 HealthInterpolatorID = INDEX_NONE;
    float LastHealthInterpolatorValue = 0.f;
    float HealthRegenRate = 0.0f;
    //This is only used by non-authoritative proxies
    EDeployableState PreviousState = EDeployableState::None;
 
    FString AllyDeployableDestoryed = "VO_EquipementDestroyed_Ally";
};