AISystem.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "UObject/ObjectMacros.h"
#include "UObject/SoftObjectPath.h"
#include "Engine/World.h"
#include "AI/AISystemBase.h"
#include "Math/RandomStream.h"
#include "AISystem.generated.h"
 
class UAIAsyncTaskBlueprintProxy;
class UAIHotSpotManager;
class UAIPerceptionSystem;
class UAISystem;
class UBehaviorTreeManager;
class UBlackboardComponent;
class UBlackboardData;
class UEnvQueryManager;
class UNavLocalGridManager;
 
#define GET_AI_CONFIG_VAR(a) (GetDefault<UAISystem>()->a)
 
UCLASS(config=Engine, defaultconfig, MinimalAPI)
class UAISystem : public UAISystemBase
{
    GENERATED_BODY()
 
protected:
    UPROPERTY(globalconfig, EditAnywhere, Category = "AISystem", meta = (MetaClass = "/Script/AIModule.AIPerceptionSystem", DisplayName = "Perception System Class"))
    FSoftClassPath PerceptionSystemClassName;
 
    UPROPERTY(globalconfig, EditAnywhere, Category = "AISystem", meta = (MetaClass = "/Script/AIModule.AIHotSpotManager", DisplayName = "AIHotSpotManager Class"))
    FSoftClassPath HotSpotManagerClassName;
 
    UPROPERTY(globalconfig, EditAnywhere, Category = "AISystem", meta = (MetaClass = "/Script/AIModule.EnvQueryManager", DisplayName = "EnvQueryManager Class"))
    FSoftClassPath EnvQueryManagerClassName;
public:
    UPROPERTY(globalconfig, EditDefaultsOnly, Category = "Movement")
    float AcceptanceRadius; 
 
    UPROPERTY(globalconfig, EditDefaultsOnly, Category = "Movement")
    float PathfollowingRegularPathPointAcceptanceRadius;
    
    UPROPERTY(globalconfig, EditDefaultsOnly, Category = "Movement")
    float PathfollowingNavLinkAcceptanceRadius;
    
    UPROPERTY(globalconfig, EditDefaultsOnly, Category = "Movement")
    bool bFinishMoveOnGoalOverlap;
 
    UPROPERTY(globalconfig, EditDefaultsOnly, Category = "Movement")
    bool bAcceptPartialPaths;
 
    UPROPERTY(globalconfig, EditDefaultsOnly, Category = "Movement")
    bool bAllowStrafing;
 
    UPROPERTY(globalconfig, EditDefaultsOnly, Category = "EQS")
    bool bAllowControllersAsEQSQuerier;
 
    UPROPERTY(globalconfig, EditDefaultsOnly, Category = "AISystem")
    bool bEnableDebuggerPlugin;
 
    UPROPERTY(globalconfig, EditDefaultsOnly, Category = "AISystem")
    bool bForgetStaleActors;
 
    UPROPERTY(globalconfig, EditDefaultsOnly, Category = "Blackboard")
    bool bAddBlackboardSelfKey = true;
 
    UPROPERTY(globalconfig, EditDefaultsOnly, Category = "Behavior Tree")
    bool bClearBBEntryOnBTEQSFail = true;
    
    UPROPERTY(globalconfig, EditDefaultsOnly, Category = "Behavior Tree")
    bool bBlackboardKeyDecoratorAllowsNoneAsValue = false;
 
    UPROPERTY(globalconfig, EditDefaultsOnly, Category = "Behavior Tree")
    TSoftObjectPtr<UBlackboardData> DefaultBlackboard;
 
    UPROPERTY(globalconfig, EditDefaultsOnly, Category = "PerceptionSystem")
    TEnumAsByte<ECollisionChannel> DefaultSightCollisionChannel;
 
protected:
    UPROPERTY(Transient)
    TObjectPtr<UBehaviorTreeManager> BehaviorTreeManager;
 
    UPROPERTY(Transient)
    TObjectPtr<UEnvQueryManager> EnvironmentQueryManager;
 
    UPROPERTY(Transient)
    TObjectPtr<UAIPerceptionSystem> PerceptionSystem;
 
    UPROPERTY(Transient)
    TArray<TObjectPtr<UAIAsyncTaskBlueprintProxy>> AllProxyObjects;
 
    UPROPERTY(Transient)
    TObjectPtr<UAIHotSpotManager> HotSpotManager;
 
    UPROPERTY(Transient)
    TObjectPtr<UNavLocalGridManager> NavLocalGrids;
 
    typedef TMultiMap<TWeakObjectPtr<UBlackboardData>, TWeakObjectPtr<UBlackboardComponent> > FBlackboardDataToComponentsMap;
 
    FBlackboardDataToComponentsMap BlackboardDataToComponentsMap;
 
    FDelegateHandle ActorSpawnedDelegateHandle;
 
    FDelegateHandle PawnBeginPlayDelegateHandle;
 
    static AIMODULE_API FRandomStream RandomStream;
    
public:
    AIMODULE_API UAISystem(const FObjectInitializer& ObjectInitializer);
 
    AIMODULE_API virtual void BeginDestroy() override;
    
    AIMODULE_API virtual void PostInitProperties() override;
 
    // UAISystemBase begin      
    AIMODULE_API virtual void InitializeActorsForPlay(bool bTimeGotReset) override;
    AIMODULE_API virtual void WorldOriginLocationChanged(FIntVector OldOriginLocation, FIntVector NewOriginLocation) override;
    AIMODULE_API virtual void CleanupWorld(bool bSessionEnded = true, bool bCleanupResources = true) override;
    UE_DEPRECATED(5.1, "NewWorld was unused and not always calculated correctly and we expect it is not needed; let us know on UDN if it is necessary.")
    AIMODULE_API virtual void CleanupWorld(bool bSessionEnded, bool bCleanupResources, UWorld* NewWorld) override;
    AIMODULE_API virtual void StartPlay() override;
    // UAISystemBase end
 
