UStageManagementSubsystem 클래스 참조

#include <StageManagementSubsystem.h>

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

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

Public 멤버 함수
virtual void	Deinitialize () override
virtual void	OnLevelLoaded (ULevel *NewLevel, const ULevelStreamingData *LevelStreamingData) override
virtual void	OnLevelUnloaded () override
virtual void	OnLevelStreamingStarted () override
virtual void	OnLevelStreamingEnded () override
void	SetCurrentWaveRemainingEnemyCount (int32 Count)
void	IncreaseCurrentWaveRemainingEnemyCount (int32 Count)
void	DecreaseCurrentWaveRemainingEnemyCount (int32 Count=1)
void	NotifyNextWaveCountdownStarted (float Duration)
void	NotifyNextWaveCountdownStopped ()
ASpawnHub *	GetOrCreateSpawnHub ()
TargetableQuery	GetStageTargetableQueryHandle () const
int32	GetTotalSpawnRemainingCount () const
int32	GetCurrentWaveRemainingEnemyCount () const
int32	GetSpawnedEnemyCount () const
void	NotifyEnemyRemainingCountChanged ()
float	GetNextWaveCountdownRemainingTime () const
bool	IsNextWaveCountdownActive () const
FStageManagementHandle	GetStageManagementHandle ()
void	RegisterListener (const FName EventID, UStageEventListenerComponent *Listener)
void	UnregisterListener (const FName EventID, UStageEventListenerComponent *Listener)
void	DispatchStageEvent (const FName EventID, const AActor *Caller, const AActor *Sender)
int32	GetProcessorTriggerCount (const UStageEventProcessor *Processor) const
int32	IncrementProcessorTriggerCount (const UStageEventProcessor *Processor)
int32	DecrementProcessorTriggerCount (const UStageEventProcessor *Processor)
void	NotifyProcessorTriggered (const FName EventID, const AActor *Caller, const UStageEventProcessor *Processor)
FName	GetLastPlayerTriggeredEventID () const
bool	RollbackLastPlayerTriggeredProcessorCounts (const FName EventID)
void	ResetProcessorTriggerCount (UStageEventProcessor *Processor)
void	ResetAllProcessorTriggerCounts ()
FORCEINLINE ASpawnHub *	GetSpawnHub () const
FORCEINLINE FName	GetCurrentStageID () const
template<CSpawnSystem TSpawnSystem>
TSpawnSystem *	GetOrCreateSpawnSystem ()

Public 속성
FOnWaveManagerReadyToSpawning	ReadyToSpawn
FOnWaveStarted	OnWaveStarted
FOnWaveCleared	OnWaveCleared
FOnAllWavesCleared	OnAllWavesCleared
FOnSpawnedEnemyKilled	OnSpawnedEnemyKilled
FOnEnemyRemainingCountChanged	OnEnemyRemainingCountChanged
FOnNextWaveCountdownStarted	OnNextWaveCountdownStarted
FOnNextWaveCountdownStopped	OnNextWaveCountdownStopped

Protected 속성
TObjectPtr< ASpawnHub >	SpawnHub

Private 멤버 함수
bool	EnsureStageDictionaryLoaded ()
const FStoryboardEntry *	ResolveEntry (const FName EventID) const
const UStoryboardDefinition *	ResolveStoryboard () const
bool	IsPlayerEventCaller (const AActor *Caller) const
FStageEventContext	BuildStageEventContext (FName EventID)

Private 속성
FStageProgressState	StageProgress
TObjectPtr< UStageDictionary >	CachedStageDictionary
TArray< TWeakObjectPtr< const UStageEventProcessor > >	LastPlayerTriggeredProcessors
TMap< TWeakObjectPtr< const UStageEventProcessor >, int32 >	ProcessorTriggerCounts
TMap< FName, TArray< TWeakObjectPtr< UStageEventListenerComponent > > >	ListenersByEventID
FName	LastPlayerTriggeredEventID = NAME_None
int32	PlayerTriggeredDispatchSerial = 0
int32	ActivePlayerTriggeredDispatchSerial = INDEX_NONE
int32	LastPlayerTriggeredDispatchSerial = INDEX_NONE

Friends
struct	FStageManagementHandle

멤버 함수 문서화

