CapturePoint.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 "GameFramework/Actor.h"
#include "Components/CapsuleComponent.h"
#include "Engine/DataTable.h"
#include "SpawnTargetInterface.h"
#include "ReactsToMatchEvents.h"
#include "TeamInterface.h"
#include "PlayerStats.h"
#include "TrackableInterface.h"
#include "CapturePoint.generated.h"
 
#define NUMBER_OF_DECAYS_UNTIL_AWARD_RESET 2
 
class AProjectXCharacter;
class AProjectXVehicle;
class AProjectXGameModeBaseControl;
class UAfflictionComponent;
class UAfflictionInstance;
class UExperienceEvent;
 
UENUM()
enum class ECaptureType : uint8
{
    CaptureFull = 0,
    CapturePartial = 1,
    NeutralizeFull = 2,
    NeutralizePartial = 3,
};
 
USTRUCT(Blueprintable)
struct FCaptureInfo
{
    GENERATED_USTRUCT_BODY()
 
public:
    //what team has progress towards this capture point
    UPROPERTY(BlueprintReadWrite, Category = "Capture")
    int32 Team = -1;
    //players is positive if it's being captured for Team specified, negative if being taken away from Team specified
    UPROPERTY(BlueprintReadWrite, Category = "Capture")
    int32 NumPlayers = 0;
    UPROPERTY(BlueprintReadWrite, Category = "Capture")
    float Progress = 0.f;
    UPROPERTY(BlueprintReadWrite, Category = "Capture")
    int32 CurrentCheckPoint = 0;
    UPROPERTY(BlueprintReadOnly, Category = "Capture")
    int32 LastAwardedCheckPoint = -1;
    UPROPERTY(BlueprintReadOnly, Category = "Capture")
    int32 DecayCounter = 0;
    /* Describes if the current capture info is a point being taken over. True if an opposing team is capturing */
    UPROPERTY(BlueprintReadWrite, Category = "Capture")
    bool bBeingTaken = false;
};
 
USTRUCT(Blueprintable)
struct FBaseControlEventTableRow : public FTableRowBase
{
    GENERATED_USTRUCT_BODY()
 
    UPROPERTY(EditDefaultsOnly, Category = "Sound")
    FString AllySound;
    UPROPERTY(EditDefaultsOnly, Category = "Sound")
    FString EnemySound;
};
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FControlPointOwnerChangedSignature, int32, TeamOwner, ACapturePoint*, Point);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FCaptureInfoChanged, const FCaptureInfo&, CaptureInfo);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FCapturePointLockChangedSignature,ACapturePoint*, CapturePoint, bool, bLocked);
 
UCLASS(BlueprintType, Blueprintable)
class PROJECTX_API ACapturePoint : public AActor, public ISpawnTargetInterface, public IReactsToMatchEvents, public ITeamInterface, public ITrackableInterface
{
    GENERATED_UCLASS_BODY()
 
protected:
    virtual void BeginPlay() override;
    virtual void CollectPlayerStartList();
 
public: 
    virtual void Tick(float DeltaTime) override;
 
    virtual void TickCapture(float DeltaTime);
 
    virtual int32 GetActorTeam(AActor* Target) const;
 
    virtual int32 GetTeam() const override { return TeamOwner; }
    virtual int32 SetTeam(int32 NewTeam) override;
    virtual float GetRadarIconSize() const { return GetCaptureRadius(); } 
    virtual TSoftObjectPtr<UTexture2D> GetRadarIcon() const override { return RadarIcon; }
    virtual float GetRadarIconOpacity() const override { return RadarIconOpacity; }
    virtual const FText& GetRadarLabel() const { return PointName; }
    virtual void SetRadarIconOpacity(float Opacity) override { RadarIconOpacity = Opacity; }
    virtual bool RegisterOnStart() const override { return bRegisterOnBeginPlay; }
    virtual FStopTrackingActorSignature& GetStopTrackingEvent() override { return StopTrackingCapturePointEvent; }
    UFUNCTION(BlueprintCallable, Category = CapturePoint)
    int32 GetSortOrder() const { return SortOrder; }
 
    UFUNCTION(BlueprintCallable, Category = CapturePoint)
    FText GetPointName() const { return PointName; }
 
    UFUNCTION(BlueprintCallable, BlueprintAuthorityOnly, Category = CapturePoint)
    virtual void SetLocked(bool bNewLocked);
    UFUNCTION(BlueprintCallable, Category = CapturePoint)
    virtual bool GetIsLocked() const { return bLocked; }
 
    UFUNCTION(BlueprintCallable, Category = CapturePoint)
    const FCaptureInfo& GetCaptureInfo() const { return CaptureInfo; }
    UFUNCTION(BlueprintCallable, Category = CapturePoint)
    FORCEINLINE float GetCaptureRadius() const { return CapsuleComponent ? CapsuleComponent->GetScaledCapsuleRadius() : -1.f; }
    
