APatrolPathPoint Class Reference

#include <PatrolPathPoint.h>

Inheritance diagram for APatrolPathPoint:

Public Member Functions
	APatrolPathPoint ()
APatrolPathPoint *	GetNextPatrolPoint (bool &bIsBridgeAvailable) const
APatrolPathPoint *	GetPreviousPatrolPoint (bool &bIsBridgeAvailable) const
APatrolPathPoint *	GetNextBridgePatrolPoint () const
virtual bool	GetTimeToWait (float &WaitMin, float &WaitMax) const override
virtual AActor *	GetNextPatrolPointActor (bool &bIsBridgeAvailable) const override
virtual AActor *	GetNextBridgePatrolPointActor () const override
virtual AActor *	GetPreviousPatrolPointActor (bool &bIsBridgeAvailable) const override
virtual float	GetRadius () const override
virtual bool	GetIsDeadEnd () const override
virtual void	SetGravityEnabled (const bool bValue) override
virtual FString	GetObjectDisplayName () const override
virtual FInteractionData	GetInteractionData () const override
virtual bool	GetIsCharacter () const override
virtual void	OnFinishSpawning () override

Protected Member Functions
virtual void	BeginPlay () override
virtual void	OnConstruction (const FTransform &Transform) override
virtual bool	SetInteractionHidden (const EInteractionType Interaction, const bool bValue) override
virtual void	SetOnlyInteractionVisible (const EInteractionType Interaction) override
virtual bool	SetInteractionAvailable (const EInteractionType Interaction, const bool bValue) override
virtual bool	SetInteractionHold (const EInteractionType Interaction, const bool bValue) override
virtual TArray< FInteractionType >	GetVisibleInteractions () const override
virtual bool	GetInteraction (FInteractionType &Type, const EInteractionType Interaction) const override
virtual bool	GetDefaultInteraction (FInteractionType &Type) const override

Protected Attributes
class USceneComponent *	SceneRoot
class UAIPerceptionStimuliSourceComponent *	AIStimuliComponent
class UBillboardComponent *	PreviewIcon
class UArrowComponent *	ArrowComponent
class UCableComponent *	PathCableComponent
class UCableComponent *	BridgePathCableComponent
class USphereComponent *	SphereRadiusComponent
FInteractionData	InteractionData = FInteractionData(EInteractionType::None, EAIStimuliType::PatrolPoint)
int32	PathNumber = 0
int32	PathStartNumber = 0
bool	bFinalPoint = false
bool	bDeadEnd = false
bool	bUseDirection = false
FLinearColor	PathColor = FLinearColor::Blue
UMaterial *	Material
int32	PathGroup = 1
float	Radius = 50.0f
bool	bCanBridge = false
bool	bBridgeEnd = false
int32	BridgeToPathGroup = 0
int32	BridgeToPathNumber = 0
FLinearColor	BridgePathColor = FLinearColor::Red
bool	bWaitRandomTime = true
float	TimeToWaitMin = 0.0f
float	TimeToWaitMax = 1.0f
bool	bDebuggingMode = false
bool	bUpdate = false
bool	bMoveAllNumbersUp1 = false

Private Member Functions
void	RemoveVisualizers () const
void	UpdateVisualizers ()
void	UpdateAllNumbers ()
TArray< APatrolPathPoint * >	GetAllPathPoints () const
TArray< APatrolPathPoint * >	GetAllPathPointsInGroup (const int32 GroupNumber) const

Private Attributes
APatrolPathPoint *	NextPathPoint
APatrolPathPoint *	NextBridgePathPoint
APatrolPathPoint *	PreviousPathPoint

Constructor & Destructor Documentation

APatrolPathPoint()

APatrolPathPoint::APatrolPathPoint

(

)