BuildStageEventContext()

FStageEventContext UStageManagementSubsystem::BuildStageEventContext ( FName  EventID )

private

{
    FStageEventContext Context;
    static const FName AllEventID = TEXT("All");
 
    auto CleanupBucket = [this](const FName BucketEventID) -> TArray<TWeakObjectPtr<UStageEventListenerComponent>>*
    {
        TArray<TWeakObjectPtr<UStageEventListenerComponent>>* Bucket = ListenersByEventID.Find(BucketEventID);
 
        if (Bucket == nullptr)
        {
            return nullptr;
        }
 
        Bucket->RemoveAllSwap([](const TWeakObjectPtr<UStageEventListenerComponent>& Weak)
        {
            return Weak.IsValid() == false;
        });
 
        if (Bucket->IsEmpty())
        {
            ListenersByEventID.Remove(BucketEventID);
            return nullptr;
        }
 
        return Bucket;
    };
 
    TSet<const UStageEventListenerComponent*> AddedListeners;
 
    auto AppendBucket = [EventID, &Context, &AddedListeners](const TArray<TWeakObjectPtr<UStageEventListenerComponent>>* Bucket)
    {
        if (Bucket == nullptr)
        {
            return;
        }
 
        for (const TWeakObjectPtr<UStageEventListenerComponent>& Weak : *Bucket)
        {
            const UStageEventListenerComponent* Listener = Weak.Get();
 
            if (Listener == nullptr || AddedListeners.Contains(Listener))
            {
                continue;
            }
 
            AActor* Owner = Listener->GetOwner();
 
            if (Owner == nullptr || Owner->Implements<UStageEventListenerInterface>() == false)
            {
                continue;
            }
 
            AddedListeners.Add(Listener);
 
            const EListenerSlot Slot = Listener->GetSlotForEvent(EventID);
 
            Context.ValidListeners.Add(Owner);
 
            if (Slot == EListenerSlot::None)
            {
                continue;
            }
 
            if (Context.ValidListenersBySlot.Contains(Slot))
            {
                LOG_WARNING(LogCKLevel, "EventID '%s' 의 ListenerSlot이 중복되어 Slot 등록을 건너뜁니다. Actor = %s", *EventID.ToString(), *Owner->GetName());
                continue;
            }
 
            Context.ValidListenersBySlot.Add(Slot, Owner);
        }
    };
 
    AppendBucket(CleanupBucket(EventID));
 
    if (EventID != AllEventID)
    {
        AppendBucket(CleanupBucket(AllEventID));
    }
 
    return Context;
}

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

DecreaseCurrentWaveRemainingEnemyCount()

void UStageManagementSubsystem::DecreaseCurrentWaveRemainingEnemyCount

(

int32

Count = 1

)

{
    if (Count <= 0)
    {
        return;
    }
 
    StageProgress.DecreaseCurrentWaveRemainingEnemyCount(Count);
    NotifyEnemyRemainingCountChanged();
}

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

DecrementProcessorTriggerCount()

int32 UStageManagementSubsystem::DecrementProcessorTriggerCount

(

const UStageEventProcessor *

Processor

)

{
    checkf(Processor, TEXT("%s가 유효하지 않습니다. "), NAMEOF(UStageEventProcessor));
    int32* Found = ProcessorTriggerCounts.Find(Processor);
 
    if (Found == nullptr)
    {
        return 0;
    }
 
    *Found = FMath::Max(*Found - 1, 0);
 
    if (*Found == 0)
    {
        ProcessorTriggerCounts.Remove(Processor);
        return 0;
    }
 
    return *Found;
}

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

Deinitialize()

void UStageManagementSubsystem::Deinitialize ( )

overridevirtual

{
    StageProgress.Reset();
    ListenersByEventID.Empty();
    ProcessorTriggerCounts.Empty();
 
    LastPlayerTriggeredEventID = NAME_None;
    LastPlayerTriggeredProcessors.Empty();
 
    LastPlayerTriggeredDispatchSerial = INDEX_NONE;
    ActivePlayerTriggeredDispatchSerial = INDEX_NONE;
 
    Super::Deinitialize();
}

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

DispatchStageEvent()

void UStageManagementSubsystem::DispatchStageEvent	(	const FName	EventID,
		const AActor *	Caller,
		const AActor *	Sender
	)

