Flag.h

Go to the documentation of this file.

// Copyright Blue Isle Studios Inc 2018. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "TeamInterface.h"
#include "TrackableInterface.h"
#include "Flag.generated.h"
 
class UAfflictionInstance;
class ASoftBoundaryVolume;
class UCapsuleComponent;
class AProjectXCharacter;
class USphereComponent;
 
UENUM(BlueprintType)
enum class EFlagState : uint8
{
    HOME,
    CARRIED,
    DROPPED,
    NONE,
};
 
USTRUCT(BlueprintType)
struct FFlagInfo
{
    GENERATED_USTRUCT_BODY()
 
    UPROPERTY(BlueprintReadWrite)
    EFlagState FlagState = EFlagState::NONE;
    UPROPERTY(BlueprintReadWrite)
    TWeakObjectPtr<AProjectXCharacter> CurrentCarrier = NULL;
    UPROPERTY()
    TWeakObjectPtr<AProjectXCharacter> PreviousCarrier = NULL;
};
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams(FFlagEventSignature,AFlag*, Flag, AProjectXCharacter*, Character, int32, Team);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FFlagStateSignature,const FFlagInfo&, Info);
 
UCLASS()
class PROJECTX_API AFlag : public AActor, public ITeamInterface, public ITrackableInterface
{
    GENERATED_UCLASS_BODY()
    AFlag();
 
public: 
    virtual int32 GetTeam() const override  { return Team; }
    UFUNCTION(BlueprintCallable)
    AProjectXCharacter* GetCharacter() const;
    UFUNCTION(BlueprintCallable)
    FORCEINLINE FFlagInfo GetFlagInfo() const { return FlagInfo; }
    UFUNCTION(BlueprintCallable)
    FORCEINLINE float GetPickupRadius() const { return PickupRadius; }
    UFUNCTION(BlueprintCallable)
    FORCEINLINE UCapsuleComponent* GetCapsuleComponent() const { return CapsuleComponent; }
    UFUNCTION(BlueprintCallable)
    FORCEINLINE TSubclassOf<UAfflictionInstance> GetFlagCarrierAffliction() const { return FlagCarrierAfflictionInstance; }
    UFUNCTION(BlueprintCallable)
    FORCEINLINE bool CanBePickedUp() const { return bCanBePickedUp; }
    virtual bool GetAllyVisibilityResponse() override { return true; }
 
    virtual TSoftObjectPtr<UTexture2D> GetRadarIcon() const override { return RadarIcon; }
    virtual float GetRadarIconOpacity() const { return RadarIconOpacity; }
    virtual void SetRadarIconOpacity(float Opacity) override { RadarIconOpacity = Opacity; }
    
    UPROPERTY(BlueprintAssignable)
    FFlagEventSignature OnFlagPickedUp;
    UPROPERTY(BlueprintAssignable)
    FFlagEventSignature OnFlagReturned;
    UPROPERTY(BlueprintAssignable)
    FFlagEventSignature OnFlagCaptured;
    UPROPERTY(BlueprintAssignable)
    FFlagEventSignature OnFlagDropped;
    UPROPERTY(BlueprintAssignable)
    FFlagStateSignature OnFlagStateUpdated;
    UPROPERTY(BlueprintAssignable)
    FFlagEventSignature OnCarrierCharacterUpdatedEvent;
 
    void UpdateFlagState(EFlagState NewFlagState);
    void UpdateFlagCarrier(AProjectXCharacter* NewFlagCarrier);
    void ReturnFlag();
    void FlagCaptured();
    virtual int32 SetTeam(int32 NewTeam) override { Team = NewTeam; return Team; }
 
protected:  
    virtual void Tick(float DeltaSeconds) override;
    virtual bool ItemPickedUp(AActor* PickingUpActor);
 
    void DropFlag();
    bool CheckForFlagPickups();
    void UpdateCanBePickedUp(bool bNewPickupableState) { bCanBePickedUp = bNewPickupableState; }
 
    UFUNCTION(BlueprintImplementableEvent)
    void FlagStatUpdated();
    UFUNCTION(BlueprintImplementableEvent)
    void FlagPickupUpdated();
 
    UFUNCTION()
    virtual void OnOverlap(UPrimitiveComponent* OverlapComponent, AActor* OtherActor, UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const FHitResult& SweepResult);
    UFUNCTION()
    void CarrierDied(AActor* Victim, const float Damage, struct FDamageEvent const& DamageEvent, const class AController* EventInstigator, const AActor* DamageCauser, const APlayerState* InstigatorPlayerState);
    UFUNCTION()
    void OnCarrierEnterSoftBoundary(AActor* Actor, ASoftBoundaryVolume* TargetSoftBoundaryVolume);
    UFUNCTION()
    void FlagAfflictionEnded();
 
    UFUNCTION()
    void OnRep_CanBePickedUp();
    UFUNCTION()
    void OnRep_FlagInfo();
 
    UPROPERTY(EditDefaultsOnly, Category = "Flag")
    TSoftObjectPtr<UTexture2D> RadarIcon = nullptr;
    UPROPERTY(EditDefaultsOnly, Category = "Flag")
    float RadarIconOpacity = 0.3f;
    UPROPERTY(EditDefaultsOnly, Category = "Flag")
    float RadarIconOpacityWhenCarried = 0.0f;
    UPROPERTY(EditDefaultsOnly, Category = "Flag")
    float RadarIconOpacityWhenDropped = 1.0f;
 
    UPROPERTY(ReplicatedUsing = OnRep_FlagInfo)
    FFlagInfo FlagInfo;
    UPROPERTY(Replicated)
    int32 Team = -1;
    UPROPERTY(Replicated)
    bool bCanBePickedUp = true;
    /*From How Far can you pickup the flag*/
    UPROPERTY(EditDefaultsOnly)
    float PickupRadius = 200.0f;
    /* Collision Component of the flag*/
    UPROPERTY(EditDefaultsOnly)
    UCapsuleComponent* CapsuleComponent;
    /*Affliction Applied to the carrier of the flag*/
    UPROPERTY(EditDefaultsOnly)
    TSubclassOf<UAfflictionInstance> FlagCarrierAfflictionInstance;
    /* How long after the flag is dropped before it can be picked up again*/
    UPROPERTY(EditDefaultsOnly)
    float PickupDelay = 1.0f;   
    /*Does the flag return home when captured*/
    UPROPERTY(EditDefaultsOnly)
    bool bDoesFlagResetOnCapture = true;
    /* List of actors that can trigger resets on overlaps*/
    UPROPERTY(EditDefaultsOnly)
    TArray<TSubclassOf<AActor>> ActorClassesToTriggerReset;
    /* Sphere used for collision between players*/
    UPROPERTY(EditDefaultsOnly)
    USphereComponent* Sphere;   
    FTimerHandle PickUpDelayTimer;
};