AAISpawnLocation Class Reference

#include <AISpawnLocation.h>

Inheritance diagram for AAISpawnLocation:

Public Member Functions
	AAISpawnLocation ()
void	AIDeath (AActor *OwningActor, EDeathType DeathType, AActor *DeathCauser, AController *DeathInstigator)
void	SetSpawnLocationData (const FAISpawnLocationData Data)

Public Attributes
FOnAISpawned	OnAISpawned
FOnFinishedSpawning	OnFinishedSpawning

Protected Member Functions
virtual void	BeginPlay () override
virtual void	OnConstruction (const FTransform &Transform) override

Protected Attributes
class USceneComponent *	SceneRoot
class UBillboardComponent *	PreviewIcon
class USphereComponent *	TriggerAreaComponent
class USphereComponent *	SpawnAreaComponent
float	SpawnRadius = 400.0f
float	SpawnDistance = 2000.0f
FAISpawnLocationData	AISpawnLocationData
bool	bDebuggingMode = false
TArray< APawn * >	SpawnedAI
float	SpawnDelayCheck = 2.0f

Private Member Functions
FVector	GetRandomSpawnLocation (TArray< FVector > &Locations)
FVector	GetRandomSpawnLocationInArea (TArray< FVector > &Locations)
bool	IsPointInsideSphere (const FVector &Point, const USphereComponent *Sphere)
void	CheckAISpawnData ()
void	RemoveVisualizers () const
void	SetRandomNumber ()
void	CheckForSpawn ()
void	SpawnAI ()
void	SpawnAICharacter (FAISpawnLocationData &SpawnLocationData)

Private Attributes
FTimerHandle	InitialDelayTimerHandle
FTimerHandle	NextSpawnTimerHandle
FTimerHandle	DestroyTimerHandle
int32	LastUsedLocationIndex = -1

Constructor & Destructor Documentation

AAISpawnLocation()

AAISpawnLocation::AAISpawnLocation

(

)

{
    PrimaryActorTick.bCanEverTick = false;
    SceneRoot = CreateDefaultSubobject<USceneComponent>("Root");
    RootComponent = SceneRoot;
    PreviewIcon = CreateDefaultSubobject<UBillboardComponent>("Icon");
    PreviewIcon->SetupAttachment(SceneRoot);
    TriggerAreaComponent = CreateDefaultSubobject<USphereComponent>("Trigger Area");
    TriggerAreaComponent->SetupAttachment(SceneRoot);
    TriggerAreaComponent->InitSphereRadius(SpawnDistance);
    SpawnAreaComponent = CreateDefaultSubobject<USphereComponent>("Spawn Area");
    SpawnAreaComponent->SetupAttachment(SceneRoot);
    SpawnAreaComponent->InitSphereRadius(SpawnRadius);
}

Member Function Documentation

AIDeath()

void AAISpawnLocation::AIDeath	(	AActor *	OwningActor,
		EDeathType	DeathType,
		AActor *	DeathCauser,
		AController *	DeathInstigator )

{
    if(OwningActor != nullptr)
    {
        APawn* SpawnedPawn = Cast<APawn>(OwningActor);
        if(SpawnedPawn == nullptr){return;}
        
        if(SpawnedAI.Contains(SpawnedPawn))
        {
            SpawnedAI.Remove(SpawnedPawn);
        }
    }
}

BeginPlay()

void AAISpawnLocation::BeginPlay ( )

overrideprotectedvirtual

{
    Super::BeginPlay();
    RemoveVisualizers();
    GetWorld()->GetTimerManager().SetTimer(DestroyTimerHandle, this, &AAISpawnLocation::CheckAISpawnData, SpawnDelayCheck);
    // if(AISpawnLocationData.bUseSpawnLocations)
    // {
    //
    //  if(AISpawnLocationData.bUseSpawnLocationsGlobal)
    //  {
    //      
    //  }
    // }
    // TArray<AActor> OverlappingActors;
    // GetOverlappingActors()
}

CheckAISpawnData()

void AAISpawnLocation::CheckAISpawnData ( )

private

{
    //- If We dont have any spawn data, Destroy the actor   //
    if(AISpawnLocationData.ActorToSpawn == nullptr){UE_LOG(LogAIToolKit, Error, TEXT("Actor to Spawn NULL"))Destroy();return;}
    SetRandomNumber();
    GetWorld()->GetTimerManager().SetTimer(InitialDelayTimerHandle, this, &AAISpawnLocation::CheckForSpawn, AISpawnLocationData.InitialDelay);
}

