AEncounterField 클래스 참조

#include <EncounterField.h>

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

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

Public 멤버 함수
	AEncounterField ()
void	StartEncounter ()
void	DeactivateEncounter ()
virtual UStageEventListenerComponent *	GetEventListenerComponent () const override
virtual EStageEvent	GetStageEvent () const override
FORCEINLINE bool	IsEncounterActive () const
IStageEventListenerInterface(으)로부터 상속된 Public 멤버 함수
virtual EListenerSlot	GetSlotForEvent (const FName EventID) const
virtual const TMap< FName, EListenerSlot > *	GetListenEvents () const

Protected 멤버 함수
virtual void	EndPlay (const EEndPlayReason::Type EndPlayReason) override

Protected 속성
TObjectPtr< UStageEventListenerComponent >	EventListenerComponent
TObjectPtr< UStageEventSenderComponent >	ClearEventSender
TObjectPtr< UStageEventSenderComponent >	EnemyKilledEventSender
FName	SectionID

Private 멤버 함수
void	SpawnNextWave ()
void	ScheduleNextWave (float Interval)
int32	CalculateExpectedEnemyCount (UEnemySpawnDirectorSystemComponent *EnemySys, const FWaveSpawnData &SpawnTables) const
void	TrySendClearEvent ()
void	ResetEncounterState ()
void	OnEnemyKilled (const AEnemyCharacterBase *DiedEnemy)
void	OnEnemySpawned (AEnemyCharacterBase *SpawnedEnemy)

Private 속성
TObjectPtr< UEnemySpawnDirectorSystemComponent >	EnemySpawnSystem
FName	CurrentWaveID
int32	CurrentWaveIndex = 0
int32	AliveEnemyCount = 0
int32	PendingSpawnCount = 0
int32	CurrentWavePendingSpawnCount = 0
bool	bAllWavesSpawned = false
bool	bActivated = false
bool	bClearEventSent = false
FTimerHandle	WaveTimerHandle

상세한 설명

스테이지 이벤트로 활성화되면 웨이브별 몬스터를 스폰하고, 섹션 내 모든 몬스터가 처치되면 완료 이벤트를 전송하는 필드 액터.

레벨에 배치 후 에디터에서 USpawnAreaComponent를 하위 컴포넌트로 추가하고 SectionID, ClearEventSender를 설정.

생성자 & 소멸자 문서화

AEncounterField()

AEncounterField::AEncounterField

(

)

{
    EventListenerComponent = CreateDefaultSubobject<UStageEventListenerComponent>(TEXT("EventListenerComponent"));
    ClearEventSender = CreateDefaultSubobject<UStageEventSenderComponent>(TEXT("ClearEventSender"));
    EnemyKilledEventSender = CreateDefaultSubobject<UStageEventSenderComponent>(TEXT("EnemyKilledEventSender"));
}

멤버 함수 문서화

CalculateExpectedEnemyCount()

int32 AEncounterField::CalculateExpectedEnemyCount ( UEnemySpawnDirectorSystemComponent *  EnemySys, const FWaveSpawnData &  SpawnTables  ) const

private

{
    if (EnemySys == nullptr)
    {
        return 0;
    }
 
    int32 ExpectedEnemyCount = 0;
 
    for (const FWaveSpawnEntry& SpawnTable : SpawnTables.SpawnList)
    {
        if (SpawnTable.Spawn_Count == 0)
        {
            continue;
        }
 
        if (SpawnTable.SpawnArea_ID == ESpawnAreaID::None)
        {
            LOG_WARNING(LogCKLevel, "EncounterField: Spawn_ID '%s'의 SpawnArea_ID가 None입니다.", *SpawnTable.Spawn_ID.ToString());
            continue;
        }
 
        if (SpawnTables.GetMonsterData(SpawnTable.Enemy_ID) == nullptr)
        {
            LOG_WARNING(LogCKLevel, "EncounterField: Spawn_ID '%s'의 MonsterData를 찾을 수 없습니다. Enemy_ID: %s", *SpawnTable.Spawn_ID.ToString(), *SpawnTable.Enemy_ID.ToString());
            continue;
        }
 
        const TArray<UEnemySpawnerComponent*> SpawnAreas = EnemySys->GetSpawners(SpawnTable.SpawnArea_ID);
 
        if (SpawnAreas.IsEmpty())
        {
            LOG_WARNING(LogCKLevel, "EncounterField: Spawn_ID '%s'에 사용할 SpawnArea가 등록되지 않았습니다.", *SpawnTable.Spawn_ID.ToString());
            continue;
        }
 
        for (UEnemySpawnerComponent* SpawnArea : SpawnAreas)
        {
            if (IsValid(SpawnArea) == false)
            {
                continue;
            }
 
            ExpectedEnemyCount += SpawnTable.Spawn_Count;
        }
    }
 
    return ExpectedEnemyCount;
}

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

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

