UEnemySpawnDirectorSystemComponent 클래스 참조

#include <EnemySpawnDirectorSystemComponent.h>

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

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

Public 멤버 함수
	UEnemySpawnDirectorSystemComponent ()
virtual void	Initialize (UStageManagementSubsystem *StageManagementSubsystem) override
virtual void	ClearAll (const bool bClearSpawnedActors=true) override
virtual void	CollectSpawnedTargetables (TArray< ITargetableInterface * > &OutTargetables) const override
virtual void	TickComponent (float DeltaTime, ELevelTick TickType, FActorComponentTickFunction *ThisTickFunction) override
void	InitializeStandalone ()
void	DeactivateAllSpawners ()
void	ClearRegisteredSpawners ()
TArray< UEnemySpawnerComponent * >	GetSpawners (ESpawnAreaID SpawnerID)
TArray< UEnemySpawnerComponent * >	GetAllSpawners ()
void	ActivateSpawners (const FWaveSpawnData &SpawnTables)
void	RegisterSpawner (ESpawnAreaID AreaID, UEnemySpawnerComponent *Spawner)
void	UnregisterSpawner (ESpawnAreaID AreaID, UEnemySpawnerComponent *Spawner)
void	OnReadyToSpawn (const FWaveDataCollection &WaveData)
void	SpawnEnemy (TSubclassOf< AEnemyCharacterBase > EnemyClass, const int32 EnemyCount=1, const FVector SpawnPosition=FVector::ZeroVector)
FORCEINLINE TArray< AEnemyCharacterBase * >	GetAllSpawnedEnemies () const
FORCEINLINE int32	GetSpawnRemainingCount () const
FORCEINLINE bool	IsActivated () const

Public 속성
FOnEnemySpawnedStandalone	OnEnemySpawned
FOnEnemyKilledStandalone	OnEnemyKilled

Private 멤버 함수
void	OnSpawnedEnemyKilled (AEnemyCharacterBase *DiedEnemy)
void	AdvanceSpawnJob (FActiveEnemySpawnJob &SpawnJob, const float DeltaTime)
AEnemyCharacterBase *	SpawnEnemyAt (const TSubclassOf< AEnemyCharacterBase > EnemyClass, const FVector &Location)
TSubclassOf< AEnemyCharacterBase >	ResolveEnemyClass (const FName EnemyID) const
TSubclassOf< USpawnPattern >	ResolveSpawnPatternClass (const FName SpawnPatternID) const

Private 속성
int32	SpawnRemainingCount = 0
bool	bIsActivated = false
FWaveDataCollection	CurrentWaveData
TObjectPtr< UMonsterDictionary >	MonsterDictionary
TObjectPtr< USpawnPatternDictionary >	SpawnPatternDictionary
TArray< FActiveEnemySpawnJob >	ActiveSpawnJobs
TMap< ESpawnAreaID, FSpawnerContainer >	SpawnerMap
TArray< TObjectPtr< AEnemyCharacterBase > >	SpawnedEnemies
TSet< TObjectPtr< AEnemyCharacterBase > >	ExternalSpawnedEnemies

생성자 & 소멸자 문서화

UEnemySpawnDirectorSystemComponent()

UEnemySpawnDirectorSystemComponent::UEnemySpawnDirectorSystemComponent

(

)

{
    PrimaryComponentTick.bCanEverTick = true;
    PrimaryComponentTick.bStartWithTickEnabled = false;
}

멤버 함수 문서화

ActivateSpawners()

void UEnemySpawnDirectorSystemComponent::ActivateSpawners

(

const FWaveSpawnData &

SpawnTables

)