    inline UBehaviorTreeManager* GetBehaviorTreeManager() { return BehaviorTreeManager; }
    inline const UBehaviorTreeManager* GetBehaviorTreeManager() const { return BehaviorTreeManager; }
 
    inline UEnvQueryManager* GetEnvironmentQueryManager() { return EnvironmentQueryManager; }
    inline const UEnvQueryManager* GetEnvironmentQueryManager() const { return EnvironmentQueryManager; }
 
    inline UAIPerceptionSystem* GetPerceptionSystem() { return PerceptionSystem; }
    inline const UAIPerceptionSystem* GetPerceptionSystem() const { return PerceptionSystem; }
 
    inline UAIHotSpotManager* GetHotSpotManager() { return HotSpotManager; }
    inline const UAIHotSpotManager* GetHotSpotManager() const { return HotSpotManager; }
 
    inline UNavLocalGridManager* GetNavLocalGridManager() { return NavLocalGrids; }
    inline const UNavLocalGridManager* GetNavLocalGridManager() const { return NavLocalGrids; }
 
    inline static UAISystem* GetCurrentSafe(UWorld* World) 
    { 
        return World != nullptr ? Cast<UAISystem>(World->GetAISystem()) : NULL;
    }
 
    inline static UAISystem* GetCurrent(UWorld& World)
    {
        return Cast<UAISystem>(World.GetAISystem());
    }
 
    inline UWorld* GetOuterWorld() const { return Cast<UWorld>(GetOuter()); }
 
    virtual UWorld* GetWorld() const override { return GetOuterWorld(); }
    
    inline void AddReferenceFromProxyObject(UAIAsyncTaskBlueprintProxy* BlueprintProxy) { AllProxyObjects.AddUnique(BlueprintProxy); }
 
    inline void RemoveReferenceToProxyObject(UAIAsyncTaskBlueprintProxy* BlueprintProxy) { AllProxyObjects.RemoveSwap(BlueprintProxy); }
 
    //----------------------------------------------------------------------//
    // cheats
    //----------------------------------------------------------------------//
    UFUNCTION(exec)
    AIMODULE_API virtual void AIIgnorePlayers();
 
    UFUNCTION(exec)
    AIMODULE_API virtual void AILoggingVerbose();
 
    AIMODULE_API void RunEQS(const FString& QueryName, UObject* Target);
 
    struct FBlackboardDataToComponentsIterator
    {
    public:
        FBlackboardDataToComponentsIterator(FBlackboardDataToComponentsMap& BlackboardDataToComponentsMap, class UBlackboardData* BlackboardAsset);
 
        inline FBlackboardDataToComponentsIterator& operator++()
        {
            ++GetCurrentIteratorRef();
            TryMoveIteratorToParentBlackboard();
            return *this;
        }
        inline FBlackboardDataToComponentsIterator operator++(int)
        {
            FBlackboardDataToComponentsIterator Tmp(*this);
            ++GetCurrentIteratorRef();
            TryMoveIteratorToParentBlackboard();
            return Tmp;
        }
 
        inline explicit operator bool() const { return CurrentIteratorIndex < Iterators.Num() && (bool)GetCurrentIteratorRef(); }
        inline bool operator !() const { return !(bool)*this; }
 
        inline UBlackboardData* Key() const { return GetCurrentIteratorRef().Key().Get(); }
        inline UBlackboardComponent* Value() const { return GetCurrentIteratorRef().Value().Get(); }
 
    private:
        inline const FBlackboardDataToComponentsMap::TConstKeyIterator& GetCurrentIteratorRef() const { return Iterators[CurrentIteratorIndex]; }
        inline FBlackboardDataToComponentsMap::TConstKeyIterator& GetCurrentIteratorRef() { return Iterators[CurrentIteratorIndex]; }
 
        void TryMoveIteratorToParentBlackboard()
        {
            if (!GetCurrentIteratorRef() && CurrentIteratorIndex < Iterators.Num() - 1)
            {
                ++CurrentIteratorIndex;
                TryMoveIteratorToParentBlackboard(); // keep incrementing until we find a valid iterator.
            }
        }
 
        int32 CurrentIteratorIndex;
 
        static const int32 InlineSize = 8;
        TArray<TWeakObjectPtr<UBlackboardData>> IteratorKeysForReference;
        TArray<FBlackboardDataToComponentsMap::TConstKeyIterator, TInlineAllocator<InlineSize>> Iterators;
    };
 
    AIMODULE_API void RegisterBlackboardComponent(class UBlackboardData& BlackboardAsset, class UBlackboardComponent& BlackboardComp);
 
    AIMODULE_API void UnregisterBlackboardComponent(class UBlackboardData& BlackboardAsset, class UBlackboardComponent& BlackboardComp);
 
    AIMODULE_API FBlackboardDataToComponentsIterator CreateBlackboardDataToComponentsIterator(class UBlackboardData& BlackboardAsset);
 
    AIMODULE_API virtual void ConditionalLoadDebuggerPlugin();
 
    static const FRandomStream& GetRandomStream() { return RandomStream; }
    static void SeedRandomStream(const int32 Seed) { return RandomStream.Initialize(Seed); }
 
protected:
    AIMODULE_API virtual void OnActorSpawned(AActor* SpawnedActor);
    AIMODULE_API virtual void OnPawnBeginPlay(APawn* Pawn);
 
    AIMODULE_API void LoadDebuggerPlugin();
};