{
    if (EventID.IsNone())
    {
        LOG_WARNING(LogCKLevel, "EventID가 비어 디스패치를 건너뜁니다.");
        return;
    }
 
    const FStoryboardEntry* Entry = ResolveEntry(EventID);
 
    if (Entry == nullptr || Entry->ProcessorGroup == nullptr || Entry->ProcessorGroup->IsEmpty())
    {
        LOG_WARNING(LogCKLevel, "EventID '%s' 엔트리에 ProcessorGroup 또는 Processor 인스턴스가 지정되지 않았습니다.", *EventID.ToString());
        return;
    }
 
    if (Entry->ExecutionCondition && Entry->ExecutionCondition->Evaluate(Caller, Cast<AEventGate>(Sender)) == false)
    {
        LOG_INFO(LogCKLevel, "EventID '%s' 의 실행 조건이 충족되지 않아 디스패치를 중단합니다.", *EventID.ToString());
        return;
    }
 
    const FStageEventContext Context = BuildStageEventContext(EventID);
 
    const FString CallerName = Caller ? Caller->GetName() : TEXT("None");
    const FString SenderName = Sender ? Sender->GetName() : TEXT("None");
 
    LOG_SCREEN_C
    (
        FColor::Yellow,
        "[StageEvent] %-9s EventID = %-16s Caller = %-28s Sender = %-28s ValidListeners = %-3d Processors = %-3d",
        TEXT("Dispatch"),
        *EventID.ToString(),
        *CallerName,
        *SenderName,
        Context.ValidListeners.Num(),
        Entry->ProcessorGroup->Num()
    );
 
    const bool bPlayerEventCaller = IsPlayerEventCaller(Caller);
    const int32 PreviousActivePlayerTriggeredDispatchSerial = ActivePlayerTriggeredDispatchSerial;
 
    if (bPlayerEventCaller)
    {
        ActivePlayerTriggeredDispatchSerial = ++PlayerTriggeredDispatchSerial;
    }
 
    Entry->ProcessorGroup->Process(this, EventID, Caller, Sender, Context);
 
    if (bPlayerEventCaller)
    {
        ActivePlayerTriggeredDispatchSerial = PreviousActivePlayerTriggeredDispatchSerial;
    }
}

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

EnsureStageDictionaryLoaded()

bool UStageManagementSubsystem::EnsureStageDictionaryLoaded ( )

private

{
    if (CachedStageDictionary)
    {
        return true;
    }
 
    CachedStageDictionary = GetEnvironmentAssetByKey<UStageDictionary>("StageDictionary");
 
    if (CachedStageDictionary == nullptr)
    {
        LOG_ERROR(LogCK, "StageDictionary 로드에 실패했습니다.");
        return false;
    }
    else
    {
        return true;
    }
}

GetCurrentStageID()

FORCEINLINE FName UStageManagementSubsystem::GetCurrentStageID ( ) const

inline

    {
        return StageProgress.GetCurrentStageID();
    }

GetCurrentWaveRemainingEnemyCount()

int32 UStageManagementSubsystem::GetCurrentWaveRemainingEnemyCount

(

)

const

{
    return StageProgress.GetCurrentWaveRemainingEnemyCount();
}

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

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

GetLastPlayerTriggeredEventID()

FName UStageManagementSubsystem::GetLastPlayerTriggeredEventID

(

)

const

{
    return LastPlayerTriggeredEventID;
}

GetNextWaveCountdownRemainingTime()

float UStageManagementSubsystem::GetNextWaveCountdownRemainingTime

(

)

const

{
    const UWorld* World = GetWorld();
 
    if (World == nullptr || StageProgress.GetNextWaveCountdownEndTime() <= 0.f)
    {
        return 0.f;
    }
 
    return FMath::Max(StageProgress.GetNextWaveCountdownEndTime() - World->GetTimeSeconds(), 0.f);
}

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

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

GetOrCreateSpawnHub()

ASpawnHub * UStageManagementSubsystem::GetOrCreateSpawnHub

(

)

