UEnemyCombatSubsystem 클래스 참조

#include <EnemyCombatSubsystem.h>

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

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

Public 멤버 함수
virtual void	Deinitialize () override
bool	RequestAttackToken (AActor *TargetActor, AActor *Requester)
void	ReleaseAttackToken (AActor *Requester)
void	UnregisterAttackTokenActor (AActor *Requester)

Private 멤버 함수
bool	HasAttackToken (const AActor *Requester) const
bool	RemoveAttackTokenHolder (AActor *Requester)
void	CompactTokenData (float CurrentTime)
FEnemyAttackTokenCandidate &	FindOrAddCandidate (AActor *TargetActor, AActor *Requester, float CurrentTime)
FEnemyAttackTokenHistory &	FindOrAddHistory (AActor *Requester)
const FEnemyAttackTokenHistory *	FindHistory (const AActor *Requester) const
void	TryGrantAttackTokens (float CurrentTime)
float	CalculateCandidateScore (const FEnemyAttackTokenCandidate &Candidate, float CurrentTime) const
void	RefreshDebugTimer ()
bool	HasDebugTokenData () const
void	DrawCombatTokenDebug ()
void	DrawTokenDebugString (AActor *TargetActor, const FString &Text, const FColor &Color) const

Private 속성
TArray< TWeakObjectPtr< AActor > >	TokenHolders
TArray< FEnemyAttackTokenCandidate >	TokenCandidates
TArray< FEnemyAttackTokenHistory >	TokenHistories
FTimerHandle	DebugTimerHandle

멤버 함수 문서화

CalculateCandidateScore()

float UEnemyCombatSubsystem::CalculateCandidateScore ( const FEnemyAttackTokenCandidate &  Candidate, float  CurrentTime  ) const

private

{
    const UEnemyCombatSettings* EnemyCombatSettings = GetDefault<UEnemyCombatSettings>();
 
    AActor* Requester = Candidate.Requester.Get();
    AActor* TargetActor = Candidate.TargetActor.Get();
 
    if (IsValid(Requester) == false || IsValid(TargetActor) == false)
    {
        return -FLT_MAX;
    }
 
    float Score = 0.0f;
 
    // 더 오래 기다릴수록 점수가 커짐.
    const float WaitTime = CurrentTime - Candidate.FirstRequestTime;
    Score += WaitTime * EnemyCombatSettings->GetWaitScore();
 
    // 최근에 공격을 해서 패널티를 받은 액터는 기존 점수에서 패널티 점수 차감.
    if (const FEnemyAttackTokenHistory* History = FindHistory(Requester))
    {
        const float TimeAfterRelease = CurrentTime - History->LastReleaseTime;
        if (TimeAfterRelease < EnemyCombatSettings->GetRecentAttackPenaltyTime())
        {
            Score -= EnemyCombatSettings->GetRecentAttackPenaltyScore();
        }
    }
 
    return Score;
}

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

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

CompactTokenData()

void UEnemyCombatSubsystem::CompactTokenData ( float  CurrentTime )

private

{
    const UEnemyCombatSettings* EnemyCombatSettings = GetDefault<UEnemyCombatSettings>();
    const float CandidateExpireTime = EnemyCombatSettings->GetAttackTokenCandidateExpireTime();
    const float RecentAttackPenaltyTime = EnemyCombatSettings->GetRecentAttackPenaltyTime();
 
    // 유효하지 않는 액터 제거
    TokenHolders.RemoveAll([](const TWeakObjectPtr<AActor>& TokenHolder)
    {
        return TokenHolder.IsValid() == false;
    });
 
    // 공격 후보자들이 요청한지 후보자초과 시간이 지났을 경우 제거
    TokenCandidates.RemoveAll([CurrentTime, CandidateExpireTime](const FEnemyAttackTokenCandidate& Candidate)
    {
        return Candidate.Requester.IsValid() == false
            || Candidate.TargetActor.IsValid() == false
            || CurrentTime - Candidate.LastRequestTime > CandidateExpireTime;
    });
 
    // 공격 후 패넡티 시간이 지났을 경우 제거
    TokenHistories.RemoveAll([CurrentTime, RecentAttackPenaltyTime](const FEnemyAttackTokenHistory& History)
    {
        return History.Requester.IsValid() == false
        || CurrentTime - History.LastReleaseTime >= RecentAttackPenaltyTime;
    });
}

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

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