{
    PrimaryActorTick.bCanEverTick = false;
 
    SceneRoot = CreateDefaultSubobject<USceneComponent>("Root");
    RootComponent = SceneRoot;
    AIStimuliComponent = CreateDefaultSubobject<UAIPerceptionStimuliSourceComponent>("AI Stimuli Source");
    AIStimuliComponent->RegisterForSense(UAISenseConfig_Sight::StaticClass());
 
    
    PreviewIcon = CreateDefaultSubobject<UBillboardComponent>("Icon");
    PreviewIcon->SetupAttachment(SceneRoot);
    PathCableComponent = CreateDefaultSubobject<UCableComponent>("Path Cable");
    PathCableComponent->SetupAttachment(SceneRoot);
    ArrowComponent = CreateDefaultSubobject<UArrowComponent>("Arrow");
    ArrowComponent->SetupAttachment(SceneRoot);
    BridgePathCableComponent= CreateDefaultSubobject<UCableComponent>("Path Bridge Cable");
    BridgePathCableComponent->SetupAttachment(SceneRoot);
    SphereRadiusComponent = CreateDefaultSubobject<USphereComponent>("Sphere Radius");
    SphereRadiusComponent->SetupAttachment(SceneRoot);
    SphereRadiusComponent->InitSphereRadius(Radius);
    SphereRadiusComponent->ShapeColor = PathColor.ToFColor(true);
    bDebuggingMode = true;
    
}

Member Function Documentation

BeginPlay()

void APatrolPathPoint::BeginPlay ( )

overrideprotectedvirtual

{
    Super::BeginPlay();
    AIStimuliComponent->RegisterWithPerceptionSystem(); 
    RemoveVisualizers();
}

GetAllPathPoints()

TArray< APatrolPathPoint * > APatrolPathPoint::GetAllPathPoints ( ) const

private

{
    TArray<APatrolPathPoint*> PatrolPathPoints;
    TArray<AActor*> PatrolPathActors;
    UGameplayStatics::GetAllActorsOfClass(this, GetClass(), PatrolPathActors);
    if(PatrolPathActors.Num() == 0){return PatrolPathPoints;}
    for(AActor* PathPointActor : PatrolPathActors)
    {
        APatrolPathPoint* PatrolPoint = Cast<APatrolPathPoint>(PathPointActor);
        if(PatrolPoint != nullptr)
        {
            PatrolPathPoints.Add(PatrolPoint);
        }
    }
    return PatrolPathPoints;
}

GetAllPathPointsInGroup()

TArray< APatrolPathPoint * > APatrolPathPoint::GetAllPathPointsInGroup ( const int32 GroupNumber ) const

private

{
    TArray<APatrolPathPoint*> PatrolPathPointsInGroup;
    TArray<APatrolPathPoint*> PathPoints = GetAllPathPoints();
    for(APatrolPathPoint* PathPoint : PathPoints)
    {
        if(PathPoint->PathGroup == GroupNumber)
        {
            PatrolPathPointsInGroup.Add(PathPoint);
        }
    }
    return PatrolPathPointsInGroup;
}

GetDefaultInteraction()

virtual bool APatrolPathPoint::GetDefaultInteraction ( FInteractionType & Type ) const

inlineoverrideprotectedvirtual

    {return InteractionData.GetDefaultInteraction(Type);}

GetInteraction()

virtual bool APatrolPathPoint::GetInteraction ( FInteractionType & Type, const EInteractionType Interaction ) const

inlineoverrideprotectedvirtual

    {return InteractionData.GetInteraction(Type, Interaction);}

GetInteractionData()

virtual FInteractionData APatrolPathPoint::GetInteractionData ( ) const

inlineoverridevirtual

{ return InteractionData;};

GetIsCharacter()

virtual bool APatrolPathPoint::GetIsCharacter ( ) const

inlineoverridevirtual

{return false;};

GetIsDeadEnd()

bool APatrolPathPoint::GetIsDeadEnd ( ) const

overridevirtual

Implements IPatrolInterface.

{
    return bDeadEnd;
}

GetNextBridgePatrolPoint()

APatrolPathPoint * APatrolPathPoint::GetNextBridgePatrolPoint

(

)

const

{
    return NextBridgePathPoint;
}

GetNextBridgePatrolPointActor()

AActor * APatrolPathPoint::GetNextBridgePatrolPointActor ( ) const

overridevirtual

Implements IPatrolInterface.

{
    return NextBridgePathPoint;
}

GetNextPatrolPoint()

APatrolPathPoint * APatrolPathPoint::GetNextPatrolPoint

(

bool &

bIsBridgeAvailable

)

const

{
    bIsBridgeAvailable = (NextBridgePathPoint != nullptr);
    // if(bDeadEnd)
    // {
    //  return PreviousPathPoint;
    // }
    return NextPathPoint;
}