    virtual void Initialize(int32 NumberOfCheckPointsOverride = INDEX_NONE, float PerPlayerCaptureRateOverride = INDEX_NONE);
 
//~ Begin ISpawnTargetInterface Interface.
    virtual bool CanSpawnPlayer(const AProjectXPlayerState* Instigator) const override;
    virtual float GetSpawnScoreForInstigator(const AActor* const QueryInstigator, FVector& TargetLocation, bool bUseDistanceToTargetLocation = false) const override;
    virtual bool GetSpawnLocation(AProjectXPlayerState* Instigator, FTransform& Transform) const override;
//~ End ISpawnTargetInterface Interface.
 
    void TriggerDelayedActivation();
 
    virtual AActor* GetPlayerStart(class AController* Player) const;
    virtual AActor* GetTrackableInterfaceActor() override { return this; }
 
    virtual void MatchEnded() override;
 
public:
    UPROPERTY(BlueprintAssignable)
    FControlPointOwnerChangedSignature OnControlPointOwnerChanged;
    UPROPERTY(BlueprintAssignable)
    FCaptureInfoChanged OnCaptureInfoChanged;
    UPROPERTY(BlueprintAssignable)
    FCapturePointLockChangedSignature OnCapturePointLockChangedEvent;
    UPROPERTY(BlueprintAssignable)
    FControlPointOwnerChangedSignature OnPointBeingClaimedEvent;
    UPROPERTY(BlueprintAssignable)
    FStopTrackingActorSignature StopTrackingCapturePointEvent;
 
protected:
    UFUNCTION()
    void OnOverlap(UPrimitiveComponent* OverlappedComponent, AActor* OtherActor, UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const FHitResult& SweepResult);
    
    UFUNCTION()
    void OnOverlapEnd(UPrimitiveComponent* OverlappedComponent, AActor* OtherActor, UPrimitiveComponent* OtherComp, int32 OtherBodyIndex);
 
    UFUNCTION()
    void UpdateProcessedOccupants();
 
    UFUNCTION()
    void CollectInitialOverlaps();
 
    UFUNCTION()
    void OnVehiclePassengerChanged(AProjectXVehicle* Vehicle, UVehicleSeatComponent* Seat = NULL, AProjectXCharacter* PreviousPassenger = NULL);
 
    bool DoesOccupantHaveAnInvalidAffliction(UAfflictionComponent* AfflictionComponent);
 
    UFUNCTION()
    void OnRep_Locked();
 
    UFUNCTION()
    void OnRep_TeamOwner();
 
    UFUNCTION()
    void OnRep_CaptureInfo();
 
    UFUNCTION(BlueprintImplementableEvent, BlueprintAuthorityOnly, Category = CapturePoint)
    void OnPointOwnerChanged(int LastOwner);
 
    UFUNCTION(BlueprintImplementableEvent, BlueprintAuthorityOnly, Category = CapturePoint)
    void OnCaptureComplete();
 
    UFUNCTION(BlueprintImplementableEvent, Category = CapturePoint)
    void OnCapturePointLockChanged(bool bIsLock);
 
    UFUNCTION(BlueprintCallable)
    void ResetPoint();
 
    UFUNCTION(BlueprintCallable)
    void ChangeCaptureProgress(float Amount);
    UFUNCTION(BlueprintCallable, Category = CapturePoint)
    int32 GetTopCapturingTeam() const
    {
        int32 TopTeam = INDEX_NONE;
        if (TeamStandings.Num() >= 1)
        {
            TopTeam = TeamStandings[0];
        }
 
 
        return TopTeam;
    }
    int32 GetSecondCapturingTeam() const
    {
        if (TeamStandings.Num() > 1)
        {
            return TeamStandings[1];
        }
        else
        {
            return INDEX_NONE;
        }
    }
    UFUNCTION(BlueprintCallable)
    void UpdateCheckPoint();
 
    void SetCaptureInfo(int32& NumberOfPlayers, int32& Direction);
    void AwardCapture(ECaptureType Type, int32 AwardingTeam);
    const TSubclassOf<UExperienceEvent> GetExpEventOverride(EXPEventType Type) const;
 
