ASecurityCameraPawn Class Reference

Represents a security camera pawn in the game. More...

#include <SecurityCameraPawn.h>

Inheritance diagram for ASecurityCameraPawn:

Public Member Functions
	ASecurityCameraPawn ()
void	OnSnappedToObject (const bool bValue)
Public Member Functions inherited from ADefenseSystemPawn
	ADefenseSystemPawn ()
virtual ETeamAttitude::Type	GetTeamAttitudeTowards (const AActor &Other) const override
virtual void	SetGenericTeamId (const FGenericTeamId &NewTeamID) override
virtual FGenericTeamId	GetGenericTeamId () const override
virtual FRotator	GetTargetRotation () const override
bool	GetActive () const
void	SetActive (const bool bValue)
void	OnActivated (const bool bValue)
virtual void	OnActivated_Implementation (const bool bValue)
Public Member Functions inherited from AInteractablePawn
	AInteractablePawn ()
virtual void	ReceiveStartFocus (AActor *Caller)
virtual void	ReceiveEndFocus (AActor *Caller)
virtual void	ReceiveOnInteract (AActor *Caller, const EInteractionType InteractionType)
virtual void	ReceiveOnEndInteract (AActor *Caller)
virtual void	ReceiveOnOverlap (AActor *Caller)
virtual void	ReceiveOnEndOverlap (AActor *Caller)
virtual void	ReceiveToggleSwitch (AActor *Caller, const bool bOn)
virtual void	InteractionDataUpdated ()
virtual void	SetupPlayerInputComponent (class UInputComponent *PlayerInputComponent) override
Public Member Functions inherited from ICharacterInterface
virtual USkeletalMeshComponent *	GetCharacterSecondaryMesh () const
virtual void	StartThreatIndication (AActor *PawnThreat)
virtual void	UpdateThreatIndication (const FVector &Location, const float DetectionAmount)
virtual void	StopThreatIndication ()
Public Member Functions inherited from IPhysicsPickup
virtual void	SetInteracting (const bool bValue)=0
virtual bool	GetCanBeSnapped (const int32 Size) const
virtual bool	GetCanBeRotated () const
virtual bool	GetUseAutoRotation () const

Protected Member Functions
virtual void	BeginPlay () override
virtual void	GetActorEyesViewPoint (FVector &OutLocation, FRotator &OutRotation) const override
virtual bool	GetIsUpsideDown () const override
virtual void	TargetSeen (APawn *Pawn) override
virtual void	EnemySeen () override
virtual void	LostAllTargets () override
virtual void	RotateToTarget () override
void	RotateCamera ()
virtual void	OnDeath (AActor *OwningActor, EDeathType DeathType, AActor *DeathCauser, AController *DeathInstigator) override
virtual UPrimitiveComponent *	GetGrabComponent () const override
virtual FPhysicsPickupData	GetPhysicsPickupData () const override
virtual bool	GetIsSnapped () const override
virtual void	SetSnapped (const bool bValue) override
virtual TArray< UArrowComponent * >	GetSnapComponents () override
Protected Member Functions inherited from ADefenseSystemPawn
int32	GetTeamID () const
virtual ECharacterType	GetCharacterType () const override
virtual EFactionType	GetCharacterFaction () const override
virtual bool	GetIsDead () const override
virtual void	SetCharacterVehicleMode (const EVehicleMode Mode) override
void	OnNewTargetSeen (APawn *Pawn)
void	OnTargetSeen (APawn *Pawn)
void	OnHostileSeen ()
void	OnHostileSeenUpdate ()
void	OnTargetLost ()
void	OnLostAllTargets ()
void	OnAlertChange (const float CurrentAlertLevel, const float MaxAlertLevel)
virtual bool	GetIsCharacter () const override
virtual void	PointDamageTaken (AActor *DamagedActor, float Damage, class AController *InstigatedBy, FVector HitLocation, class UPrimitiveComponent *HitComponent, FName BoneName, FVector ShotFromDirection, const class UDamageType *DamageType, AActor *DamageCauser)
bool	CanStillSeePawn (APawn *Pawn) const
bool	IsPawnAlive (APawn *Pawn) const
bool	GetCurrentTarget (APawn *&Pawn) const
TArray< APawn * > &	GetTargets ()
float	GetDistanceToPawn (const APawn *Pawn) const
float	GetTotalDistanceScoreToAllTargets () const
virtual FRotator	GetRotationToTarget (const FVector &StartLocation)
virtual void	NewTargetSeen (APawn *Pawn)
Protected Member Functions inherited from AInteractablePawn
virtual bool	SaveGame () override
virtual bool	LoadGame () override
FVector	GetCustomInteractionLocation () const
void	LogDebugError (const FString &Message) const
void	LogDebugError (const FString &Message, const int32 Value) const
void	LogDebugError (const FString &Message, const float Value) const
void	LogDebugWarning (const FString &Message) const
void	LogDebugWarning (const FString &Message, const int32 Value) const
void	LogDebugWarning (const FString &Message, const float Value) const
void	LogDebugMessage (const FString &Message, const bool bWarning=false, const bool bError=false) const
void	LogDebugMessage (const FString &Message, const int32 Value, const bool bWarning=false, const bool bError=false) const
void	LogDebugMessage (const FString &Message, const float Value, const bool bWarning=false, const bool bError=false) const
void	LogDebugMessage (const FString &Message, const bool bValue, const bool bWarning, const bool bError) const
void	LogOnScreenMessage (const int32 Key, const FString &Message, FColor Color=FColor::Green) const
void	SetCategoryName (const FLogCategoryBase &Category)