{
    LOG_INFO(LogCK, "Wave ID : %s", *SpawnTables.Wave_ID.ToString());
 
    for (const FWaveSpawnEntry& SpawnTable : SpawnTables.SpawnList)
    {
        if (SpawnTable.SpawnArea_ID == ESpawnAreaID::None)
        {
            LOG_ERROR(LogCK, "SpawnArea_ID가 설정되어있지 않아 건너뜁니다. ");
            continue;
        }
 
        const FMonsterDataCollection* MonsterData = SpawnTables.GetMonsterData(SpawnTable.Enemy_ID);
 
        if (MonsterData == nullptr)
        {
            LOG_ERROR(LogCK, "Monster_ID '%s'에 대한 MonsterData를 찾을 수 없습니다.", *SpawnTable.Enemy_ID.ToString());
            continue;
        }
 
        const TSubclassOf<AEnemyCharacterBase> EnemyClass = ResolveEnemyClass(SpawnTable.Enemy_ID);
 
        if (EnemyClass == nullptr)
        {
            continue;
        }
 
        const TSubclassOf<USpawnPattern> PatternClass = ResolveSpawnPatternClass(SpawnTable.Spawn_Pattern_ID);
 
        if (PatternClass == nullptr)
        {
            continue;
        }
 
        for (UEnemySpawnerComponent* Spawner : GetSpawners(SpawnTable.SpawnArea_ID))
        {
            if (IsValid(Spawner) == false)
            {
                continue;
            }
 
            FActiveEnemySpawnJob SpawnJob;
            SpawnJob.SpawnEntry = SpawnTable;
            SpawnJob.MonsterDataCollection = *MonsterData;
            SpawnJob.Spawner = Spawner;
            SpawnJob.EnemyClass = EnemyClass;
            SpawnJob.SpawnPattern = NewObject<USpawnPattern>(this, PatternClass);
 
            ActiveSpawnJobs.Add(SpawnJob);
 
            LOG_SCREEN("%s %d 스포너가 활성화됨", NAMEOF(UEnemySpawnerComponent), Spawner->GetSpawnerAreaMask());
            LOG_INFO(LogCK, "%s %d 스포너가 활성화됨. Spawn_ID: %s", NAMEOF(UEnemySpawnerComponent), Spawner->GetSpawnerAreaMask(), *SpawnTable.Spawn_ID.ToString());
        }
    }
 
    bIsActivated = true;
}

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

AdvanceSpawnJob()

void UEnemySpawnDirectorSystemComponent::AdvanceSpawnJob ( FActiveEnemySpawnJob &  SpawnJob, const float  DeltaTime  )

private

{
    if (SpawnJob.SpawnedCount >= SpawnJob.SpawnEntry.Spawn_Count)
    {
        return;
    }
 
    if (IsValid(SpawnJob.Spawner) == false)
    {
        LOG_ERROR(LogCK, "잘못된 %s를 참조하는 스폰 잡입니다. Spawn_ID: %s", NAMEOF(UEnemySpawnerComponent), *SpawnJob.SpawnEntry.Spawn_ID.ToString());
        SpawnJob.SpawnedCount = SpawnJob.SpawnEntry.Spawn_Count;
        return;
    }
 
    SpawnJob.ElapsedTime += DeltaTime;
    const float RequiredDelay = (SpawnJob.SpawnedCount == 0) ? SpawnJob.SpawnEntry.Start_Delay : SpawnJob.SpawnEntry.Spawn_Interval;
 
    if (SpawnJob.ElapsedTime < RequiredDelay)
    {
        return;
    }
 
    SpawnJob.ElapsedTime = 0.0f;
 
    const FVector SpawnLocation = SpawnJob.Spawner->GetSpawnLocation(SpawnJob.SpawnPattern);
    AEnemyCharacterBase* SpawnedEnemy = SpawnEnemyAt(SpawnJob.EnemyClass, SpawnLocation);
 
    if (SpawnedEnemy == nullptr)
    {
        LOG_ERROR(LogCK, "캐릭터 스폰 실패. Spawner: %s, Enemy_ID: %s", *SpawnJob.Spawner->GetName(), *SpawnJob.SpawnEntry.Enemy_ID.ToString());
        return;
    }
 
    SpawnJob.SpawnedCount++;
    SpawnRemainingCount++;
    OnEnemySpawned.Broadcast(SpawnedEnemy);
}

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

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

ClearAll()

void UEnemySpawnDirectorSystemComponent::ClearAll ( const bool  bClearSpawnedActors = true )

overridevirtual