CheckForSpawn()

void AAISpawnLocation::CheckForSpawn ( )

private

{
    // if(/*Distance to player*/ 1.0f < SpawnDistance)
    // {
        if(AISpawnLocationData.AmountToSpawn != 0)
        {
            SpawnAI();
        }
    // }
}

GetRandomSpawnLocation()

FVector AAISpawnLocation::GetRandomSpawnLocation ( TArray< FVector > & Locations )

private

{
    if(Locations.Num() == 0)
    {
        return FVector::Zero();
    }
    if(Locations.Num() == 1)
    {
        return Locations[0];
    }
    int32 LocationIndex = UKismetMathLibrary::RandomIntegerInRange(0, Locations.Num());
    if(LocationIndex == LastUsedLocationIndex)
    {
        LocationIndex = UKismetMathLibrary::RandomIntegerInRange(0, Locations.Num());
    }
    LastUsedLocationIndex = LocationIndex; 
    return Locations[LocationIndex];
}

GetRandomSpawnLocationInArea()

FVector AAISpawnLocation::GetRandomSpawnLocationInArea ( TArray< FVector > & Locations )

private

{
    TArray<FVector> SpawnLocations;
    for(const FVector& Location : Locations)
    {
        if(IsPointInsideSphere(Location, SpawnAreaComponent))
        {
            SpawnLocations.Add(Location);
        }
    }
    return GetRandomSpawnLocation(SpawnLocations);
}

IsPointInsideSphere()

bool AAISpawnLocation::IsPointInsideSphere ( const FVector & Point, const USphereComponent * Sphere )

private

{
    if(Sphere == nullptr){return false;}
 
    const float Radius = Sphere->GetScaledSphereRadius();
    const FVector SphereCenter = Sphere->GetComponentLocation();
 
    // Calculate the squared distance from the point to the sphere's center
    const float DistSquared = FVector::DistSquared(Point, SphereCenter);
 
    // Check if the squared distance is less than or equal to the squared radius
    return DistSquared <= FMath::Square(Radius);
}

OnConstruction()

void AAISpawnLocation::OnConstruction ( const FTransform & Transform )

overrideprotectedvirtual

{
    Super::OnConstruction(Transform);
    SpawnAreaComponent->SetSphereRadius(SpawnRadius);
    TriggerAreaComponent->SetSphereRadius(SpawnDistance);
}

RemoveVisualizers()

void AAISpawnLocation::RemoveVisualizers ( ) const

private

{
    if(bDebuggingMode)
    {
        SpawnAreaComponent->bHiddenInGame = false;
        SpawnAreaComponent->SetVisibility(true);
        TriggerAreaComponent->SetVisibility(true);
        TriggerAreaComponent->bHiddenInGame = false;
        return;
    }
    PreviewIcon->DestroyComponent();
    // SpawnAreaComponent->DestroyComponent();
    SpawnAreaComponent->bHiddenInGame = true;
    SpawnAreaComponent->SetVisibility(false);
    TriggerAreaComponent->DestroyComponent();
}

SetRandomNumber()

void AAISpawnLocation::SetRandomNumber ( )

private

{
    //- if using Random number replace the data //
    if(AISpawnLocationData.bUseRandomSpawnNumber)
    {
        const int32 RandomAmount = UKismetMathLibrary::RandomIntegerInRange(AISpawnLocationData.SpawnMin, AISpawnLocationData.SpawnMin);
        AISpawnLocationData.AmountToSpawn = RandomAmount;
        AISpawnLocationData.bUseRandomSpawnNumber = false;
        AISpawnLocationData.SpawnMin = 0;
        AISpawnLocationData.SpawnMax = 0;
    }
}

SetSpawnLocationData()

void AAISpawnLocation::SetSpawnLocationData ( const FAISpawnLocationData Data )

inline

{AISpawnLocationData = Data;};

SpawnAI()

void AAISpawnLocation::SpawnAI ( )

private

{
    SpawnAICharacter(AISpawnLocationData);
    const float TimeTillNextSpawn = UKismetMathLibrary::RandomFloatInRange(AISpawnLocationData.TimeBetweenSpawnsMin, AISpawnLocationData.TimeBetweenSpawnsMax);
    if(SpawnedAI.Num() < AISpawnLocationData.AmountToSpawn)
    {
        GetWorld()->GetTimerManager().SetTimer(NextSpawnTimerHandle, this, &AAISpawnLocation::SpawnAI, TimeTillNextSpawn);
    }
    else
    {
        // if(bDebuggingMode){UE_LOG(LogAIToolKit, Warning, TEXT("ON finished??"));}
        OnFinishedSpawning.Broadcast(this);
    }
}