Deinitialize()

void UEnemyCombatSubsystem::Deinitialize ( )

overridevirtual

{
    if (UWorld* World = GetWorld())
    {
        World->GetTimerManager().ClearTimer(DebugTimerHandle);
    }
 
    TokenHolders.Empty();
    TokenCandidates.Empty();
    TokenHistories.Empty();
 
    Super::Deinitialize();
}

DrawCombatTokenDebug()

void UEnemyCombatSubsystem::DrawCombatTokenDebug ( )

private

{
#if ENABLE_DRAW_DEBUG
    const UEnemyCombatSettings* EnemyCombatSettings = GetDefault<UEnemyCombatSettings>();
 
    const float CurrentTime = GetWorld()->GetTimeSeconds();
    CompactTokenData(CurrentTime);
 
    for (const TWeakObjectPtr<AActor>& TokenHolder : TokenHolders)
    {
        if (AActor* Holder = TokenHolder.Get())
        {
            DrawTokenDebugString(Holder, TEXT("Holder"), FColor::Red);
        }
    }
 
    for (const FEnemyAttackTokenCandidate& Candidate : TokenCandidates)
    {
        AActor* Requester = Candidate.Requester.Get();
        if (IsValid(Requester) == false)
        {
            continue;
        }
 
        const float Score = CalculateCandidateScore(Candidate, CurrentTime);
        FString Text = FString::Printf(TEXT("Candidate\nScore: %.2f"), Score);
 
        if (const FEnemyAttackTokenHistory* History = FindHistory(Requester))
        {
            const float PenaltyRemainTime = EnemyCombatSettings->GetRecentAttackPenaltyTime() - (CurrentTime - History->LastReleaseTime);
            if (PenaltyRemainTime > 0.0f)
            {
                Text += FString::Printf(TEXT("\nPenalty: %.2f"), PenaltyRemainTime);
            }
        }
 
        DrawTokenDebugString(Requester, Text, FColor::Yellow);
    }
 
    for (const FEnemyAttackTokenHistory& History : TokenHistories)
    {
        AActor* Requester = History.Requester.Get();
        if (IsValid(Requester) == false || HasAttackToken(Requester))
        {
            continue;
        }
 
        const bool bIsCandidate = TokenCandidates.ContainsByPredicate([Requester](const FEnemyAttackTokenCandidate& Candidate)
        {
            return Candidate.Requester.Get() == Requester;
        });
 
        if (bIsCandidate)
        {
            continue;
        }
 
        const float PenaltyRemainTime = EnemyCombatSettings->GetRecentAttackPenaltyTime() - (CurrentTime - History.LastReleaseTime);
        if (PenaltyRemainTime <= 0.0f)
        {
            continue;
        }
 
        const FString Text = FString::Printf(TEXT("Penalty\n%.2f"), PenaltyRemainTime);
        DrawTokenDebugString(Requester, Text, FColor::Cyan);
    }
 
    RefreshDebugTimer();
#endif
}

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

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

DrawTokenDebugString()

void UEnemyCombatSubsystem::DrawTokenDebugString ( AActor *  TargetActor, const FString &  Text, const FColor &  Color  ) const

private

{
#if ENABLE_DRAW_DEBUG
    if (IsValid(TargetActor) == false)
    {
        return;
    }
 
    const FVector DrawLocation = TargetActor->GetActorLocation() + FVector(0.0f, 0.0f, 200.0f);
    const float DrawDuration = GetDefault<UEnemyCombatSettings>()->GetCombatTokenDebugDrawInterval() * 1.1f; // 디버깅 텍스트 여유 시간
    DrawDebugString(GetWorld(), DrawLocation, Text, nullptr, Color, DrawDuration, true, 1.0f);
#endif
}

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

FindHistory()

const FEnemyAttackTokenHistory * UEnemyCombatSubsystem::FindHistory ( const AActor *  Requester ) const