{
    if (IsValid(SpawnHub))
    {
        return SpawnHub;
    }
 
    UWorld* World = GetWorld();
 
    if (World == nullptr)
    {
        LOG_ERROR(LogCK, "World가 없어 %s를 생성할 수 없습니다.", NAMEOF(ASpawnHub));
        return nullptr;
    }
 
    SpawnHub = World->SpawnActor<ASpawnHub>(ASpawnHub::StaticClass(), FVector::ZeroVector, FRotator::ZeroRotator);
 
    if (SpawnHub == nullptr)
    {
        LOG_ERROR(LogCK, "%s 생성에 실패했습니다.", NAMEOF(ASpawnHub));
        return nullptr;
    }
 
    SpawnHub->InitializeHub(this);
    return SpawnHub;
}

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

GetOrCreateSpawnSystem()

template<CSpawnSystem TSpawnSystem>

TSpawnSystem * UStageManagementSubsystem::GetOrCreateSpawnSystem

(

)

{
    ASpawnHub* Hub = GetOrCreateSpawnHub();
    return Hub ? Hub->GetOrCreateSpawnSystem<TSpawnSystem>() : nullptr;
}

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

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

GetProcessorTriggerCount()

int32 UStageManagementSubsystem::GetProcessorTriggerCount

(

const UStageEventProcessor *

Processor

)

const

{
    if (Processor == nullptr)
    {
        return 0;
    }
 
    if (const int32* Found = ProcessorTriggerCounts.Find(Processor))
    {
        return *Found;
    }
    else
    {
        return 0;
    }
}

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

GetSpawnedEnemyCount()

int32 UStageManagementSubsystem::GetSpawnedEnemyCount

(

)

const

{
    if (SpawnHub == nullptr || IsValid(SpawnHub) == false)
    {
        return 0;
    }
 
    int32 Total = 0;
 
    for (UEnemySpawnDirectorSystemComponent* SpawnSystem : SpawnHub->GetRegisteredSpawnSystems<UEnemySpawnDirectorSystemComponent>())
    {
        TArray<AEnemyCharacterBase*> Array = SpawnSystem->GetAllSpawnedEnemies();
 
        Array.RemoveAllSwap([](const AEnemyCharacterBase* Enemy)
        {
            return !IsValid(Enemy);
        });
 
        Total += Array.Num();
    }
 
    return Total;
}

GetSpawnHub()

FORCEINLINE ASpawnHub * UStageManagementSubsystem::GetSpawnHub ( ) const

inline

    {
        return SpawnHub;
    }

GetStageManagementHandle()

FStageManagementHandle UStageManagementSubsystem::GetStageManagementHandle

(

)

{
    FStageManagementHandle Handle = FStageManagementHandle(this);
    Handle.OnAllWavesCleared = this->OnAllWavesCleared;
    Handle.OnWaveCleared = this->OnWaveCleared;
    Handle.OnWaveStarted = this->OnWaveStarted;
    Handle.OnSpawnedEnemyKilled = this->OnSpawnedEnemyKilled;
    return Handle;
}

GetStageTargetableQueryHandle()

TargetableQuery UStageManagementSubsystem::GetStageTargetableQueryHandle

(

)

const

{
    if (SpawnHub == nullptr || IsValid(SpawnHub) == false)
    {
        return TargetableQuery(GetWorld(), {});
    }
    else
    {
        return TargetableQuery(GetWorld(), SpawnHub->GetAllSpawnedTargetableEntity());
    }
}

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

GetTotalSpawnRemainingCount()

int32 UStageManagementSubsystem::GetTotalSpawnRemainingCount

(

)

const

{
    return GetCurrentWaveRemainingEnemyCount();
}

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

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

IncreaseCurrentWaveRemainingEnemyCount()

void UStageManagementSubsystem::IncreaseCurrentWaveRemainingEnemyCount

(

int32

Count

)

{
    StageProgress.IncreaseCurrentWaveRemainingEnemyCount(Count);
    NotifyEnemyRemainingCountChanged();
}

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

IncrementProcessorTriggerCount()

int32 UStageManagementSubsystem::IncrementProcessorTriggerCount

(

const UStageEventProcessor *

Processor

)

