UWaveManagerSubsystem 클래스 참조

#include <WaveManagerSubsystem.h>

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

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

Public 멤버 함수
void	SetLevelRule (ULevelRuleData *InLevelRule)
void	StartWaves ()
void	RegisterSpawnPoints (const TArray< AActor * > &InSpawnPoints)
int32	GetCurrentWaveIndex () const
int32	GetAliveEnemyCount () const
int32	GetTotalWaveCount () const

Public 속성
FOnWaveStarted	OnWaveStarted
FOnWaveCleared	OnWaveCleared
FOnAllWavesCleared	OnAllWavesCleared

Private 멤버 함수
void	BeginWave (int32 WaveIndex)
void	BuildSpawnQueue (const struct FWaveData &Wave)
void	ProcessSpawnQueue ()
void	CheckWaveClearCondition ()
void	AdvanceToNextWave ()
FVector	GetSpawnLocation () const
void	OnEnemyDead ()
void	OnWaveDelayFinished ()

Private 속성
int32	CurrentWaveIndex = -1
int32	AliveEnemyCount = 0
int32	EffectiveMaxAlive = 0
int32	SpawnQueueIndex = 0
bool	bSpawnQueueDone = false
bool	bCurrentWaveWaitsForClear = true
ULevelRuleData *	LevelRule
TArray< FSpawnTask >	SpawnQueue
TArray< TWeakObjectPtr< AActor > >	SpawnPoints
FTimerHandle	WaveDelayTimer
FTimerHandle	SpawnTimer

멤버 함수 문서화

AdvanceToNextWave()

void UWaveManagerSubsystem::AdvanceToNextWave ( )

private

{
    CurrentWaveIndex++;
 
    if (LevelRule == nullptr || CurrentWaveIndex >= LevelRule->Waves.Num())
    {
        OnAllWavesCleared.Broadcast();
        return;
    }
 
    const float Delay = FMath::Max(LevelRule->Waves[CurrentWaveIndex].WaveStartDelay, 0.01f);
    GetWorld()->GetTimerManager().SetTimer(WaveDelayTimer, this, &UWaveManagerSubsystem::OnWaveDelayFinished, Delay, false);
}

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

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

BeginWave()

void UWaveManagerSubsystem::BeginWave ( int32  WaveIndex )

private

{
    if (LevelRule == nullptr)
    {
        return;
    }
 
    const FWaveData& Wave = LevelRule->Waves[WaveIndex];
 
    bCurrentWaveWaitsForClear = Wave.bWaitForClear;
    bSpawnQueueDone = false;
 
    const int32 WaveMax = Wave.MaxAliveMonsters;
 
    if (WaveMax > 0)
    {
        EffectiveMaxAlive = WaveMax;
    }
    else
    {
        EffectiveMaxAlive = LevelRule->GlobalMaxAliveMonsters;
    }
 
    BuildSpawnQueue(Wave);
    OnWaveStarted.Broadcast(WaveIndex);
    ProcessSpawnQueue();
}

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

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

BuildSpawnQueue()

void UWaveManagerSubsystem::BuildSpawnQueue ( const struct FWaveData &  Wave )

private

{
    SpawnQueue.Reset();
    SpawnQueueIndex = 0;
 
    for (const FMonsterSpawnEntry& Entry : Wave.MonsterEntries)
    {
        TSubclassOf<ACK_CharacterEnemy> LoadedClass = Entry.MonsterClass.LoadSynchronous();
 
        if (LoadedClass == nullptr)
        {
            continue;
        }
 
        for (int32 i = 0; i < Entry.SpawnCount; i++)
        {
            FSpawnTask& Task = SpawnQueue.AddDefaulted_GetRef();
            Task.MonsterClass = LoadedClass;
            Task.SpawnInterval = Entry.SpawnInterval;
        }
    }
}

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

CheckWaveClearCondition()

void UWaveManagerSubsystem::CheckWaveClearCondition ( )

private

{
    //bWaitForClear가 false면 스폰 완료 시 이미 처리임. 
    if (!bCurrentWaveWaitsForClear)
    {
        return;
    }
 
    if (bSpawnQueueDone == false || AliveEnemyCount > 0)
    {
        return;
    }
 
    OnWaveCleared.Broadcast(CurrentWaveIndex);
    AdvanceToNextWave();
}

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

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

GetAliveEnemyCount()

int32 UWaveManagerSubsystem::GetAliveEnemyCount ( ) const

inline

{ return AliveEnemyCount; }

GetCurrentWaveIndex()

int32 UWaveManagerSubsystem::GetCurrentWaveIndex ( ) const

inline

{ return CurrentWaveIndex; }

GetSpawnLocation()

FVector UWaveManagerSubsystem::GetSpawnLocation ( ) const

private

{
    if (SpawnPoints.IsEmpty() == false) //등록된 스폰 포인트 중 랜덤 선택.
    {
        const int32 RandIdx = FMath::RandRange(0, SpawnPoints.Num() - 1);
 
        if (SpawnPoints[RandIdx].IsValid())
        {
            return SpawnPoints[RandIdx]->GetActorLocation();
        }
    }
 
    if (const APlayerController* PC = GetWorld()->GetFirstPlayerController()) //없으면 플레이어 기준 랜덤 위치.
    {
        if (PC->GetPawn() == nullptr)
        {
            return FVector::ZeroVector;
        }
 
        const float Angle = FMath::FRandRange(0.f, 360.f);
        const float Radius = FMath::FRandRange(800.f, 1500.f);
 
        float Cos = FMath::Cos(FMath::DegreesToRadians(Angle));
        float Sin = FMath::Sin(FMath::DegreesToRadians(Angle));
 
        const FVector Center = PC->GetPawn()->GetActorLocation();
        return Center + FVector(Cos * Radius, Sin * Radius, 0.f);
    }
 
    return FVector::ZeroVector;
}

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