Protected Attributes
UStaticMeshComponent *	BaseMeshComponent
UStaticMeshComponent *	HeadMeshComponent
UCameraComponent *	CameraComponent
USpotLightComponent *	SpotLightComponent
USceneCaptureComponent2D *	SceneCaptureComponent
USceneComponent *	SnapTargets
FPhysicsPickupData	PhysicsPickupData
bool	bSnapped = false
float	CameraRotateFrequency = 0.1f
float	CameraRotateToTargetFrequency = 0.1f
float	CameraMaxRotation = 90.0f
float	CameraTargetRotationTolerance = 10.0f
float	VisibilityPercentNeeded = 60.0f
float	RotationOffset = -90.0f
Protected Attributes inherited from ADefenseSystemPawn
FGenericTeamId	TeamID
ECharacterType	CharacterType = ECharacterType::Defence
EFactionType	OwnerFaction = EFactionType::Alliance
FRotator	StartRotation = FRotator::ZeroRotator
FRotator	TargetRotation = FRotator::ZeroRotator
float	AlertUpdateFrequency = 0.2f
float	AlertLevelIncrease = 0.1f
float	AlertLevelDecrease = 0.1f
float	AlertLevelThreshold = 100.0f
float	AlertLevel = 0.0f
bool	bAlert = false
float	VisibilityCheckFrequency = 2.0f
bool	bInstantResetOnLostTarget = false
float	LostTargetResetTime = 2.0f
bool	bDead = false
bool	bAutoActivate = true
UHealthComponentBase *	HealthComponent
UAdvancedPawnSensingComponent *	PawnSensingComponent
Protected Attributes inherited from AInteractablePawn
class UAudioReactionComponent *	AudioReactionComponent
class UInteractableActorComponent *	InteractableActorComponent
class UAIPerceptionStimuliSourceComponent *	PerceptionStimuliComponent
bool	bDebuggingMode = false

Private Member Functions
void	RotateBackToStart ()

Private Attributes
bool	bChangeDirection = false
float	LerpAlpha = 0.0f
FRotator	StartRelativeRotation = FRotator::ZeroRotator
FTimerHandle	RotateTimerHandle
FTimerHandle	RotateToTargetTimerHandle
FTimerHandle	RotateBackToStartTimerHandle

Detailed Description

Represents a security camera pawn in the game.

The ASecurityCameraPawn class is a blueprintable actor class that represents a security camera pawn in the game. It inherits from AInteractablePawn and implements functionality for rotating the camera, detecting hostile targets, and more.

Constructor & Destructor Documentation

ASecurityCameraPawn()

ASecurityCameraPawn::ASecurityCameraPawn

(

)

{
    BaseMeshComponent = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Base Mesh"));
    RootComponent = BaseMeshComponent;
    HeadMeshComponent = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Head Mesh"));
    HeadMeshComponent->SetupAttachment(BaseMeshComponent);
    
    CameraComponent = CreateDefaultSubobject<UCameraComponent>(TEXT("Camera"));
    CameraComponent->SetupAttachment(HeadMeshComponent);
    SpotLightComponent = CreateDefaultSubobject<USpotLightComponent>(TEXT("SpotLight"));
    SpotLightComponent->SetupAttachment(CameraComponent);
    
    SceneCaptureComponent = CreateDefaultSubobject<USceneCaptureComponent2D>(TEXT("Scene Capture"));
    SceneCaptureComponent->SetupAttachment(CameraComponent);
 
    SnapTargets = CreateDefaultSubobject<USceneComponent>(TEXT("Snap Targets"));
    SnapTargets->SetupAttachment(BaseMeshComponent);
 
    PhysicsPickupData.bSnappable = true;
    bAutoActivate = false;
}

