UTargetSelector 클래스 참조

#include <TargetSelector.h>

UTargetSelector에 대한 상속 다이어그램 :

UTargetSelector에 대한 협력 다이어그램:

Public 멤버 함수
bool	ResolveTarget (const AMainPlayerCharacter *Player, FTargetSelectionResult &OutResult) const

Protected 속성
ETargetSelectionMode	SelectionMode = ETargetSelectionMode::CurrentTargetOrDensity
float	TargetSearchRange = 2000.0f
float	FallbackSearchRange = 2000.0f
float	DensityRadius = 350.0f
bool	bUseLineOfSight = true

Private 멤버 함수
ITargetableInterface *	GetCurrentTarget (const AMainPlayerCharacter *Player) const
TArray< ITargetableInterface * >	GatherTargets (const AMainPlayerCharacter *Player) const
TArray< ITargetableInterface * >	FilterVisibleTargets (const APlayerController *PC, const TArray< ITargetableInterface * > &Candidates) const
ITargetableInterface *	PickDensityCenterTarget (const AMainPlayerCharacter *Player, const TArray< ITargetableInterface * > &Candidates) const
TArray< ITargetableInterface * >	FilterTargetsInPlayerRange (const AMainPlayerCharacter *Player, const TArray< ITargetableInterface * > &Candidates) const
bool	HasLineOfSight (const APlayerController *PC, ITargetableInterface *Targetable) const
bool	IsTargetInCameraView (const APlayerController *PC, ITargetableInterface *Targetable) const

멤버 함수 문서화

FilterTargetsInPlayerRange()

TArray< ITargetableInterface * > UTargetSelector::FilterTargetsInPlayerRange ( const AMainPlayerCharacter *  Player, const TArray< ITargetableInterface * > &  Candidates  ) const

private

{
    TArray<ITargetableInterface*> Result;
 
    if (Player == nullptr)
    {
        return Result;
    }
 
    const FVector PlayerLocation = Player->GetActorLocation();
    const float RangeSq = FMath::Square(FallbackSearchRange);
 
    for (ITargetableInterface* Targetable : Candidates)
    {
        if (Targetable == nullptr)
        {
            continue;
        }
 
        const float DistSq = FVector::DistSquared2D(PlayerLocation, Targetable->GetTargetedActorLocation());
 
        if (DistSq <= RangeSq)
        {
            Result.Add(Targetable);
        }
    }
 
    return Result;
}

이 함수를 호출하는 함수들에 대한 그래프입니다.:

FilterVisibleTargets()

TArray< ITargetableInterface * > UTargetSelector::FilterVisibleTargets ( const APlayerController *  PC, const TArray< ITargetableInterface * > &  Candidates  ) const

private