private

{
    for (const FEnemyAttackTokenHistory& History : TokenHistories)
    {
        if (History.Requester.Get() == Requester)
        {
            return &History;
        }
    }
 
    return nullptr;
}

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

FindOrAddCandidate()

FEnemyAttackTokenCandidate & UEnemyCombatSubsystem::FindOrAddCandidate ( AActor *  TargetActor, AActor *  Requester, float  CurrentTime  )

private

{
    for (FEnemyAttackTokenCandidate& Candidate : TokenCandidates)
    {
        if (Candidate.Requester.Get() == Requester)
        {
            Candidate.TargetActor = TargetActor;
            Candidate.LastRequestTime = CurrentTime;
            return Candidate;
        }
    }
 
    FEnemyAttackTokenCandidate& NewCandidate = TokenCandidates.AddDefaulted_GetRef();
    NewCandidate.Requester = Requester;
    NewCandidate.TargetActor = TargetActor;
    NewCandidate.FirstRequestTime = CurrentTime;
    NewCandidate.LastRequestTime = CurrentTime;
 
    return NewCandidate;
}

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

FindOrAddHistory()

FEnemyAttackTokenHistory & UEnemyCombatSubsystem::FindOrAddHistory ( AActor *  Requester )

private

{
    for (FEnemyAttackTokenHistory& History : TokenHistories)
    {
        if (History.Requester.Get() == Requester)
        {
            return History;
        }
    }
 
    FEnemyAttackTokenHistory& NewHistory = TokenHistories.AddDefaulted_GetRef();
    NewHistory.Requester = Requester;
    return NewHistory;
}

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

HasAttackToken()

bool UEnemyCombatSubsystem::HasAttackToken ( const AActor *  Requester ) const

private

{
    if (IsValid(Requester) == false)
    {
        return false;
    }
 
    for (const TWeakObjectPtr<AActor>& TokenHolder : TokenHolders)
    {
        if (TokenHolder.Get() == Requester)
        {
            return true;
        }
    }
 
    return false;
}

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

HasDebugTokenData()

bool UEnemyCombatSubsystem::HasDebugTokenData ( ) const

private

{
#if ENABLE_DRAW_DEBUG
    return TokenHolders.IsEmpty() == false
        || TokenCandidates.IsEmpty() == false
        || TokenHistories.IsEmpty() == false;
#else
    return false;
#endif
}

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

RefreshDebugTimer()

void UEnemyCombatSubsystem::RefreshDebugTimer ( )

private

{
#if ENABLE_DRAW_DEBUG
    UWorld* World = GetWorld();
    if (IsValid(World) == false)
    {
        return;
    }
 
    const UEnemyCombatSettings* EnemyCombatSettings = GetDefault<UEnemyCombatSettings>();
    if (EnemyCombatSettings->ShouldShowCombatTokenDebug() == false || HasDebugTokenData() == false)
    {
        World->GetTimerManager().ClearTimer(DebugTimerHandle);
        return;
    }
 
    if (World->GetTimerManager().IsTimerActive(DebugTimerHandle))
    {
        return;
    }
 
    World->GetTimerManager().SetTimer(
        DebugTimerHandle,
        this,
        &UEnemyCombatSubsystem::DrawCombatTokenDebug,
        EnemyCombatSettings->GetCombatTokenDebugDrawInterval(),
        true
    );
#endif
}

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

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

ReleaseAttackToken()

void UEnemyCombatSubsystem::ReleaseAttackToken

(

AActor *

Requester

)

{
    if (IsValid(Requester) == false)
    {
        return;
    }
 
    const float CurrentTime = GetWorld()->GetTimeSeconds();
    const bool bHadToken = RemoveAttackTokenHolder(Requester);
 
    TokenCandidates.RemoveAll([Requester](const FEnemyAttackTokenCandidate& Candidate)
    {
        return Candidate.Requester.IsValid() == false || Candidate.Requester.Get() == Requester;
    });
 
    if (bHadToken)
    {
        FEnemyAttackTokenHistory& History = FindOrAddHistory(Requester);
        History.LastReleaseTime = CurrentTime;
    }
 
    CompactTokenData(CurrentTime);
    TryGrantAttackTokens(CurrentTime);
    RefreshDebugTimer();
}

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