{
    checkf(Processor, TEXT("%s가 유효하지 않습니다. "), NAMEOF(UStageEventProcessor));
 
    if (ProcessorTriggerCounts.Contains(Processor))
    {
        int32* ExecutedCount = ProcessorTriggerCounts.Find(Processor);
        int32& CurrentCount = *ExecutedCount;
        return (++CurrentCount);
    }
 
    ProcessorTriggerCounts.Add(Processor, 1);
    return 1;
}

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

IsNextWaveCountdownActive()

bool UStageManagementSubsystem::IsNextWaveCountdownActive

(

)

const

{
    return GetNextWaveCountdownRemainingTime() > KINDA_SMALL_NUMBER;
}

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

IsPlayerEventCaller()

bool UStageManagementSubsystem::IsPlayerEventCaller ( const AActor *  Caller ) const

private

{
    const APawn* Pawn = Cast<APawn>(Caller);
    return Pawn && Pawn->IsPlayerControlled();
}

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

NotifyEnemyRemainingCountChanged()

void UStageManagementSubsystem::NotifyEnemyRemainingCountChanged

(

)

{
    OnEnemyRemainingCountChanged.Broadcast(StageProgress.GetCurrentWaveRemainingEnemyCount());
}

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

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

NotifyNextWaveCountdownStarted()

void UStageManagementSubsystem::NotifyNextWaveCountdownStarted

(

float

Duration

)

{
    UWorld* World = GetWorld();
 
    if (World == nullptr || Duration < KINDA_SMALL_NUMBER)
    {
        NotifyNextWaveCountdownStopped();
        return;
    }
 
    StageProgress.SetNextWaveCountdownEndTime(World->GetTimeSeconds() + Duration);
    OnNextWaveCountdownStarted.Broadcast(Duration);
}

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

NotifyNextWaveCountdownStopped()

void UStageManagementSubsystem::NotifyNextWaveCountdownStopped

(

)

{
    const bool bWasScheduled = StageProgress.GetNextWaveCountdownEndTime() > 0.0f;
    StageProgress.SetNextWaveCountdownEndTime(0.0f);
 
    if (bWasScheduled)
    {
        OnNextWaveCountdownStopped.Broadcast();
    }
}

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

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

NotifyProcessorTriggered()

void UStageManagementSubsystem::NotifyProcessorTriggered	(	const FName	EventID,
		const AActor *	Caller,
		const UStageEventProcessor *	Processor
	)

{
    if (EventID.IsNone() || Processor == nullptr || IsPlayerEventCaller(Caller) == false)
    {
        return;
    }
 
    if (ActivePlayerTriggeredDispatchSerial == INDEX_NONE)
    {
        return;
    }
 
    if (LastPlayerTriggeredDispatchSerial != ActivePlayerTriggeredDispatchSerial)
    {
        LastPlayerTriggeredEventID = EventID;
        LastPlayerTriggeredProcessors.Empty();
        LastPlayerTriggeredDispatchSerial = ActivePlayerTriggeredDispatchSerial;
    }
 
    LastPlayerTriggeredProcessors.AddUnique(TWeakObjectPtr<const UStageEventProcessor>(Processor));
}

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

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

OnLevelLoaded()

void UStageManagementSubsystem::OnLevelLoaded ( ULevel *  NewLevel, const ULevelStreamingData *  LevelStreamingData  )

overridevirtual

IStreamingEventListenerInterface를 구현.

{
    LOG_INFO(LogCK, "Level Loaded");
 
    if (LevelStreamingData == nullptr)
    {
        LOG_WARNING(LogCK, "LevelStreamingData가 nullptr 입니다.");
        return;
    }
    
    FName ResolvedStageID = LevelStreamingData->TargetMap.PrimaryAssetName;
    StageProgress.SetCurrentStageID(ResolvedStageID);
 
    LOG_INFO(LogCK, "스테이지 정보 로드 완료: %s", *ResolvedStageID.ToString());
 
    // SpawnHub는 레벨당 하나이며, 각 SpawnSystemComponent를 소유한다.
    GetOrCreateSpawnHub();
}

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

OnLevelStreamingEnded()

virtual void UStageManagementSubsystem::OnLevelStreamingEnded ( )

inlineoverridevirtual

IStreamingEventListenerInterface를 구현.

{ }

OnLevelStreamingStarted()

virtual void UStageManagementSubsystem::OnLevelStreamingStarted ( )

inlineoverridevirtual