GetNextPatrolPointActor()

AActor * APatrolPathPoint::GetNextPatrolPointActor ( bool & bIsBridgeAvailable ) const

overridevirtual

Implements IPatrolInterface.

{
    bIsBridgeAvailable = (NextBridgePathPoint != nullptr);
    return NextPathPoint;
}

GetObjectDisplayName()

virtual FString APatrolPathPoint::GetObjectDisplayName ( ) const

inlineoverridevirtual

{return "Patrol Point";};

GetPreviousPatrolPoint()

APatrolPathPoint * APatrolPathPoint::GetPreviousPatrolPoint

(

bool &

bIsBridgeAvailable

)

const

{
    bIsBridgeAvailable = (NextBridgePathPoint != nullptr);
    return PreviousPathPoint;
}

GetPreviousPatrolPointActor()

AActor * APatrolPathPoint::GetPreviousPatrolPointActor ( bool & bIsBridgeAvailable ) const

overridevirtual

Implements IPatrolInterface.

{
    bIsBridgeAvailable = (NextBridgePathPoint != nullptr);
    return PreviousPathPoint;
}

GetRadius()

virtual float APatrolPathPoint::GetRadius ( ) const

inlineoverridevirtual

Reimplemented from IPatrolInterface.

{return Radius;};

GetTimeToWait()

bool APatrolPathPoint::GetTimeToWait ( float & WaitMin, float & WaitMax ) const

overridevirtual

Implements IPatrolInterface.

{
    WaitMin = TimeToWaitMin;
    WaitMax = TimeToWaitMax;
    return bWaitRandomTime;
}

GetVisibleInteractions()

virtual TArray< FInteractionType > APatrolPathPoint::GetVisibleInteractions ( ) const

inlineoverrideprotectedvirtual

    {return InteractionData.GetVisibleInteractions();}

OnConstruction()

void APatrolPathPoint::OnConstruction ( const FTransform & Transform )

overrideprotectedvirtual

{
    Super::OnConstruction(Transform);
    ArrowComponent->SetVisibility(bUseDirection);
    if(bUpdate)
    {
        bUpdate = false;
        UE_LOG(LogAIToolKit,Warning,TEXT("Patrol Points Updated"));
    }
    UpdateVisualizers();
    UpdateAllNumbers();
    if(Material != nullptr)
    {
        UMaterialInstanceDynamic* MatInst = PathCableComponent->CreateDynamicMaterialInstance(0, Material);
        MatInst->SetVectorParameterValue(FName("Color"), PathColor);
        UMaterialInstanceDynamic* BridgeMatInst = BridgePathCableComponent->CreateDynamicMaterialInstance(0, Material);
        BridgeMatInst->SetVectorParameterValue(FName("Color"), BridgePathColor);
    }
    if(bDebuggingMode)
    {
        BridgePathCableComponent->SetVisibility(bCanBridge);
        BridgePathCableComponent->bHiddenInGame = !bCanBridge;
    }
    SphereRadiusComponent->SetSphereRadius(Radius);
    SphereRadiusComponent->ShapeColor = PathColor.ToFColor(true);
}

OnFinishSpawning()

void APatrolPathPoint::OnFinishSpawning ( )

overridevirtual

{
}

RemoveVisualizers()

void APatrolPathPoint::RemoveVisualizers ( ) const

private

{
    BridgePathCableComponent->SetVisibility(false);
    BridgePathCableComponent->bHiddenInGame = true;
    if(bDebuggingMode)
    {
        PreviewIcon->bHiddenInGame = false;
        PreviewIcon->SetVisibility(true);
        PathCableComponent->SetVisibility(true);
        PathCableComponent->bHiddenInGame = false;
        SphereRadiusComponent->SetVisibility(true);
        SphereRadiusComponent->bHiddenInGame = false;
        if(bUseDirection)
        {
            ArrowComponent->SetVisibility(true);
            ArrowComponent->bHiddenInGame = false;
        }
        if(bCanBridge && BridgePathCableComponent != nullptr)
        {
            BridgePathCableComponent->SetVisibility(true);
            BridgePathCableComponent->bHiddenInGame = false;
        }
        return;
    }
    PreviewIcon->DestroyComponent();
    PathCableComponent->DestroyComponent();
    ArrowComponent->DestroyComponent();
}