    /* The team this capture point defaults to. If -1 this capture point will be neutral */
    UPROPERTY(EditInstanceOnly, Category = "Capture Point", meta = (AllowPrivateAccess = true))
    int32 DefaultTeam = INDEX_NONE;
    /* The icon used for this capture point on the radar*/
    UPROPERTY(EditDefaultsOnly, Category = "Capture Point", meta = (AllowPrivateAccess = true))
    TSoftObjectPtr<UTexture2D> RadarIcon = nullptr;
    /* Use this to make the radar icon semi-transparent */
    UPROPERTY(EditDefaultsOnly, Category = "Capture Point", meta = (AllowPrivateAccess = true))
    float RadarIconOpacity = 0.3f;
    /* should this call to register itself as trackable at game start*/
    UPROPERTY(EditDefaultsOnly, Category = "Capture Point", meta = (AllowPrivateAccess = true))
    bool bRegisterOnBeginPlay = true;
    /* is this trackable when it is locked*/
    UPROPERTY(EditDefaultsOnly, Category = "Capture Point", meta = (AllowPrivateAccess = true))
    bool bIsTrackableWhenLocked = true;
    /*valid teams that can capture the objective*/
    UPROPERTY(EditDefaultsOnly, Category = "Capture Point", meta = (AllowPrivateAccess = true))
    TSet<uint8> ValidCaptureTeams = TSet<uint8>({0,1});
    /* How much score is awarded for spawn logics control point is locked and cannot be capture? */
    UPROPERTY(EditDefaultsOnly, Category = "Spawn Scoring", meta = (AllowPrivateAccess = true))
    float LockedScoringWeight = 0.5f;
    /* The maximum distance considered for awarding a score increment, every distance bigger than this value will award 0 score. Value needs to be > 0*/
    UPROPERTY(EditDefaultsOnly, Category = "Spawn Scoring", meta = (AllowPrivateAccess = true))
    float ControlPointDistanceScoringWeight = 10000.f;
    UPROPERTY(EditInstanceOnly, Category = "Capture Point", meta = (AllowPrivateAccess = true))
    float CaptureDecayRate = 0.05f;
    /* max distance you can spawn at */
    UPROPERTY(EditInstanceOnly, Category = "Capture Point", meta = (AllowPrivateAccess = true))
    float MaxSpawnPointSearchDistance = 10000.0f;
    /* minimum distance you can spawn at*/
    UPROPERTY(EditInstanceOnly, Category = "Capture Point", meta = (AllowPrivateAccess = true))
    float MinSpawnPointSearchDistance = 3000.0f;
    /* Determines what order the points will display on the HUD */
    UPROPERTY(EditInstanceOnly, Category = "Capture Point", meta = (AllowPrivateAccess = true))
    int32 SortOrder = INDEX_NONE;
    UPROPERTY(EditInstanceOnly, Category = "Capture Point", meta = (AllowPrivateAccess = true))
    UCapsuleComponent* CapsuleComponent = NULL;
    UPROPERTY(EditInstanceOnly, Category = "Capture Point Spawns")
    TArray<class AStartPointVolume*> StartPointVolumes;
    /*Name of the point*/
    UPROPERTY(EditInstanceOnly, Category = "Capture Point", meta = (AllowPrivateAccess = true))
    FText PointName = FText::FromString("X");
    /*afflictions that prevent capture of the point*/
    UPROPERTY(EditDefaultsOnly, Category = "Capture Point")
    TArray<TSubclassOf<UAfflictionInstance>> InvalidAfflictionClasses;
    /*Can you spawn on the point regardless of team*/
    UPROPERTY(EditDefaultsOnly)
    bool bIgnoreTeamWhenSpawning = false;
    /* Does the point reset when locked*/
    UPROPERTY(EditDefaultsOnly)
    bool bResetOnLocked = false;
    /* Delay before unlocking */
    UPROPERTY(EditDefaultsOnly)
    float DelayActivationTime = 0.0f;
    /*Optional override events to the default exp events*/
    UPROPERTY(EditDefaultsOnly)
    TMap<EXPEventType,TSubclassOf<UExperienceEvent>> ExperienceEventOverrides;
    /* If true this capture point cannot be captured after its initialization */
    UPROPERTY(ReplicatedUsing = OnRep_Locked, EditInstanceOnly, Category = "Capture Point", meta = (AllowPrivateAccess = true))
    bool bLocked = false;
    UPROPERTY(ReplicatedUsing = OnRep_TeamOwner)
    int32 TeamOwner = INDEX_NONE;
    //Hold information about the current capture
    UPROPERTY(ReplicatedUsing = OnRep_CaptureInfo)
    FCaptureInfo CaptureInfo;
 
    UPROPERTY()
    TArray<TWeakObjectPtr<AProjectXCharacter>> PlayerOccupants;
    /* Privately collected using the spawning volume. */
    UPROPERTY()
    TArray<AActor*> PlayerStartList;
 
    /* both of these are managed by UpdateProcessedOccupants and are used to move capture calculations to event-driven systems */
    TMap<int32, int32> NumberOfOccupantsByTeam;
    TArray<int32> TeamStandings;
    TArray<float>CaptureCheckPoints;
    int32 CapturingTeam = INDEX_NONE;
    float PerPlayerCaptureRate = 0.1f;
    int32 NumberOfCheckPoints;
    FTimerHandle DelayedUnlockHandle;
 
public:
    UFUNCTION(BlueprintCallable)
    static void GetAllControlPoints(const UObject* WorldContextObject, TArray<class ACapturePoint*>& CapturePointList);
    UFUNCTION(BlueprintPure)
    static void GetBaseControlEventTableRow(const FBaseControlEventTableRow& TableRow, FString& AllySound, FString& EnemySound);
 
};