ISpawnSystemInterface를 구현.

{
    if (SpawnedEnemies.IsEmpty())
    {
        SpawnRemainingCount = 0;
        return;
    }
 
    if (bClearSpawnedActors == false)
    {
        SpawnedEnemies.Empty();
        ExternalSpawnedEnemies.Empty();
        SpawnRemainingCount = 0;
        return;
    }
 
    for (AEnemyCharacterBase* Enemy : SpawnedEnemies)
    {
        if (Enemy == nullptr || IsValid(Enemy) == false)
        {
            continue;
        }
 
        if (Enemy->OnSpawnEnemyDead.IsBound())
        {
            Enemy->OnSpawnEnemyDead.RemoveDynamic(this, &UEnemySpawnDirectorSystemComponent::OnSpawnedEnemyKilled);
        }
 
        Enemy->ForceReturnToPool(false);
    }
 
    SpawnedEnemies.Empty();
    ExternalSpawnedEnemies.Empty();
    SpawnRemainingCount = 0;
}

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

ClearRegisteredSpawners()

void UEnemySpawnDirectorSystemComponent::ClearRegisteredSpawners

(

)

{
    DeactivateAllSpawners();
    SpawnerMap.Empty();
    CurrentWaveData = FWaveDataCollection();
}

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

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

CollectSpawnedTargetables()

void UEnemySpawnDirectorSystemComponent::CollectSpawnedTargetables ( TArray< ITargetableInterface * > &  OutTargetables ) const

overridevirtual

ISpawnSystemInterface(으)로부터 재구현되었습니다.

{
    OutTargetables.Reserve(SpawnedEnemies.Num());
    OutTargetables.Append(SpawnedEnemies);
}

DeactivateAllSpawners()

void UEnemySpawnDirectorSystemComponent::DeactivateAllSpawners

(

)

{
    if (ActiveSpawnJobs.IsEmpty() == false)
    {
        LOG_INFO(LogCK, "활성화된 스폰 잡 %d개를 중단합니다.", ActiveSpawnJobs.Num());
    }
 
    ActiveSpawnJobs.Empty();
    SetComponentTickEnabled(false);
    bIsActivated = false;
}

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

GetAllSpawnedEnemies()

FORCEINLINE TArray< AEnemyCharacterBase * > UEnemySpawnDirectorSystemComponent::GetAllSpawnedEnemies ( ) const

inline

    {
        return SpawnedEnemies;
    }

GetAllSpawners()

TArray< UEnemySpawnerComponent * > UEnemySpawnDirectorSystemComponent::GetAllSpawners

(

)

{
    if (SpawnerMap.IsEmpty())
    {
        return TArray<UEnemySpawnerComponent*>();
    }
 
    TArray<UEnemySpawnerComponent*> Result;
 
    for (auto& [SpawnerID, Spawner] : SpawnerMap)
    {
        Result.Append(Spawner.Spawners);
    }
 
    return Result;
}

GetSpawners()

TArray< UEnemySpawnerComponent * > UEnemySpawnDirectorSystemComponent::GetSpawners

(

ESpawnAreaID

SpawnerID

)

{
    if (SpawnerMap.IsEmpty())
    {
        return TArray<UEnemySpawnerComponent*>();
    }
 
    TArray<UEnemySpawnerComponent*> Result;
 
    if (const FSpawnerContainer* Container = SpawnerMap.Find(SpawnerID))
    {
        Result.Append(Container->Spawners);
    }
 
    return Result;
}

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

GetSpawnRemainingCount()

FORCEINLINE int32 UEnemySpawnDirectorSystemComponent::GetSpawnRemainingCount ( ) const

inline

    {
        return SpawnRemainingCount;
    }

Initialize()

void UEnemySpawnDirectorSystemComponent::Initialize ( UStageManagementSubsystem *  StageManagementSubsystem )

overridevirtual

ISpawnSystemInterface를 구현.

{
    InitializeStandalone();
}

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

InitializeStandalone()

void UEnemySpawnDirectorSystemComponent::InitializeStandalone

(

)