SetGravityEnabled()

virtual void APatrolPathPoint::SetGravityEnabled ( const bool bValue )

inlineoverridevirtual

{return;};

SetInteractionAvailable()

virtual bool APatrolPathPoint::SetInteractionAvailable ( const EInteractionType Interaction, const bool bValue )

inlineoverrideprotectedvirtual

    {return InteractionData.SetInteractionAvailable(Interaction, bValue);}

SetInteractionHidden()

virtual bool APatrolPathPoint::SetInteractionHidden ( const EInteractionType Interaction, const bool bValue )

inlineoverrideprotectedvirtual

Interaction Data Manipulation, so Actors can change there Interaction Data struct from BP

    {return InteractionData.SetInteractionHidden(Interaction, bValue);};

SetInteractionHold()

virtual bool APatrolPathPoint::SetInteractionHold ( const EInteractionType Interaction, const bool bValue )

inlineoverrideprotectedvirtual

    {return InteractionData.SetInteractionHold(Interaction, bValue);}

SetOnlyInteractionVisible()

virtual void APatrolPathPoint::SetOnlyInteractionVisible ( const EInteractionType Interaction )

inlineoverrideprotectedvirtual

    {InteractionData.SetOnlyInteractionVisible(Interaction);}

UpdateAllNumbers()

void APatrolPathPoint::UpdateAllNumbers ( )

private

{
    if(bMoveAllNumbersUp1)
    {
        const int32 OwnStartPoint = PathStartNumber;
        TArray<APatrolPathPoint*> PathPoints = GetAllPathPointsInGroup(PathGroup);
        if(PathPoints.Num() == 0){return;}
        for(APatrolPathPoint* PathPoint : PathPoints)
        {
            if(PathPoint->PathNumber > PathNumber)
            {
                if(PathPoint->PathStartNumber > OwnStartPoint || PathPoint->PathStartNumber == PathPoint->PathNumber)
                {
                    PathPoint->PathStartNumber++;
                }
                PathPoint->PathNumber++;
            }
        }
        bMoveAllNumbersUp1 = false;
    }
}

UpdateVisualizers()

void APatrolPathPoint::UpdateVisualizers ( )

private

{
    TArray<APatrolPathPoint*> PathPoints = GetAllPathPointsInGroup(PathGroup);
    if(PathPoints.Num() == 0){return;}
    if(PathCableComponent == nullptr){return;}
    NextPathPoint = nullptr;
    NextBridgePathPoint = nullptr;
    PathCableComponent->SetAttachEndTo(nullptr, FName(""));
    for(APatrolPathPoint* PathPoint : PathPoints)
    {
        if(bFinalPoint)
        {
            if(PathPoint->PathNumber == PathStartNumber)
            {
                NextPathPoint = PathPoint;
                PathPoint->PreviousPathPoint = this;
                PathCableComponent->SetAttachEndTo(PathPoint, FName("PathCableComponent"),FName("Center"));
            }
        }
        else
        {
            if(PathPoint->PathNumber == (PathNumber + 1))
            {
                NextPathPoint = PathPoint;
                PathPoint->PreviousPathPoint = this;
                PathCableComponent->SetAttachEndTo(PathPoint, FName("PathCableComponent"),FName("Center"));
            }
        }
    }
    if(bCanBridge)
    {
        TArray<APatrolPathPoint*> OtherGroupPathPoints = GetAllPathPointsInGroup(BridgeToPathGroup);
        if(OtherGroupPathPoints.Num() == 0){return;}
        if(BridgePathCableComponent == nullptr){return;}
        BridgePathCableComponent->SetAttachEndTo(nullptr, FName(""));
        for(APatrolPathPoint* OtherGroupPath : OtherGroupPathPoints)
        {
            if(OtherGroupPath->PathNumber == BridgeToPathNumber)
            {
                NextBridgePathPoint = OtherGroupPath;
                BridgePathCableComponent->SetAttachEndTo(OtherGroupPath, FName("PathCableComponent"),FName("Center"));
                //- Set the End of the bridge to be able to go back //
                OtherGroupPath->bBridgeEnd = true;
                OtherGroupPath->BridgeToPathGroup = PathGroup;
                OtherGroupPath->BridgeToPathNumber = PathNumber;
                // OtherGroupPath->NextBridgePathPoint = this;
            }
        }
    }
    if(bBridgeEnd)
    {
        TArray<APatrolPathPoint*> OtherGroupPathPoints = GetAllPathPointsInGroup(BridgeToPathGroup);
        if(OtherGroupPathPoints.Num() == 0){return;}
        if(BridgePathCableComponent == nullptr){return;}
        BridgePathCableComponent->SetAttachEndTo(nullptr, FName(""));
        for(APatrolPathPoint* OtherGroupPath : OtherGroupPathPoints)
        {
            if(OtherGroupPath->PathNumber == BridgeToPathNumber)
            {
                NextBridgePathPoint = OtherGroupPath;
                BridgePathCableComponent->SetAttachEndTo(OtherGroupPath, FName("PathCableComponent"),FName("Center"));
            }
        }
    }
}