DeactivateEncounter()

void AEncounterField::DeactivateEncounter

(

)

{
    UStageManagementSubsystem* StageManager = UCK_BPFunctionLibrary::GetStageManagementSubsystem(this);
    check(StageManager);
 
    GetWorld()->GetTimerManager().ClearTimer(WaveTimerHandle);
    StageManager->NotifyNextWaveCountdownStopped();
 
    if (IsValid(EnemySpawnSystem))
    {
        EnemySpawnSystem->OnEnemySpawned.RemoveDynamic(this, &AEncounterField::OnEnemySpawned);
        EnemySpawnSystem->OnEnemyKilled.RemoveDynamic(this, &AEncounterField::OnEnemyKilled);
        EnemySpawnSystem->ClearRegisteredSpawners();
        EnemySpawnSystem->ClearAll(true);
        EnemySpawnSystem = nullptr;
        ResetEncounterState();
    }
    else
    {
        EnemySpawnSystem = nullptr;
        ResetEncounterState();
    }
 
    StageManager->SetCurrentWaveRemainingEnemyCount(0);
}

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

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

EndPlay()

void AEncounterField::EndPlay ( const EEndPlayReason::Type  EndPlayReason )

overrideprotectedvirtual

{
    DeactivateEncounter();
 
    Super::EndPlay(EndPlayReason);
}

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

GetEventListenerComponent()

virtual UStageEventListenerComponent * AEncounterField::GetEventListenerComponent ( ) const

inlineoverridevirtual

IStageEventListenerInterface를 구현.

    {
        return EventListenerComponent;
    }

GetStageEvent()

virtual EStageEvent AEncounterField::GetStageEvent ( ) const

inlineoverridevirtual

IStageEventListenerInterface를 구현.

    {
        return EStageEvent::EncounterField;
    }

IsEncounterActive()

FORCEINLINE bool AEncounterField::IsEncounterActive ( ) const

inline

    {
        return bActivated;
    }

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

OnEnemyKilled()

void AEncounterField::OnEnemyKilled ( const AEnemyCharacterBase *  DiedEnemy )

private

{
    AliveEnemyCount = FMath::Max(AliveEnemyCount - 1, 0);
 
    if (UStageManagementSubsystem* StageManager = GetWorld()->GetSubsystem<UStageManagementSubsystem>())
    {
        StageManager->DecreaseCurrentWaveRemainingEnemyCount();
        StageManager->OnSpawnedEnemyKilled.Broadcast(DiedEnemy, StageManager->GetTotalSpawnRemainingCount());
    }
 
    if (EnemyKilledEventSender)
    {
        EnemyKilledEventSender->Send(DiedEnemy);
    }
 
    TrySendClearEvent();
}

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

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

OnEnemySpawned()

void AEncounterField::OnEnemySpawned ( AEnemyCharacterBase *  SpawnedEnemy )

private

{
    if (SpawnedEnemy == nullptr)
    {
        return;
    }
 
    AliveEnemyCount++;
    PendingSpawnCount = FMath::Max(PendingSpawnCount - 1, 0);
    CurrentWavePendingSpawnCount = FMath::Max(CurrentWavePendingSpawnCount - 1, 0);
}

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

ResetEncounterState()

void AEncounterField::ResetEncounterState ( )

private

{
    CurrentWaveID = NAME_None;
    CurrentWaveIndex = 0;
    AliveEnemyCount = 0;
    PendingSpawnCount = 0;
    CurrentWavePendingSpawnCount = 0;
    bAllWavesSpawned = false;
    bActivated = false;
    bClearEventSent = false;
}

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

ScheduleNextWave()

void AEncounterField::ScheduleNextWave ( float  Interval )

private

{
    if (Interval < KINDA_SMALL_NUMBER)
    {
        SpawnNextWave();
        return;
    }
 
    FTimerDelegate Delegate = FTimerDelegate::CreateUObject(this, &AEncounterField::SpawnNextWave);
 
    UWorld* World = GetWorld();
    check(World);
 
    if (UStageManagementSubsystem* StageManager = World->GetSubsystem<UStageManagementSubsystem>())
    {
        StageManager->NotifyNextWaveCountdownStarted(Interval);
    }
 
    World->GetTimerManager().SetTimer(WaveTimerHandle, Delegate, Interval, false);
}

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

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

SpawnNextWave()

void AEncounterField::SpawnNextWave ( )

private