{
    MonsterDictionary = GetEnvironmentAssetByKey<UMonsterDictionary>("MonsterDictionary");
    ensureAlwaysMsgf(MonsterDictionary, TEXT("%s 로드 실패."), NAMEOF(UMonsterDictionary));
 
    SpawnPatternDictionary = GetEnvironmentAssetByKey<USpawnPatternDictionary>("SpawnPatternDictionary");
    ensureAlwaysMsgf(SpawnPatternDictionary, TEXT("%s 로드 실패."), NAMEOF(USpawnPatternDictionary));
 
    SpawnRemainingCount = 0;
}

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

IsActivated()

FORCEINLINE bool UEnemySpawnDirectorSystemComponent::IsActivated ( ) const

inline

    {
        return bIsActivated;
    }

OnReadyToSpawn()

void UEnemySpawnDirectorSystemComponent::OnReadyToSpawn

(

const FWaveDataCollection &

WaveData

)

{
    CurrentWaveData = WaveData;
    LOG_INFO(LogCK, "웨이브:%s 스폰 준비 완료.", *WaveData.Wave_ID.ToString());
}

OnSpawnedEnemyKilled()

void UEnemySpawnDirectorSystemComponent::OnSpawnedEnemyKilled ( AEnemyCharacterBase *  DiedEnemy )

private

{
    checkf(DiedEnemy, TEXT("죽은 %s에 접근할 수 없습니다. NullPtr입니다. "), NAMEOF(AEnemyCharacterBase));
    checkf(SpawnRemainingCount >= 0, TEXT("스폰된 몬스터보다 죽은 몬스터가 많을 수 없습니다. "));
 
    if (DiedEnemy->OnSpawnEnemyDead.IsBound())
    {
        DiedEnemy->OnSpawnEnemyDead.RemoveDynamic(this, &UEnemySpawnDirectorSystemComponent::OnSpawnedEnemyKilled);
    }
 
    SpawnedEnemies.Remove(DiedEnemy);
    LOG_INFO(LogCK, "Enemy '%s'가 죽었습니다. (남은 몬스터 수: %d)", *DiedEnemy->GetName(), SpawnedEnemies.Num());
 
    // 외부 요청으로 스폰된 적은 웨이브 클리어 판정에 영향을 주지 않는다.
    if (ExternalSpawnedEnemies.Remove(DiedEnemy) > 0)
    {
        return;
    }
 
    SpawnRemainingCount = FMath::Max(SpawnRemainingCount - 1, 0);
 
    // EncounterField가 OnEnemyKilled를 구독하여 섹션 클리어 조건을 판단한다.
    OnEnemyKilled.Broadcast(DiedEnemy);
}

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

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

RegisterSpawner()

void UEnemySpawnDirectorSystemComponent::RegisterSpawner	(	ESpawnAreaID	AreaID,
		UEnemySpawnerComponent *	Spawner
	)

{
    if (Spawner == nullptr)
    {
        LOG_ERROR(LogCK, "인자로 넘어온, %s가 nullptr입니다. ", NAMEOF(UEnemySpawnerComponent));
        return;
    }
 
    if (SpawnerMap.Contains(AreaID) == false)
    {
        SpawnerMap.Add(AreaID, FSpawnerContainer());
    }
 
    if (SpawnerMap[AreaID].Spawners.Contains(Spawner))
    {
        return;
    }
 
    SpawnerMap[AreaID].Spawners.Add(Spawner);
}

ResolveEnemyClass()

TSubclassOf< AEnemyCharacterBase > UEnemySpawnDirectorSystemComponent::ResolveEnemyClass ( const FName  EnemyID ) const

private

{
    if (MonsterDictionary == nullptr)
    {
        LOG_ERROR(LogCK, "'%s'가 로드되어 있지 않습니다.", NAMEOF(UMonsterDictionary));
        return nullptr;
    }
 
    const TSubclassOf<AEnemyCharacterBase>* EnemyClass = MonsterDictionary->MonsterClassMap.Find(EnemyID);
 
    if (EnemyClass == nullptr)
    {
        LOG_ERROR(LogCK, "Enemy_ID '%s'에 대한 클래스를 찾을 수 없습니다.", *EnemyID.ToString());
        return nullptr;
    }
 
    return *EnemyClass;
}

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