Member Function Documentation

BeginPlay()

void ASecurityCameraPawn::BeginPlay ( )

overrideprotectedvirtual

Reimplemented from ADefenseSystemPawn.

{
    Super::BeginPlay();
    if(GetWorld() != nullptr)
    {
        GetWorld()->GetTimerManager().SetTimer(RotateTimerHandle, this, &ASecurityCameraPawn::RotateCamera, CameraRotateFrequency, true);
    }
    if(HeadMeshComponent != nullptr)
    {
        StartRotation = HeadMeshComponent->GetComponentRotation();
        StartRelativeRotation = HeadMeshComponent->GetRelativeRotation();
    }
    if(BaseMeshComponent == nullptr) {return;}
    BaseMeshComponent->SetSimulatePhysics(!bSnapped);
}

EnemySeen()

void ASecurityCameraPawn::EnemySeen ( )

overrideprotectedvirtual

Reimplemented from ADefenseSystemPawn.

{
    Super::EnemySeen();
    GetWorld()->GetTimerManager().ClearTimer(RotateTimerHandle);
    if(GetWorld()->GetTimerManager().IsTimerActive(RotateToTargetTimerHandle) == false)
    {
        GetWorld()->GetTimerManager().SetTimer(RotateToTargetTimerHandle, this, &ASecurityCameraPawn::RotateToTarget, CameraRotateFrequency, true);
    }
}

GetActorEyesViewPoint()

void ASecurityCameraPawn::GetActorEyesViewPoint ( FVector & OutLocation, FRotator & OutRotation ) const

overrideprotectedvirtual

Reimplemented from ADefenseSystemPawn.

{
    if(CameraComponent != nullptr)
    {
        OutLocation = CameraComponent->GetComponentLocation();
        OutRotation = CameraComponent->GetComponentRotation();
        return;
    }
    Super::GetActorEyesViewPoint(OutLocation, OutRotation);
}

GetGrabComponent()

UPrimitiveComponent * ASecurityCameraPawn::GetGrabComponent ( ) const

overrideprotectedvirtual

Implements IPhysicsPickup.

{
    return BaseMeshComponent;
}

GetIsSnapped()

virtual bool ASecurityCameraPawn::GetIsSnapped ( ) const

inlineoverrideprotectedvirtual

Implements IPhysicsPickup.

{return bSnapped;};

GetIsUpsideDown()

bool ASecurityCameraPawn::GetIsUpsideDown ( ) const

overrideprotectedvirtual

Reimplemented from ADefenseSystemPawn.

{
    return Super::GetIsUpsideDown();
}

GetPhysicsPickupData()

virtual FPhysicsPickupData ASecurityCameraPawn::GetPhysicsPickupData ( ) const

inlineoverrideprotectedvirtual

Implements IPhysicsPickup.

{return PhysicsPickupData;};

GetSnapComponents()

TArray< UArrowComponent * > ASecurityCameraPawn::GetSnapComponents ( )

overrideprotectedvirtual

Implements IPhysicsPickup.

{
    TArray<USceneComponent*> Components;
    SnapTargets->GetChildrenComponents(false, Components);
    TArray<UArrowComponent*> ArrowComponents;
    for(const auto Component : Components)
    {
        UArrowComponent* Arrow = Cast<UArrowComponent>(Component);
        if(Arrow != nullptr)
        {
            ArrowComponents.Add(Arrow);
        }
    }
    return ArrowComponents;
}

LostAllTargets()

void ASecurityCameraPawn::LostAllTargets ( )

overrideprotectedvirtual

Reimplemented from ADefenseSystemPawn.

{
    Super::LostAllTargets();
    LerpAlpha = 1.0f;
    if(GetWorld() != nullptr)
    {
        GetWorld()->GetTimerManager().ClearTimer(RotateToTargetTimerHandle);
        GetWorld()->GetTimerManager().SetTimer(RotateBackToStartTimerHandle, this, &ASecurityCameraPawn::RotateBackToStart, CameraRotateFrequency, true);
    }
}

OnDeath()

void ASecurityCameraPawn::OnDeath ( AActor * OwningActor, EDeathType DeathType, AActor * DeathCauser, AController * DeathInstigator )

overrideprotectedvirtual

Reimplemented from ADefenseSystemPawn.