{
    UWorld* World = GetWorld();
 
    if (UStageManagementSubsystem* StageManager = World ? World->GetSubsystem<UStageManagementSubsystem>() : nullptr)
    {
        StageManager->NotifyNextWaveCountdownStopped();
    }
 
    if (IsValid(EnemySpawnSystem) == false)
    {
        LOG_WARNING(LogCKLevel, "EncounterField: EnemySpawnSystem이 없어 웨이브 스폰을 건너뜁니다.");
        return;
    }
 
    UStageManifest* Manifest = UDataBundleRegistry::GetBundleAssetByTag<UStageManifest>(TAG_BUNDLE_INITIAL);
 
    if (Manifest == nullptr)
    {
        return;
    }
 
    FSectionData SectionData = Manifest->GetSectionTable(SectionID);
    const FWaveDataCollection* Wave = SectionData.GetWave(CurrentWaveID);
 
    if (Wave == nullptr)
    {
        LOG_WARNING(LogCKLevel, "EncounterField: 웨이브 '%s'를 찾을 수 없어 스폰을 종료합니다.", *CurrentWaveID.ToString());
        bAllWavesSpawned = true;
        TrySendClearEvent();
        return;
    }
 
    if (CurrentWavePendingSpawnCount > 0)
    {
        if (UStageManagementSubsystem* StageManager = GetWorld()->GetSubsystem<UStageManagementSubsystem>())
        {
            StageManager->DecreaseCurrentWaveRemainingEnemyCount(CurrentWavePendingSpawnCount);
        }
 
        PendingSpawnCount = FMath::Max(PendingSpawnCount - CurrentWavePendingSpawnCount, 0);
        CurrentWavePendingSpawnCount = 0;
    }
 
    EnemySpawnSystem->DeactivateAllSpawners();
 
    const FWaveSpawnData SpawnTables = Wave->GetSpawnTables();
    const int32 ExpectedEnemyCount = CalculateExpectedEnemyCount(EnemySpawnSystem, SpawnTables);
    CurrentWavePendingSpawnCount = ExpectedEnemyCount;
    PendingSpawnCount += ExpectedEnemyCount;
 
    if (UStageManagementSubsystem* StageManager = GetWorld()->GetSubsystem<UStageManagementSubsystem>())
    {
        StageManager->IncreaseCurrentWaveRemainingEnemyCount(ExpectedEnemyCount);
    }
 
    EnemySpawnSystem->SetComponentTickEnabled(true);
    EnemySpawnSystem->ActivateSpawners(SpawnTables);
 
    LOG_INFO(LogCKLevel, "EncounterField: 웨이브 '%s' 시작 (예정 스폰: %d, 대기 스폰: %d, 생존 몬스터: %d)", *CurrentWaveID.ToString(), ExpectedEnemyCount, PendingSpawnCount, AliveEnemyCount);
 
    if (UStageManagementSubsystem* StageManager = GetWorld()->GetSubsystem<UStageManagementSubsystem>())
    {
        StageManager->OnWaveStarted.Broadcast(*Wave, CurrentWaveIndex);
    }
 
    ++CurrentWaveIndex;
 
    if (Wave->IsLastWave())
    {
        bAllWavesSpawned = true;
    }
    else
    {
        CurrentWaveID = Wave->WaveTable.NextWave_ID;
        ScheduleNextWave(Wave->WaveTable.Wave_Interval);
    }
 
    TrySendClearEvent();
}

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

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

StartEncounter()

void AEncounterField::StartEncounter

(

)