Member Data Documentation

AIStimuliComponent

class UAIPerceptionStimuliSourceComponent* APatrolPathPoint::AIStimuliComponent

protected

ArrowComponent

class UArrowComponent* APatrolPathPoint::ArrowComponent

protected

bBridgeEnd

bool APatrolPathPoint::bBridgeEnd = false

protected

bCanBridge

bool APatrolPathPoint::bCanBridge = false

protected

bDeadEnd

bool APatrolPathPoint::bDeadEnd = false

protected

bDebuggingMode

bool APatrolPathPoint::bDebuggingMode = false

protected

bFinalPoint

bool APatrolPathPoint::bFinalPoint = false

protected

bMoveAllNumbersUp1

bool APatrolPathPoint::bMoveAllNumbersUp1 = false

protected

BridgePathCableComponent

class UCableComponent* APatrolPathPoint::BridgePathCableComponent

protected

BridgePathColor

FLinearColor APatrolPathPoint::BridgePathColor = FLinearColor::Red

protected

BridgeToPathGroup

int32 APatrolPathPoint::BridgeToPathGroup = 0

protected

BridgeToPathNumber

int32 APatrolPathPoint::BridgeToPathNumber = 0

protected

bUpdate

bool APatrolPathPoint::bUpdate = false

protected

bUseDirection

bool APatrolPathPoint::bUseDirection = false

protected

bWaitRandomTime

bool APatrolPathPoint::bWaitRandomTime = true

protected

InteractionData

FInteractionData APatrolPathPoint::InteractionData = FInteractionData(EInteractionType::None, EAIStimuliType::PatrolPoint)

protected

Material

UMaterial* APatrolPathPoint::Material

protected

NextBridgePathPoint

APatrolPathPoint* APatrolPathPoint::NextBridgePathPoint

private

NextPathPoint

APatrolPathPoint* APatrolPathPoint::NextPathPoint

private

PathCableComponent

class UCableComponent* APatrolPathPoint::PathCableComponent

protected

PathColor

FLinearColor APatrolPathPoint::PathColor = FLinearColor::Blue

protected

PathGroup

int32 APatrolPathPoint::PathGroup = 1

protected

PathNumber

int32 APatrolPathPoint::PathNumber = 0

protected

PathStartNumber

int32 APatrolPathPoint::PathStartNumber = 0

protected

PreviewIcon

class UBillboardComponent* APatrolPathPoint::PreviewIcon

protected

PreviousPathPoint

APatrolPathPoint* APatrolPathPoint::PreviousPathPoint

private

Radius

float APatrolPathPoint::Radius = 50.0f

protected

SceneRoot

class USceneComponent* APatrolPathPoint::SceneRoot

protected

SphereRadiusComponent

class USphereComponent* APatrolPathPoint::SphereRadiusComponent

protected

TimeToWaitMax

float APatrolPathPoint::TimeToWaitMax = 1.0f

protected

TimeToWaitMin

float APatrolPathPoint::TimeToWaitMin = 0.0f

protected

---

The documentation for this class was generated from the following files:

• T:/Unreal/Unreal Projects/SpaceAdventure52/SpaceAdventure/Plugins/AIToolKit/Source/AIToolKit/Public/Actors/PatrolPathPoint.h
• T:/Unreal/Unreal Projects/SpaceAdventure52/SpaceAdventure/Plugins/AIToolKit/Source/AIToolKit/Private/Actors/PatrolPathPoint.cpp