GetTotalWaveCount()

int32 UWaveManagerSubsystem::GetTotalWaveCount

(

)

const

{
    if (LevelRule)
    {
        return LevelRule->Waves.Num();
    }
    else
    {
        return 0;
    }
}

OnEnemyDead()

void UWaveManagerSubsystem::OnEnemyDead ( )

private

{
    AliveEnemyCount = FMath::Max(0, AliveEnemyCount - 1);
    CheckWaveClearCondition();
 
    //MaxAlive 제한으로 스폰이 멈춰있었으면 재개.
    if (bSpawnQueueDone == false && GetWorld()->GetTimerManager().IsTimerActive(SpawnTimer) == false)
    {
        ProcessSpawnQueue();
    }
}

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

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

OnWaveDelayFinished()

void UWaveManagerSubsystem::OnWaveDelayFinished ( )

private

{
    BeginWave(CurrentWaveIndex);
}

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

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

ProcessSpawnQueue()

void UWaveManagerSubsystem::ProcessSpawnQueue ( )

private

{
    if (SpawnQueueIndex >= SpawnQueue.Num())
    {
        bSpawnQueueDone = true;
 
        // bWaitForClear = false면 스폰 완료 시점에 다음 웨이브 진행
        if (bCurrentWaveWaitsForClear == false)
        {
            OnWaveCleared.Broadcast(CurrentWaveIndex);
            AdvanceToNextWave();
        }
 
        return;
    }
 
    // MaxAlive 초과 시 잠시 후 재시도
    if (AliveEnemyCount >= EffectiveMaxAlive)
    {
        GetWorld()->GetTimerManager().SetTimer(SpawnTimer, this, &UWaveManagerSubsystem::ProcessSpawnQueue, 0.5f, false);
        return;
    }
 
    const FSpawnTask& Task = SpawnQueue[SpawnQueueIndex++];
 
    FActorSpawnParameters Params;
    Params.SpawnCollisionHandlingOverride = ESpawnActorCollisionHandlingMethod::AdjustIfPossibleButAlwaysSpawn;
 
    if (auto Enemy = GetWorld()->SpawnActor<ACK_CharacterEnemy>(Task.MonsterClass, GetSpawnLocation(), FRotator::ZeroRotator, Params))
    {
        AliveEnemyCount++;
 
        if (const UEnemyAttributeSet* AS = Enemy->GetEnemyAttributeSet())
        {
            AS->OnDeathDelegate.AddDynamic(this, &UWaveManagerSubsystem::OnEnemyDead);
        }
    }
 
    const float Interval = FMath::Max(Task.SpawnInterval, 0.01f);
    GetWorld()->GetTimerManager().SetTimer(SpawnTimer, this, &UWaveManagerSubsystem::ProcessSpawnQueue, Interval, false);
}

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

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

RegisterSpawnPoints()

void UWaveManagerSubsystem::RegisterSpawnPoints

(

const TArray< AActor * > &

InSpawnPoints

)

{
    SpawnPoints.Reset();
 
    Algo::CopyIf(InSpawnPoints, SpawnPoints, [](AActor* Point)
    {
        return Point;
    });
}

SetLevelRule()

void UWaveManagerSubsystem::SetLevelRule

(

ULevelRuleData *

InLevelRule

)

{
    LevelRule = InLevelRule;
    LOG_SCREEN("%s의 레벨 데이터를 변경하는데에 성공했습니다. ", NAMEOF(UWaveManagerSubsystem));
}

StartWaves()

void UWaveManagerSubsystem::StartWaves

(

)

{
    if (LevelRule == nullptr || LevelRule->Waves.IsEmpty())
    {
        return;
    }
 
    CurrentWaveIndex = -1;
    AliveEnemyCount = 0;
    AdvanceToNextWave();
}

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

멤버 데이터 문서화

AliveEnemyCount

int32 UWaveManagerSubsystem::AliveEnemyCount = 0

private

bCurrentWaveWaitsForClear

bool UWaveManagerSubsystem::bCurrentWaveWaitsForClear = true

private

bSpawnQueueDone

bool UWaveManagerSubsystem::bSpawnQueueDone = false

private

CurrentWaveIndex

int32 UWaveManagerSubsystem::CurrentWaveIndex = -1

private

EffectiveMaxAlive

int32 UWaveManagerSubsystem::EffectiveMaxAlive = 0

private

LevelRule

ULevelRuleData* UWaveManagerSubsystem::LevelRule

private

OnAllWavesCleared

FOnAllWavesCleared UWaveManagerSubsystem::OnAllWavesCleared

OnWaveCleared

FOnWaveCleared UWaveManagerSubsystem::OnWaveCleared

OnWaveStarted

FOnWaveStarted UWaveManagerSubsystem::OnWaveStarted

SpawnPoints

TArray<TWeakObjectPtr<AActor> > UWaveManagerSubsystem::SpawnPoints

private

SpawnQueue

TArray<FSpawnTask> UWaveManagerSubsystem::SpawnQueue

private

SpawnQueueIndex

int32 UWaveManagerSubsystem::SpawnQueueIndex = 0

private

SpawnTimer

FTimerHandle UWaveManagerSubsystem::SpawnTimer

private

WaveDelayTimer

FTimerHandle UWaveManagerSubsystem::WaveDelayTimer

private

---

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

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