SpawnAICharacter()

void AAISpawnLocation::SpawnAICharacter ( FAISpawnLocationData & SpawnLocationData )

private

{
    if(SpawnLocationData.ActorToSpawn == nullptr){UE_LOG(LogAIToolKit,Error,TEXT("No Actor to Spawn in AISpawnLocation"));return;}
    FVector RandomSpawnLocation = FVector::Zero();
    if(SpawnLocationData.bUseSpawnLocations)
    {
        if(!SpawnLocationData.SpawnLocations.IsEmpty())
        {
            if(SpawnLocationData.bUseSpawnLocationsGlobal)
            {
                RandomSpawnLocation = GetRandomSpawnLocation(SpawnLocationData.SpawnLocations);
            }
            else
            {
                RandomSpawnLocation = GetRandomSpawnLocationInArea(SpawnLocationData.SpawnLocations);
            }
        }
        //@TODO Check if the locations are in the SpawnArea,
        // GetRandomLocation
    }
    //@TODO rotation possibly screwing up aLS??
    const float SpawnRotationZ = UKismetMathLibrary::RandomFloatInRange(0.0f, 360.0f);
    const FRotator SpawnRotation = FRotator(0.0f, SpawnRotationZ, 0.0f);
    FNavLocation SpawnLocation;
    if(RandomSpawnLocation != FVector::Zero())
    {
        SpawnLocation = FNavLocation(RandomSpawnLocation);
    }
    else
    {
        const UNavigationSystemV1* NavSystemV1 = FNavigationSystem::GetCurrent<UNavigationSystemV1>(GetWorld());
        if(NavSystemV1 == nullptr){UE_LOG(LogAIToolKit,Warning,TEXT("Navigation System Failed in AI Spawner"));return;}
        const bool bSuccess = NavSystemV1->GetRandomReachablePointInRadius(SpawnAreaComponent->GetComponentLocation(), SpawnAreaComponent->GetScaledSphereRadius(), SpawnLocation);
        if(!bSuccess)
        {
            if(bDebuggingMode){UE_LOG(LogAIToolKit, Error, TEXT("Random Point Failed"));}
            return;
        }
    }
    APawn* SpawnedPawn = UAIBlueprintHelperLibrary::SpawnAIFromClass(this, SpawnLocationData.ActorToSpawn,nullptr, SpawnLocation, SpawnRotation, true, this);
    if(SpawnedPawn == nullptr){if(bDebuggingMode){UE_LOG(LogAIToolKit, Error, TEXT("Spawn Failed"));}return;}
 
    OnAISpawned.Broadcast(SpawnedPawn, this);
    SpawnedAI.Add(SpawnedPawn);
}

Member Data Documentation

AISpawnLocationData

FAISpawnLocationData AAISpawnLocation::AISpawnLocationData

protected

bDebuggingMode

bool AAISpawnLocation::bDebuggingMode = false

protected

DestroyTimerHandle

FTimerHandle AAISpawnLocation::DestroyTimerHandle

private

InitialDelayTimerHandle

FTimerHandle AAISpawnLocation::InitialDelayTimerHandle

private

LastUsedLocationIndex

int32 AAISpawnLocation::LastUsedLocationIndex = -1

private

NextSpawnTimerHandle

FTimerHandle AAISpawnLocation::NextSpawnTimerHandle

private

OnAISpawned

FOnAISpawned AAISpawnLocation::OnAISpawned

OnFinishedSpawning

FOnFinishedSpawning AAISpawnLocation::OnFinishedSpawning

PreviewIcon

class UBillboardComponent* AAISpawnLocation::PreviewIcon

protected

SceneRoot

class USceneComponent* AAISpawnLocation::SceneRoot

protected

SpawnAreaComponent

class USphereComponent* AAISpawnLocation::SpawnAreaComponent

protected

SpawnDelayCheck

float AAISpawnLocation::SpawnDelayCheck = 2.0f

protected

SpawnDistance

float AAISpawnLocation::SpawnDistance = 2000.0f

protected

SpawnedAI

TArray<APawn*> AAISpawnLocation::SpawnedAI

protected

SpawnRadius

float AAISpawnLocation::SpawnRadius = 400.0f

protected

TriggerAreaComponent

class USphereComponent* AAISpawnLocation::TriggerAreaComponent

protected

---

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

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