{
    Super::OnDeath(OwningActor, DeathType, DeathCauser, DeathInstigator);
    if(HeadMeshComponent != nullptr)
    {
        HeadMeshComponent->SetSimulatePhysics(true);
    }
    if(CameraComponent != nullptr)
    {
        CameraComponent->DestroyComponent();
    }
    if(SpotLightComponent != nullptr)
    {
        SpotLightComponent->DestroyComponent();
    }
    if(GetWorld() != nullptr)
    {
        GetWorld()->GetTimerManager().ClearTimer(RotateTimerHandle);
    }
}

OnSnappedToObject()

void ASecurityCameraPawn::OnSnappedToObject

(

const bool

bValue

)

RotateBackToStart()

void ASecurityCameraPawn::RotateBackToStart ( )

private

{
    if(GetActive() == false || GetIsDead()){return;}
    // HeadMeshComponent->SetWorldRotation(FRotator(0.0f, StartRotation.Yaw, 0.0f));
    GetWorld()->GetTimerManager().ClearTimer(RotateBackToStartTimerHandle);
    GetWorld()->GetTimerManager().SetTimer(RotateTimerHandle, this, &ASecurityCameraPawn::RotateCamera, CameraRotateFrequency, true);
 
    // if(bDebuggingMode){UE_LOG(LogAIToolKit, Warning, TEXT("Rotate Back Alpha: %f"), LerpAlpha);}
    // const float LerpValue = UKismetMathLibrary::Lerp(StartRotation.Yaw, HeadMeshComponent->GetComponentRotation().Yaw, LerpAlpha);
 //    LerpAlpha = FMath::Max(0.0f, LerpAlpha - CameraRotateFrequency);
    // HeadMeshComponent->SetWorldRotation(FRotator(0.0f, LerpValue, 0.0f));
    // if(LerpAlpha <= 0.0f)
    // {
    //  GetWorld()->GetTimerManager().ClearTimer(RotateBackToStartTimerHandle);
    //  GetWorld()->GetTimerManager().SetTimer(RotateTimerHandle, this, &ASecurityCameraPawn::RotateCamera, CameraRotateFrequency, true);
    // }
    //@TODO Once done, start Rotate
}

RotateCamera()

void ASecurityCameraPawn::RotateCamera ( )

protected

{
    if(GetActive() == false || GetIsDead()){return;}
    if(HeadMeshComponent == nullptr)
    {
        if(bDebuggingMode){UE_LOG(LogAIToolKit, Error, TEXT("Head Mesh null in Security Camera"));}
        GetWorld()->GetTimerManager().ClearTimer(RotateTimerHandle);
        return;
    }
    const float DirectionYaw = bChangeDirection ? -1.0f : 1.0f;
    HeadMeshComponent->AddRelativeRotation(FRotator(0.0f,DirectionYaw,0.0f));
    //- Check if rotation has reached or exceeded the maximum rotation angle
    if ((bChangeDirection && (HeadMeshComponent->GetRelativeRotation().Yaw - StartRelativeRotation.Yaw) <= -CameraMaxRotation) ||
        (!bChangeDirection && (HeadMeshComponent->GetRelativeRotation().Yaw - StartRelativeRotation.Yaw) >= CameraMaxRotation))
    {
        bChangeDirection = !bChangeDirection;
    }
    // if(CurrentTarget == nullptr && CameraViewCollision != nullptr)
    // {
    //  TArray<AActor*> OverlappingActors;
    //  CameraViewCollision->GetOverlappingActors(OverlappingActors, APawn::StaticClass());
    //  if(OverlappingActors.IsEmpty()){return;}
    //  for(const auto& OverlapActor : OverlappingActors)
    //  {
    //      ICharacterInterface* CharacterOverlapped = Cast<ICharacterInterface>(OverlapActor);
    //      if(CharacterOverlapped == nullptr){continue;}
    //      if(CharacterOverlapped->GetIsDead()){continue;}
    //      const ETeamAttitude::Type Attitude = GetTeamAttitudeTowards(*OverlapActor);
    //      if(Attitude != ETeamAttitude::Hostile){continue;}
    //      
    //      const float VisibilityScore = GetVisibilityScore(OverlapActor);
    //      if(VisibilityScore > VisibilityPercentNeeded)
    //      {
    //          CurrentTarget = OverlapActor;
    //          CurrentCharacterTarget = CharacterOverlapped;
    //          GainedTarget();
    //      }
    //      
    //  }
    // }
}

RotateToTarget()

void ASecurityCameraPawn::RotateToTarget ( )

overrideprotectedvirtual

Reimplemented from ADefenseSystemPawn.