{
    TArray<ITargetableInterface*> Result;
 
    for (ITargetableInterface* Targetable : Candidates)
    {
        if (IsTargetInCameraView(PC, Targetable))
        {
            Result.Add(Targetable);
        }
    }
 
    return Result;
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

GatherTargets()

TArray< ITargetableInterface * > UTargetSelector::GatherTargets ( const AMainPlayerCharacter *  Player ) const

private

{
    TArray<ITargetableInterface*> Targets;
 
    if (Player == nullptr || Player->GetWorld() == nullptr)
    {
        return Targets;
    }
 
    UStageManagementSubsystem* StageSubsystem = Player->GetWorld()->GetSubsystem<UStageManagementSubsystem>();
 
    if (StageSubsystem == nullptr)
    {
        return Targets;
    }
 
    TargetableQuery Query = StageSubsystem->GetStageTargetableQueryHandle();
    TArray<ITargetableInterface*> RawTargets = Query.GetTargets();
    APlayerController* PC = Cast<APlayerController>(Player->GetController());
 
    for (ITargetableInterface* Targetable : RawTargets)
    {
        if (Targetable == nullptr || Targetable->IsTargetValid() == false || Targetable->IsTargetable() == false)
        {
            continue;
        }
 
        if (bUseLineOfSight && HasLineOfSight(PC, Targetable) == false)
        {
            continue;
        }
 
        const float DistSq = FVector::DistSquared2D(Player->GetActorLocation(), Targetable->GetTargetedActorLocation());
 
        if (DistSq > FMath::Square(TargetSearchRange))
        {
            continue;
        }
 
        Targets.Add(Targetable);
    }
 
    return Targets;
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

GetCurrentTarget()

ITargetableInterface * UTargetSelector::GetCurrentTarget ( const AMainPlayerCharacter *  Player ) const

private

{
    if (Player == nullptr)
    {
        return nullptr;
    }
 
    const UCameraTargetingComponent* TargetingComponent = Player->GetPlayerTargetingComponent();
 
    if (TargetingComponent == nullptr || TargetingComponent->IsTargeting() == false)
    {
        return nullptr;
    }
 
    TScriptInterface<ITargetableInterface> CurrentTarget = TargetingComponent->GetCurrentTarget();
    return CurrentTarget.GetInterface();
}

이 함수를 호출하는 함수들에 대한 그래프입니다.:

HasLineOfSight()

bool UTargetSelector::HasLineOfSight ( const APlayerController *  PC, ITargetableInterface *  Targetable  ) const

private

{
    if (PC == nullptr || PC->GetWorld() == nullptr || PC->PlayerCameraManager == nullptr || Targetable == nullptr)
    {
        return false;
    }
 
    FCollisionQueryParams Params(SCENE_QUERY_STAT(TargetSelector), false);
 
    if (PC->GetPawn())
    {
        Params.AddIgnoredActor(PC->GetPawn());
    }
 
    TArray<FHitResult> HitResults;
    const FVector TraceStart = PC->PlayerCameraManager->GetCameraLocation();
    const FVector TraceEnd = Targetable->GetTargetedActorLocation();
    PC->GetWorld()->LineTraceMultiByChannel(HitResults, TraceStart, TraceEnd, ECC_Visibility, Params);
 
    for (const FHitResult& Hit : HitResults)
    {
        if (Hit.Component.IsValid() && Hit.Component->GetCollisionProfileName() == CPROFILE_CKPLAYERCAPSULE)
        {
            continue;
        }
 
        if (Hit.GetActor() == ITargetableInterface::AsActor(Targetable))
        {
            return true;
        }
 
        return false;
    }
 
    return true;
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

IsTargetInCameraView()

bool UTargetSelector::IsTargetInCameraView ( const APlayerController *  PC, ITargetableInterface *  Targetable  ) const

private

{
    if (PC == nullptr || PC->PlayerCameraManager == nullptr || Targetable == nullptr)
    {
        return false;
    }
 
    const FVector TargetLocation = Targetable->GetTargetedActorLocation();
    const FVector ToTarget = TargetLocation - PC->PlayerCameraManager->GetCameraLocation();
    const float ForwardDot = FVector::DotProduct(PC->PlayerCameraManager->GetCameraRotation().Vector(), ToTarget);
 
    if (ForwardDot <= 0.0f)
    {
        return false;
    }
 
    FVector2D ScreenPosition;
 
    if (PC->ProjectWorldLocationToScreen(TargetLocation, ScreenPosition) == false)
    {
        return false;
    }
 
    int32 ViewportSizeX = 0;
    int32 ViewportSizeY = 0;
    PC->GetViewportSize(ViewportSizeX, ViewportSizeY);
 
    if (ViewportSizeX <= 0 || ViewportSizeY <= 0)
    {
        return false;
    }
 
    return ScreenPosition.X >= 0.0f && ScreenPosition.X <= ViewportSizeX && ScreenPosition.Y >= 0.0f && ScreenPosition.Y <= ViewportSizeY;
}

이 함수를 호출하는 함수들에 대한 그래프입니다.:

PickDensityCenterTarget()

ITargetableInterface * UTargetSelector::PickDensityCenterTarget ( const AMainPlayerCharacter *  Player, const TArray< ITargetableInterface * > &  Candidates  ) const

private

{
    if (Player == nullptr || Candidates.IsEmpty())
    {
        return nullptr;
    }
 
    ITargetableInterface* BestTarget = nullptr;
    int32 BestNeighborCount = INDEX_NONE;
    float BestDistanceToClusterCenterSq = TNumericLimits<float>::Max();
    float BestDistanceToPlayerSq = TNumericLimits<float>::Max();
    const float DensityRadiusSq = FMath::Square(DensityRadius);
    const FVector PlayerLocation = Player->GetActorLocation();
 
    for (ITargetableInterface* Candidate : Candidates)
    {
        if (Candidate == nullptr)
        {
            continue;
        }
 
        const FVector CandidateLocation = Candidate->GetTargetedActorLocation();
        FVector ClusterCenter = FVector::ZeroVector;
        int32 NeighborCount = 0;
 
        for (ITargetableInterface* Other : Candidates)
        {
            if (Other == nullptr)
            {
                continue;
            }
 
            const FVector OtherLocation = Other->GetTargetedActorLocation();
 
            if (FVector::DistSquared2D(CandidateLocation, OtherLocation) > DensityRadiusSq)
            {
                continue;
            }
 
            ClusterCenter += OtherLocation;
            NeighborCount++;
        }
 
        if (NeighborCount <= 0)
        {
            continue;
        }
 
        ClusterCenter /= static_cast<float>(NeighborCount);
 
        const float DistanceToClusterCenterSq = FVector::DistSquared2D(CandidateLocation, ClusterCenter);
        const float DistanceToPlayerSq = FVector::DistSquared2D(CandidateLocation, PlayerLocation);
        const bool bHasMoreNeighbors = NeighborCount > BestNeighborCount;
        const bool bCloserToClusterCenter = NeighborCount == BestNeighborCount && DistanceToClusterCenterSq < BestDistanceToClusterCenterSq;
        const bool bCloserToPlayer = NeighborCount == BestNeighborCount && FMath::IsNearlyEqual(DistanceToClusterCenterSq, BestDistanceToClusterCenterSq) && DistanceToPlayerSq < BestDistanceToPlayerSq;
 
        if (bHasMoreNeighbors || bCloserToClusterCenter || bCloserToPlayer)
        {
            BestTarget = Candidate;
            BestNeighborCount = NeighborCount;
            BestDistanceToClusterCenterSq = DistanceToClusterCenterSq;
            BestDistanceToPlayerSq = DistanceToPlayerSq;
        }
    }
 
    return BestTarget;
}

이 함수를 호출하는 함수들에 대한 그래프입니다.:

ResolveTarget()

bool UTargetSelector::ResolveTarget	(	const AMainPlayerCharacter *	Player,
		FTargetSelectionResult &	OutResult
	)		const

{
    OutResult = FTargetSelectionResult();
 
    if (Player == nullptr)
    {
        return false;
    }
 
    ITargetableInterface* Targetable = nullptr;
 
    if (SelectionMode == ETargetSelectionMode::CurrentTargetOrDensity || SelectionMode == ETargetSelectionMode::CurrentTargetOnly)
    {
        Targetable = GetCurrentTarget(Player);
    }
 
    if (Targetable == nullptr && SelectionMode != ETargetSelectionMode::CurrentTargetOnly)
    {
        APlayerController* PC = Cast<APlayerController>(Player->GetController());
        TArray<ITargetableInterface*> Candidates = GatherTargets(Player);
        TArray<ITargetableInterface*> SelectedCandidates = FilterVisibleTargets(PC, Candidates);
 
        if (SelectedCandidates.IsEmpty())
        {
            SelectedCandidates = FilterTargetsInPlayerRange(Player, Candidates);
        }
 
        Targetable = PickDensityCenterTarget(Player, SelectedCandidates);
    }
 
    if (Targetable == nullptr)
    {
        return true;
    }
 
    OutResult.bHasTarget = true;
    OutResult.TargetActor = ITargetableInterface::AsActor(Targetable);
    OutResult.TargetLocation = Targetable->GetTargetedActorLocation();
    OutResult.TargetDistance = FVector::Dist2D(Player->GetActorLocation(), OutResult.TargetLocation);
    return true;
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

멤버 데이터 문서화

bUseLineOfSight

bool UTargetSelector::bUseLineOfSight = true

protected

DensityRadius

float UTargetSelector::DensityRadius = 350.0f

protected

FallbackSearchRange

float UTargetSelector::FallbackSearchRange = 2000.0f

protected

SelectionMode

ETargetSelectionMode UTargetSelector::SelectionMode = ETargetSelectionMode::CurrentTargetOrDensity

protected

TargetSearchRange

float UTargetSelector::TargetSearchRange = 2000.0f

protected

---

이 클래스에 대한 문서화 페이지는 다음의 파일들로부터 생성되었습니다.:

• Source/CK_UE/Level/Selector/TargetSelector.h
• Source/CK_UE/Level/Selector/TargetSelector.cpp