{
    if (bActivated)
    {
        return;
    }
 
    UStageManifest* Manifest = UDataBundleRegistry::GetBundleAssetByTag<UStageManifest>(TAG_BUNDLE_INITIAL);
 
    if (ensureMsgf(Manifest, TEXT("EncounterField: UStageManifest를 번들에서 찾을 수 없습니다.")) == false)
    {
        return;
    }
 
    UStageManagementSubsystem* StageManager = GetWorld()->GetSubsystem<UStageManagementSubsystem>();
 
    if (ensureMsgf(StageManager, TEXT("EncounterField: UStageManagementSubsystem이 없습니다.")) == false)
    {
        return;
    }
 
    ResetEncounterState();
 
    FSectionData SectionData = Manifest->GetSectionTable(SectionID);
 
    if (SectionData.SectionTable.Section_ID.IsNone())
    {
        LOG_ERROR(LogCKLevel, "EncounterField: 섹션 '%s'를 찾을 수 없습니다.", *SectionID.ToString());
        return;
    }
 
    const FWaveDataCollection* FirstWave = SectionData.GetWaveTable();
 
    if (FirstWave == nullptr)
    {
        LOG_ERROR(LogCKLevel, "EncounterField: 섹션 '%s'의 첫 번째 웨이브를 찾을 수 없습니다.", *SectionID.ToString());
        return;
    }
 
    CurrentWaveID = FirstWave->Wave_ID;
 
    if (ensureMsgf(CurrentWaveID.IsValid(), TEXT("EncounterField: 섹션 '%s'의 첫 번째 웨이브를 찾을 수 없습니다."), *SectionID.ToString()) == false)
    {
        return;
    }
 
    const FWaveDataCollection* StartWave = SectionData.GetWave(CurrentWaveID);
 
    if (StartWave == nullptr)
    {
        LOG_ERROR(LogCKLevel, "EncounterField: 시작 웨이브 '%s'를 찾을 수 없습니다.", *CurrentWaveID.ToString());
        return;
    }
 
    ASpawnHub* SpawnHub = StageManager->GetOrCreateSpawnHub();
 
    if (ensureMsgf(SpawnHub, TEXT("EncounterField: SpawnHub를 생성하지 못했습니다.")) == false)
    {
        return;
    }
 
    EnemySpawnSystem = SpawnHub->GetOrCreateSpawnSystem<UEnemySpawnDirectorSystemComponent>();
 
    if (ensureMsgf(EnemySpawnSystem, TEXT("EncounterField: SpawnHub에서 EnemySpawnSystem을 가져오지 못했습니다.")) == false)
    {
        return;
    }
 
    EnemySpawnSystem->ClearRegisteredSpawners();
    EnemySpawnSystem->ClearAll(true);
    StageManager->SetCurrentWaveRemainingEnemyCount(0);
 
    // 하위 SpawnAreaComponent를 모두 수집하여 EnemySpawnSystem에 등록한다.
    TArray<UEnemySpawnerComponent*> SpawnAreas;
    GetComponents<UEnemySpawnerComponent>(SpawnAreas);
 
    Algo::NullSafeForEach(SpawnAreas, [this](UEnemySpawnerComponent* Area)
    {
        EnemySpawnSystem->RegisterSpawner(Area->GetID(), Area);
    });
 
    EnemySpawnSystem->OnReadyToSpawn(*StartWave);
    EnemySpawnSystem->OnEnemySpawned.AddDynamic(this, &AEncounterField::OnEnemySpawned);
    EnemySpawnSystem->OnEnemyKilled.AddDynamic(this, &AEncounterField::OnEnemyKilled);
 
    if (StageManager)
    {
        StageManager->ReadyToSpawn.Broadcast(*StartWave);
    }
 
    bActivated = true;
 
    USnapshotSubsystem::ProcessNewCommand<UEncounterActivationCommand>(this, [this](UEncounterActivationCommand* Command)
    {
        Command->Initialize(this);
    });
 
    SpawnNextWave();
}

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

TrySendClearEvent()

void AEncounterField::TrySendClearEvent ( )

private

{
    if (bClearEventSent || bAllWavesSpawned == false || PendingSpawnCount > 0 || AliveEnemyCount > 0)
    {
        return;
    }
 
    if (ClearEventSender == nullptr)
    {
        LOG_ERROR(LogCKLevel, "EncounterField: ClearEventSender가 nullptr입니다.");
        return;
    }
 
    bClearEventSent = true;
    LOG_INFO(LogCKLevel, "EncounterField: 모든 몬스터 처치 완료. 완료 이벤트 전송.");
    ClearEventSender->Send(nullptr);
 
    // 다음 트리거에서 새 사이클이 시작될 수 있도록 자동 비활성화.
    DeactivateEncounter();
}

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

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

멤버 데이터 문서화

AliveEnemyCount

int32 AEncounterField::AliveEnemyCount = 0

private

bActivated

bool AEncounterField::bActivated = false

private

bAllWavesSpawned

bool AEncounterField::bAllWavesSpawned = false

private

bClearEventSent

bool AEncounterField::bClearEventSent = false

private

ClearEventSender

TObjectPtr<UStageEventSenderComponent> AEncounterField::ClearEventSender

protected

CurrentWaveID

FName AEncounterField::CurrentWaveID

private

CurrentWaveIndex

int32 AEncounterField::CurrentWaveIndex = 0

private

CurrentWavePendingSpawnCount

int32 AEncounterField::CurrentWavePendingSpawnCount = 0

private

EnemyKilledEventSender

TObjectPtr<UStageEventSenderComponent> AEncounterField::EnemyKilledEventSender

protected

EnemySpawnSystem

TObjectPtr<UEnemySpawnDirectorSystemComponent> AEncounterField::EnemySpawnSystem

private

EventListenerComponent

TObjectPtr<UStageEventListenerComponent> AEncounterField::EventListenerComponent

protected

PendingSpawnCount

int32 AEncounterField::PendingSpawnCount = 0

private

SectionID

FName AEncounterField::SectionID

protected

WaveTimerHandle

FTimerHandle AEncounterField::WaveTimerHandle

private

---

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

• Source/CK_UE/Level/Event/Signalable/EncounterField.h
• Source/CK_UE/Level/Event/Signalable/EncounterField.cpp