RemoveAttackTokenHolder()

bool UEnemyCombatSubsystem::RemoveAttackTokenHolder ( AActor *  Requester )

private

{
    bool bRemoved = false;
 
    TokenHolders.RemoveAll([Requester, &bRemoved](const TWeakObjectPtr<AActor>& TokenHolder)
    {
        if (TokenHolder.IsValid() == false)
        {
            return true;
        }
 
        if (TokenHolder.Get() == Requester)
        {
            bRemoved = true;
            return true;
        }
 
        return false;
    });
 
    return bRemoved;
}

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

RequestAttackToken()

bool UEnemyCombatSubsystem::RequestAttackToken	(	AActor *	TargetActor,
		AActor *	Requester
	)

{
    if (IsValid(TargetActor) == false || IsValid(Requester) == false)
    {
        return false;
    }
 
    const float CurrentTime = GetWorld()->GetTimeSeconds();
 
    CompactTokenData(CurrentTime);
 
    if (HasAttackToken(Requester))
    {
        RefreshDebugTimer();
        return true;
    }
 
    FindOrAddCandidate(TargetActor, Requester, CurrentTime);
    TryGrantAttackTokens(CurrentTime);
    RefreshDebugTimer();
 
    return HasAttackToken(Requester);
}

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

TryGrantAttackTokens()

void UEnemyCombatSubsystem::TryGrantAttackTokens ( float  CurrentTime )

private

{
    const int32 MaxTokenCount = GetDefault<UEnemyCombatSettings>()->GetMaxMeleeAttackTokenCount();
 
    while (TokenHolders.Num() < MaxTokenCount && TokenCandidates.IsEmpty() == false)
    {
        int32 BestIndex = INDEX_NONE;
        float BestScore = -FLT_MAX;
 
        for (int32 Index = 0; Index < TokenCandidates.Num(); ++Index)
        {
            const float Score = CalculateCandidateScore(TokenCandidates[Index], CurrentTime);
            if (Score > BestScore)
            {
                BestScore = Score;
                BestIndex = Index;
            }
        }
 
        if (BestIndex == INDEX_NONE)
        {
            return;
        }
 
        AActor* BestRequester = TokenCandidates[BestIndex].Requester.Get();
        if (IsValid(BestRequester))
        {
            TokenHolders.Add(BestRequester);
        }
 
        TokenCandidates.RemoveAtSwap(BestIndex);
    }
}

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

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

UnregisterAttackTokenActor()

void UEnemyCombatSubsystem::UnregisterAttackTokenActor

(

AActor *

Requester

)

{
    if (IsValid(Requester) == false)
    {
        return;
    }
 
    const float CurrentTime = GetWorld()->GetTimeSeconds();
 
    RemoveAttackTokenHolder(Requester);
 
    TokenCandidates.RemoveAll([Requester](const FEnemyAttackTokenCandidate& Candidate)
    {
        return Candidate.Requester.IsValid() == false || Candidate.Requester.Get() == Requester;
    });
 
    TokenHistories.RemoveAll([Requester](const FEnemyAttackTokenHistory& History)
    {
        return History.Requester.IsValid() == false || History.Requester.Get() == Requester;
    });
 
    CompactTokenData(CurrentTime);
    TryGrantAttackTokens(CurrentTime);
    RefreshDebugTimer();
}

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

멤버 데이터 문서화

DebugTimerHandle

FTimerHandle UEnemyCombatSubsystem::DebugTimerHandle

private

TokenCandidates

TArray<FEnemyAttackTokenCandidate> UEnemyCombatSubsystem::TokenCandidates

private

TokenHistories

TArray<FEnemyAttackTokenHistory> UEnemyCombatSubsystem::TokenHistories

private

TokenHolders

TArray<TWeakObjectPtr<AActor> > UEnemyCombatSubsystem::TokenHolders

private

---

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

• Source/CK_UE/Subsystem/World/EnemyCombatSubsystem.h
• Source/CK_UE/Subsystem/World/EnemyCombatSubsystem.cpp