IStreamingEventListenerInterface를 구현.

{ }

OnLevelUnloaded()

void UStageManagementSubsystem::OnLevelUnloaded ( )

overridevirtual

IStreamingEventListenerInterface를 구현.

{
    if (SpawnHub == nullptr || IsValid(SpawnHub) == false)
    {
        NotifyNextWaveCountdownStopped();
        SetCurrentWaveRemainingEnemyCount(0);
        StageProgress.SetCurrentStageID(NAME_None);
        return;
    }
 
    // 등록된 모든 EncounterField EnemySpawnSystem에서 살아있는 적을 풀로 반환한다.
    for (UEnemySpawnDirectorSystemComponent* SpawnSystem : SpawnHub->GetRegisteredSpawnSystems<UEnemySpawnDirectorSystemComponent>())
    {
        for (AEnemyCharacterBase* Enemy : SpawnSystem->GetAllSpawnedEnemies())
        {
            checkf(Enemy, TEXT("%s가 유효하지 않습니다. "), NAMEOF(AEnemyCharacterBase));
            Enemy->ForceReturnToPool(true);
        }
    }
 
    SpawnHub->Destroy();
    SpawnHub = nullptr;
    NotifyNextWaveCountdownStopped();
    SetCurrentWaveRemainingEnemyCount(0);
    StageProgress.SetCurrentStageID(NAME_None);
}

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

RegisterListener()

void UStageManagementSubsystem::RegisterListener	(	const FName	EventID,
		UStageEventListenerComponent *	Listener
	)

{
    if (Listener == nullptr)
    {
        LOG_WARNING(LogCKLevel, "Listener가 nullptr 입니다.");
        return;
    }
 
    if (EventID.IsNone() == false)
    {
        TArray<TWeakObjectPtr<UStageEventListenerComponent>>& Bucket = ListenersByEventID.FindOrAdd(EventID);
        Bucket.AddUnique(Listener);
        return;
    }
 
    LOG_WARNING
    (
        LogCKLevel,
        "EventID가 비어있어 등록을 건너뜁니다. (Owner: %s)",
        Listener->GetOwner() ? *Listener->GetOwner()->GetName() : TEXT("None")
    );
}

ResetAllProcessorTriggerCounts()

void UStageManagementSubsystem::ResetAllProcessorTriggerCounts

(

)

{
    ProcessorTriggerCounts.Empty();
    LastPlayerTriggeredEventID = NAME_None;
    LastPlayerTriggeredProcessors.Empty();
    LastPlayerTriggeredDispatchSerial = INDEX_NONE;
}

ResetProcessorTriggerCount()

void UStageManagementSubsystem::ResetProcessorTriggerCount

(

UStageEventProcessor *

Processor

)

{
    if (Processor == nullptr)
    {
        return;
    }
 
    ProcessorTriggerCounts.Remove(Processor);
}

ResolveEntry()

const FStoryboardEntry * UStageManagementSubsystem::ResolveEntry ( const FName  EventID ) const

private

{
    const UStoryboardDefinition* Storyboard = ResolveStoryboard();
 
    if (Storyboard == nullptr)
    {
        return nullptr;
    }
 
    return Storyboard->FindEntry(EventID);
}

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

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

ResolveStoryboard()

const UStoryboardDefinition * UStageManagementSubsystem::ResolveStoryboard ( ) const

private

{
    UStageDictionary* StageDictionary = UCK_LevelStreamingBPLibrary::GetStreamingDataFromStageDictionary();
 
    if (StageDictionary == nullptr)
    {
        return nullptr;
    }
 
    ULevelStreamingData* StreamingData = StageDictionary->GetLevelStreamingDataByWorld(this);
 
    if (StreamingData == nullptr || StreamingData->LevelRule == nullptr)
    {
        return nullptr;
    }
 
    return StreamingData->LevelRule->GetStoryboardDefinition();
}

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

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

RollbackLastPlayerTriggeredProcessorCounts()

bool UStageManagementSubsystem::RollbackLastPlayerTriggeredProcessorCounts

(

const FName

EventID

)

