ProjectXAIController.h

Go to the documentation of this file.

// Copyright Blue Isle Studios 2017. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "ProjectXAIPerception.h"
#include "BehaviorTree/BlackboardComponent.h"
#include "Gameplay/TeamInterface.h"
#include "DetourCrowdAIController.h"
#include "ProjectXAIController.generated.h"
 
class APlayerState;
class AProjectXVehicle;
class UVehicleSeatComponent;
class AProjectXCharacter;
 
#define BLACKBOARDKEY_TARGET FName("Target")
#define BLACKBOARDKEY_MOVEWAYPOINT FName("MoveWaypoint")
#define BLACKBOARDKEY_SETTINGTARGET FName("IsSwitchingTargets")
#define BLACKBOARDKEY_RANGEMIN FName("EngagementRangeMin")
#define BLACKBOARDKEY_RANGEMAX FName("EngagementRangeMax")
#define BLACKBOARDKEY_MAXFIRINGDISTANCE FName("FiringDistance")
#define BLACKBOARDKEY_VISIBILITYEXTENT FName("VisibilityExtent")
#define BLACKBOARDKEY_AGENTHEIGHT FName("AgentHeight")
#define BLACKBOARDKEY_TARGET_THREATLEVEL FName("TargetThreatLevel")
 
UENUM(BlueprintType)
enum class ESetTargetEvent : uint8
{
    NoReason = 0,
    SelectedRandomly = 1,
    SelectedClosest = 2,
    SawTarget = 3,
    HeardTarget = 4,
    TookDamageFromTarget = 5,
    TargetLost = 6,
    TargetKilled = 7,
    TargetEnteredVehicle = 8,
    TargetExitedVehicle = 9,
    CantPathToTarget = 10
};
 
UENUM(BlueprintType)
enum class EAcquireTargetType : uint8
{
    Random = 0,
    Closest = 1
};
 
UCLASS()
class PROJECTX_API AProjectXAIController : public ADetourCrowdAIController, public ITeamInterface
{
    GENERATED_BODY()
 
public:
    /* Should the AI switch targets if attacked? */
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "AI")
    FText DisplayName = NSLOCTEXT("LEAP", "AI_DisplayName", "Bot");
    /* When the behaviour tree reports a failure (pathing, eqs failures etc), we'll increment a counter which is reset if the behaviour tree succeeds. If the value goes above our threshold, the pawn assumed lost for gameplay purposes and is terminated. -1 disables this behaviour */
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "AI")
    int32 AllowableSimultaneousFailures = -1.0f;
    /* Should we automatically select a target when the pawn is posessed? */
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "AI")
    bool bSelectTargetOnPosssess = false;
    /* Should the AI target the player's head? They will do a lot more damage on these shots. If false, will target the body.*/
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "AI")
    bool bAllowHeadshots = false;
    /* Should the AI switch targets if attacked? */
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "AI")
    bool bTargetAttackers = true;
    /* If enabled, allies will be able to be targeted. Make sure your ai's behaviours account for this if enabled. */
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "AI")
    bool bCanTargetAllies = false;
    /* If threat reaches zero, should we drop ally targets? Hostile targets are never dropped at zero threat. Low threat merely gives them an avenue to switch to higher threat targets */
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "AI", meta = (EditCondition = "bCanTargetAllies"))
    bool bDropAllyTargetsIfThreatIsZero = false;
    /* Should the AI be capable of losing its target? */
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "AI")
    bool CanLoseTarget = false;
    /*If the AI has a target, it will check every X seconds and lose the target if it is no longer visible*/
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "AI", meta=(EditCondition="CanLoseTarget"))
    float AttentionSpan = 3.0f;
    /* Wait a number of seconds before acquiring the target and running behaviours. This is useful if you want to the AI to appear reactive before beginning behaviours.  */
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "AI")
    TMap<ESetTargetEvent, float> TargetSwitchDelay;
    /* How many points of threat are decayed per second? Reaching zero, could cause the AI to drop the target depending on settings */
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "AI")
    float ThreatDecayRate = 1.0f;
    /* The ai is allowed to fire if outside of the engagement distance so long as they are within the following range. This value should always be larger or equal to your maximum engagement distance */
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "AI")
    float MaxFiringDistance = 8000.0f;
    /* The distance from the target that the AI would like to path towards. */
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "AI")
    FVector2D EngagementDistance = FVector2D(1000.0f, 5000.0f);
    /* Updates the blackboard extent trace size which allows the AI to pass or fail occlusion checks. You will want to use a size similar to the AI's weapon projectiles extent. */
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "AI")
    float VisibilityExtentTrace = 25.0f;
    /* Tolerance to allow in case pathfinding finishes queries just outside or inside of the expected bounds */
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "AI")
    float EngagementRangePadding = 300.0f;
    UPROPERTY(VisibleAnywhere, BlueprintReadWrite, Category = "AI Components")
    UProjectXAIPerception* PerceptionSystem = nullptr;
 
    AProjectXAIController();
 
    UFUNCTION(BlueprintPure, BlueprintAuthorityOnly, Category = "AI")
    AProjectXCharacter* GetProjectXAI() const;
    UFUNCTION(BlueprintPure, BlueprintAuthorityOnly, Category = "AI")
    float GetTargetThreatLevel() const;
    UFUNCTION(BlueprintPure, BlueprintAuthorityOnly, Category = "AI")
    FORCEINLINE bool HasTarget() const { return GetTarget() != nullptr; }
    UFUNCTION(BlueprintPure, BlueprintAuthorityOnly, Category = "AI")
    virtual UObject* GetTarget() const;
    UFUNCTION(BlueprintPure, BlueprintAuthorityOnly, Category = "AI")
    virtual bool CanSeeTarget() const { return bCanSeeTarget; }
    UFUNCTION(BlueprintPure, BlueprintAuthorityOnly, Category = "AI")
    virtual bool IsWithinEngagementMaxRangeOfTarget() const { return bIsWithinEngagementMaxRangeOfTarget; }
    UFUNCTION(BlueprintPure, BlueprintAuthorityOnly, Category = "AI")
    virtual bool IsWithinEngagementRangeOfTarget() const { return bIsWithinEngagementRangeOfTarget; } 
    UFUNCTION(BlueprintPure, BlueprintAuthorityOnly, Category = "AI")
    virtual bool IsWithinFiringRangeOfTarget() const { return bIsWithinFiringRangeOfTarget; } 
    UFUNCTION(BlueprintPure, BlueprintAuthorityOnly, Category = "AI")
    virtual float GetSquareFiringDistance() const { return FiringDistanceSquared; } 
    UFUNCTION(BlueprintPure, BlueprintAuthorityOnly, Category = "AI")
    virtual const FVector2D& GetSquareEngagementDistance() const { return EngagementDistanceSquared; } 
 
    UFUNCTION(BlueprintCallable, BlueprintAuthorityOnly, Category = "AI")
    virtual void SetTarget(AActor* Target, ESetTargetEvent Context, bool bAllowDelays = true, float TargetThreatLevel = 1.0f);
 
    UFUNCTION(BlueprintCallable, BlueprintAuthorityOnly, Category = "AI")
    virtual bool SelectTarget(bool bDontReselectSameTarget, EAcquireTargetType SearchType);
    UFUNCTION(BlueprintCallable, BlueprintAuthorityOnly, Category = "AI")
    virtual AActor* GetMoveActor() const { return MoveActor; }
 
    virtual void SetCanSeeTarget(bool bToggle) { bCanSeeTarget = bToggle; }
    virtual void SetIsWithinEngagementMaxRangeOfTarget(bool bToggle) { bIsWithinEngagementMaxRangeOfTarget = bToggle; }
    virtual void SetIsWithinEngagementRangeOfTarget(bool bToggle) { bIsWithinEngagementRangeOfTarget = bToggle; }
    virtual void SetIsWithinFiringRangeOfTarget(bool bToggle) { bIsWithinFiringRangeOfTarget = bToggle; }
 
    template <class T>
    T* GetTarget() const
    {
        if (GetBlackboardComponent())
        {
            return Cast<T>(GetBlackboardComponent()->GetValueAsObject(BLACKBOARDKEY_TARGET));
        }
        return nullptr;
    }
 