ResolveSpawnPatternClass()

TSubclassOf< USpawnPattern > UEnemySpawnDirectorSystemComponent::ResolveSpawnPatternClass ( const FName  SpawnPatternID ) const

private

{
    if (SpawnPatternDictionary == nullptr)
    {
        LOG_ERROR(LogCK, "'%s'가 로드되어 있지 않습니다.", NAMEOF(USpawnPatternDictionary));
        return nullptr;
    }
 
    TSoftClassPtr<USpawnPattern>* PatternPtr = SpawnPatternDictionary->SpawnPatternMap.Find(SpawnPatternID);
 
    if (PatternPtr == nullptr)
    {
        LOG_ERROR(LogCK, "SpawnPattern_ID '%s'에 대한 SpawnPattern을 찾을 수 없습니다.", *SpawnPatternID.ToString());
        return nullptr;
    }
 
    const TSubclassOf<USpawnPattern> PatternClass = PatternPtr->LoadSynchronous();
 
    if (PatternClass == nullptr)
    {
        LOG_ERROR(LogCK, "SpawnPattern 클래스 로드 실패. SpawnPattern_ID: %s", *SpawnPatternID.ToString());
        return nullptr;
    }
 
    return PatternClass;
}

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

SpawnEnemy()

void UEnemySpawnDirectorSystemComponent::SpawnEnemy	(	TSubclassOf< AEnemyCharacterBase >	EnemyClass,
		const int32	EnemyCount = 1,
		const FVector	SpawnPosition = FVector::ZeroVector
	)

{
    // 2기 이상이면 같은 좌표에 겹쳐 스폰되지 않도록 원형으로 분산시킨다.
    const float ScatterRadius = (EnemyCount > 1) ? 150.0f : 0.0f;
 
    for (int32 Index = 0; Index < EnemyCount; ++Index)
    {
        const float Angle = 2.0f * PI * Index / EnemyCount;
        const FVector SpawnLocation = SpawnPosition + FVector(FMath::Cos(Angle), FMath::Sin(Angle), 0.0f) * ScatterRadius;
 
        AEnemyCharacterBase* SpawnedEnemy = SpawnEnemyAt(EnemyClass, SpawnLocation);
 
        if (SpawnedEnemy == nullptr)
        {
            continue;
        }
 
        // SpawnArea를 거치지 않았으므로 웨이브 카운트에는 넣지 않고, 조회/정리 대상으로만 등록한다.
        ExternalSpawnedEnemies.Add(SpawnedEnemy);
    }
}

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

SpawnEnemyAt()

AEnemyCharacterBase * UEnemySpawnDirectorSystemComponent::SpawnEnemyAt ( const TSubclassOf< AEnemyCharacterBase >  EnemyClass, const FVector &  Location  )

private

{
    if (EnemyClass == nullptr)
    {
        LOG_ERROR(LogCK, "스폰할 %s 클래스가 nullptr입니다. ", NAMEOF(AEnemyCharacterBase));
        return nullptr;
    }
 
    const UWorld* World = GetWorld();
 
    if (World == nullptr)
    {
        LOG_ERROR(LogCK, "World가 nullptr이라 스폰할 수 없습니다. ");
        return nullptr;
    }
 
    UPoolWorldSubsystem* Pool = World->GetSubsystem<UPoolWorldSubsystem>();
 
    if (Pool == nullptr)
    {
        LOG_ERROR(LogCK, "%s이 존재하지 않습니다. ", NAMEOF(UPoolWorldSubsystem));
        return nullptr;
    }
 
    AEnemyCharacterBase* SpawnedEnemy = Cast<AEnemyCharacterBase>(Pool->GetActorFromPool(EnemyClass, Location, FRotator::ZeroRotator));
 
    if (SpawnedEnemy == nullptr)
    {
        LOG_ERROR(LogCK, "풀에서 %s를 가져오지 못했습니다. (Class: %s)", NAMEOF(AEnemyCharacterBase), *EnemyClass->GetName());
        return nullptr;
    }
 
    SpawnedEnemies.Add(SpawnedEnemy);
    SpawnedEnemy->OnSpawnEnemyDead.AddUniqueDynamic(this, &UEnemySpawnDirectorSystemComponent::OnSpawnedEnemyKilled);
 
    LOG_INFO(LogCK, "Enemy 생성 성공. (Class: %s, Position: %s)", *EnemyClass->GetName(), *Location.ToString());
    return SpawnedEnemy;
}

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

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