{
    if (EventID.IsNone() || LastPlayerTriggeredEventID != EventID)
    {
        return false;
    }
 
    bool bRolledBack = false;
 
    for (const TWeakObjectPtr<const UStageEventProcessor>& WeakProcessor : LastPlayerTriggeredProcessors)
    {
        if (const UStageEventProcessor* Processor = WeakProcessor.Get())
        {
            DecrementProcessorTriggerCount(Processor);
            bRolledBack = true;
        }
    }
 
    LastPlayerTriggeredEventID = NAME_None;
    LastPlayerTriggeredProcessors.Empty();
    LastPlayerTriggeredDispatchSerial = INDEX_NONE;
    return bRolledBack;
}

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

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

SetCurrentWaveRemainingEnemyCount()

void UStageManagementSubsystem::SetCurrentWaveRemainingEnemyCount

(

int32

Count

)

{
    StageProgress.SetCurrentWaveRemainingEnemyCount(Count);
    NotifyEnemyRemainingCountChanged();
}

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

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

UnregisterListener()

void UStageManagementSubsystem::UnregisterListener	(	const FName	EventID,
		UStageEventListenerComponent *	Listener
	)

{
    if (EventID.IsNone() || Listener == nullptr)
    {
        return;
    }
 
    TArray<TWeakObjectPtr<UStageEventListenerComponent>>* Bucket = ListenersByEventID.Find(EventID);
 
    if (Bucket == nullptr)
    {
        return;
    }
 
    Bucket->RemoveAllSwap([Listener](const TWeakObjectPtr<UStageEventListenerComponent>& Weak)
    {
        return Weak.IsValid() == false || Weak.Get() == Listener;
    });
 
    if (Bucket->IsEmpty())
    {
        ListenersByEventID.Remove(EventID);
    }
}

Friend, 그리고 관련된 함수 문서화

FStageManagementHandle

friend struct FStageManagementHandle

friend

멤버 데이터 문서화

ActivePlayerTriggeredDispatchSerial

int32 UStageManagementSubsystem::ActivePlayerTriggeredDispatchSerial = INDEX_NONE

private

CachedStageDictionary

TObjectPtr<UStageDictionary> UStageManagementSubsystem::CachedStageDictionary

private

LastPlayerTriggeredDispatchSerial

int32 UStageManagementSubsystem::LastPlayerTriggeredDispatchSerial = INDEX_NONE

private

LastPlayerTriggeredEventID

FName UStageManagementSubsystem::LastPlayerTriggeredEventID = NAME_None

private

LastPlayerTriggeredProcessors

TArray<TWeakObjectPtr<const UStageEventProcessor> > UStageManagementSubsystem::LastPlayerTriggeredProcessors

private

ListenersByEventID

TMap<FName, TArray<TWeakObjectPtr<UStageEventListenerComponent> > > UStageManagementSubsystem::ListenersByEventID

private

OnAllWavesCleared

FOnAllWavesCleared UStageManagementSubsystem::OnAllWavesCleared

OnEnemyRemainingCountChanged

FOnEnemyRemainingCountChanged UStageManagementSubsystem::OnEnemyRemainingCountChanged

OnNextWaveCountdownStarted

FOnNextWaveCountdownStarted UStageManagementSubsystem::OnNextWaveCountdownStarted

OnNextWaveCountdownStopped

FOnNextWaveCountdownStopped UStageManagementSubsystem::OnNextWaveCountdownStopped

OnSpawnedEnemyKilled

FOnSpawnedEnemyKilled UStageManagementSubsystem::OnSpawnedEnemyKilled

OnWaveCleared

FOnWaveCleared UStageManagementSubsystem::OnWaveCleared

OnWaveStarted

FOnWaveStarted UStageManagementSubsystem::OnWaveStarted

PlayerTriggeredDispatchSerial

int32 UStageManagementSubsystem::PlayerTriggeredDispatchSerial = 0

private

ProcessorTriggerCounts

TMap<TWeakObjectPtr<const UStageEventProcessor>, int32> UStageManagementSubsystem::ProcessorTriggerCounts

private

ReadyToSpawn

FOnWaveManagerReadyToSpawning UStageManagementSubsystem::ReadyToSpawn

SpawnHub

TObjectPtr<ASpawnHub> UStageManagementSubsystem::SpawnHub

protected

StageProgress

FStageProgressState UStageManagementSubsystem::StageProgress

private

---

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

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