protected:
    virtual void BeginPlay() override;
    virtual void CheckIfStuck();
    virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;
    virtual void UpdateCanLoseTarget();
    virtual void UpdateThreatDecay();
    virtual void OnBehaviourTreeFailureReported();
    virtual void OnBehaviourTreeSuccess();
    virtual void OnPossess(APawn* InPawn) override;
    virtual void OnUnPossess() override;
    virtual int32 GetTeam() const override;
    virtual int32 SetTeam(int32 NewTeam) override;
    virtual FVector GetFocalPointOnActor(const AActor* Actor) const override;
 
    UFUNCTION()
    void OnTargetKilled(class AActor* Victim, const float Damage, struct FDamageEvent const& DamageEvent, const class AController* EventInstigator, const class AActor* DamageCauser, const class APlayerState* InstigatorPlayerState);
    UFUNCTION()
    void OnTargetVehicleEnter(AProjectXCharacter* Driver, AProjectXVehicle* CurrentVehicle, AProjectXVehicle* PreviousVehicle);
    UFUNCTION()
    void OnTargetVehicleExit(AProjectXVehicle* Vehicle, UVehicleSeatComponent* Seat, AProjectXCharacter* PreviousPassenger);
    UFUNCTION()
    void OnPawnDeath(class AActor* Victim, const float Damage, struct FDamageEvent const& DamageEvent, const class AController* EventInstigator, const class AActor* DamageCauser, const class APlayerState* InstigatorPlayerState);
    UFUNCTION()
    virtual void OnPerceptionUpdated(TArray<FProjectXPerceptionInfo> Perceptions);
 
private:
    mutable AProjectXCharacter* CachedPawn = nullptr;
    FTimerHandle UpdateTargetTimerHandle;
    FTimerHandle ThreatDecayTimerHandle;
    FTimerHandle TargetSwitchDelayTimerHandle;
    AActor* MoveActor = nullptr;
    FVector SpawnLocation = FVector::ZeroVector;
    int32 FailCounter = 0;
    bool bCanSeeTarget = false;
    bool bIsWithinEngagementMaxRangeOfTarget = false;
    bool bIsWithinEngagementRangeOfTarget = false;
    bool bIsWithinFiringRangeOfTarget = false;
    float FiringDistanceSquared = 0.0f;
    FVector2D EngagementDistanceSquared = FVector2D::ZeroVector;
    FVector CachedPawnPosition = FVector::ZeroVector;
};