{
    if(GetActive() == false || GetIsDead()){return;}
    Super::RotateToTarget();
    APawn* TargetPawn;
    if(GetCurrentTarget(TargetPawn) == false || TargetPawn == nullptr || HeadMeshComponent == nullptr){return;}
    
    const FRotator NewRotation = GetRotationToTarget(GetActorLocation());
    float DesiredYaw = NewRotation.Yaw;
    const float MinYaw = UKismetMathLibrary::NormalizeAxis(StartRotation.Yaw - CameraMaxRotation);
    const float MaxYaw = UKismetMathLibrary::NormalizeAxis(StartRotation.Yaw + CameraMaxRotation);
 
    DesiredYaw = UKismetMathLibrary::NormalizeAxis(DesiredYaw);
    // Clamp the normalized desired yaw
    DesiredYaw = FMath::ClampAngle(DesiredYaw, MinYaw, MaxYaw);
    // const float LerpValue = UKismetMathLibrary::Lerp(HeadMeshComponent->GetComponentRotation().Yaw, DesiredYaw, LerpAlpha);
    HeadMeshComponent->SetRelativeRotation(FRotator(0.0f, DesiredYaw + RotationOffset - GetActorRotation().Yaw, 0.0f));
    // LerpAlpha = FMath::Min(1.0f, LerpAlpha + CameraRotateToTargetFrequency);
    // UE_LOG(LogTemp, Warning, TEXT("Lerp Alpha: %f"), LerpAlpha);
}

SetSnapped()

void ASecurityCameraPawn::SetSnapped ( const bool bValue )

overrideprotectedvirtual

Implements IPhysicsPickup.

{
    bSnapped = bValue;
    if(BaseMeshComponent == nullptr) {return;}
    BaseMeshComponent->SetSimulatePhysics(!bSnapped);
    SetActive(bValue);
    OnSnappedToObject(bSnapped);
}

TargetSeen()

void ASecurityCameraPawn::TargetSeen ( APawn * Pawn )

overrideprotectedvirtual

Only Fires when Someone is Hostile, Alive, and a Character

Reimplemented from ADefenseSystemPawn.

{
    Super::TargetSeen(Pawn);
    GetWorld()->GetTimerManager().ClearTimer(RotateTimerHandle);
    GetWorld()->GetTimerManager().SetTimer(RotateToTargetTimerHandle, this, &ASecurityCameraPawn::RotateToTarget, CameraRotateFrequency, true);
}

Member Data Documentation

BaseMeshComponent

UStaticMeshComponent* ASecurityCameraPawn::BaseMeshComponent

protected

bChangeDirection

bool ASecurityCameraPawn::bChangeDirection = false

private

bSnapped

bool ASecurityCameraPawn::bSnapped = false

protected

CameraComponent

UCameraComponent* ASecurityCameraPawn::CameraComponent

protected

CameraMaxRotation

float ASecurityCameraPawn::CameraMaxRotation = 90.0f

protected

CameraRotateFrequency

float ASecurityCameraPawn::CameraRotateFrequency = 0.1f

protected

CameraRotateToTargetFrequency

float ASecurityCameraPawn::CameraRotateToTargetFrequency = 0.1f

protected

CameraTargetRotationTolerance

float ASecurityCameraPawn::CameraTargetRotationTolerance = 10.0f

protected

How close to the target rotation before it's counted as a goal

HeadMeshComponent

UStaticMeshComponent* ASecurityCameraPawn::HeadMeshComponent

protected

LerpAlpha

float ASecurityCameraPawn::LerpAlpha = 0.0f

private

PhysicsPickupData

FPhysicsPickupData ASecurityCameraPawn::PhysicsPickupData

protected

RotateBackToStartTimerHandle

FTimerHandle ASecurityCameraPawn::RotateBackToStartTimerHandle

private

RotateTimerHandle

FTimerHandle ASecurityCameraPawn::RotateTimerHandle

private

RotateToTargetTimerHandle

FTimerHandle ASecurityCameraPawn::RotateToTargetTimerHandle

private

RotationOffset

float ASecurityCameraPawn::RotationOffset = -90.0f

protected

SceneCaptureComponent

USceneCaptureComponent2D* ASecurityCameraPawn::SceneCaptureComponent

protected

SnapTargets

USceneComponent* ASecurityCameraPawn::SnapTargets

protected

SpotLightComponent

USpotLightComponent* ASecurityCameraPawn::SpotLightComponent

protected

StartRelativeRotation

FRotator ASecurityCameraPawn::StartRelativeRotation = FRotator::ZeroRotator

private

VisibilityPercentNeeded

float ASecurityCameraPawn::VisibilityPercentNeeded = 60.0f

protected

How Much of the player is needed to be visible to keep tracking

---

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

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