TickComponent()

void UEnemySpawnDirectorSystemComponent::TickComponent ( float  DeltaTime, ELevelTick  TickType, FActorComponentTickFunction *  ThisTickFunction  )

overridevirtual

{
    Super::TickComponent(DeltaTime, TickType, ThisTickFunction);
 
    if (ActiveSpawnJobs.IsEmpty())
    {
        return;
    }
 
    for (FActiveEnemySpawnJob& SpawnJob : ActiveSpawnJobs)
    {
        AdvanceSpawnJob(SpawnJob, DeltaTime);
    }
}

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

UnregisterSpawner()

void UEnemySpawnDirectorSystemComponent::UnregisterSpawner	(	ESpawnAreaID	AreaID,
		UEnemySpawnerComponent *	Spawner
	)

{
    if (Spawner == nullptr)
    {
        LOG_ERROR(LogCK, "인자로 넘어온, %s가 nullptr입니다. ", NAMEOF(UEnemySpawnerComponent));
        return;
    }
 
    FSpawnerContainer* Container = SpawnerMap.Find(AreaID);
 
    if (Container == nullptr)
    {
        LOG_ERROR(LogCK, "%s를 찾을 수 없습니다. ", *Utils::EnumToString(AreaID));
        return;
    }
 
    Container->Spawners.Remove(Spawner);
 
    // 해제된 스포너를 참조하는 잡은 더 이상 진행할 수 없다.
    auto IsOrphanedJob = [Spawner](const FActiveEnemySpawnJob& SpawnJob)
    {
        return SpawnJob.Spawner == Spawner;
    };
 
    ActiveSpawnJobs.RemoveAll(IsOrphanedJob);
}

멤버 데이터 문서화

ActiveSpawnJobs

TArray<FActiveEnemySpawnJob> UEnemySpawnDirectorSystemComponent::ActiveSpawnJobs

private

bIsActivated

bool UEnemySpawnDirectorSystemComponent::bIsActivated = false

private

CurrentWaveData

FWaveDataCollection UEnemySpawnDirectorSystemComponent::CurrentWaveData

private

ExternalSpawnedEnemies

TSet<TObjectPtr<AEnemyCharacterBase> > UEnemySpawnDirectorSystemComponent::ExternalSpawnedEnemies

private

MonsterDictionary

TObjectPtr<UMonsterDictionary> UEnemySpawnDirectorSystemComponent::MonsterDictionary

private

OnEnemyKilled

FOnEnemyKilledStandalone UEnemySpawnDirectorSystemComponent::OnEnemyKilled

OnEnemySpawned

FOnEnemySpawnedStandalone UEnemySpawnDirectorSystemComponent::OnEnemySpawned

SpawnedEnemies

TArray<TObjectPtr<AEnemyCharacterBase> > UEnemySpawnDirectorSystemComponent::SpawnedEnemies

private

SpawnerMap

TMap<ESpawnAreaID, FSpawnerContainer> UEnemySpawnDirectorSystemComponent::SpawnerMap

private

SpawnPatternDictionary

TObjectPtr<USpawnPatternDictionary> UEnemySpawnDirectorSystemComponent::SpawnPatternDictionary

private

SpawnRemainingCount

int32 UEnemySpawnDirectorSystemComponent::SpawnRemainingCount = 0

private

---

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

• Source/CK_UE/Component/Spawn/EnemySpawnDirectorSystemComponent.h
• Source/CK_UE/Component/Spawn/EnemySpawnDirectorSystemComponent.cpp