UStageManifest 클래스 참조

#include <StageManifest.h>

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

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

Public 멤버 함수
	UStageManifest ()
virtual FPrimaryAssetId	GetPrimaryAssetId () const override
virtual void	PostLoad () override
virtual void	OnBundleLoaded_Implementation (FGameplayTag BundleTag) override
virtual void	OnBundleReleased_Implementation (FGameplayTag BundleTag) override
virtual FSectionData	GetSectionTable (const FName &SectionID)
virtual FDT_ToastMessageTable	GetToastMessageTable (const FName &RowID)
virtual FDT_PortraitTable	GetPortraitTable (const FName &RowID)
virtual FDT_ScenarioCutsceneTable	GetScenarioCutsceneTable (const FName &RowID)
virtual FDT_TutorialTable	GetTutorialTable (const FName &RowID)
virtual FDT_ConstellationTable	GetConstellationTable (const FName &RowID)
virtual FDT_BuffTable	GetBuffTable (const FName &RowID)
virtual FDT_ConstellationTable	GetRandomConstellationTable ()
FORCEINLINE const TMap< FName, FDT_ConstellationTable > &	GetConstellationMap () const
virtual FDT_SituationTable	GetSituationTable (const FName &RowID)
virtual TArray< FDT_SituationTable >	DrawSituationChoices (int32 PlayerLevel, const TArray< FName > &EquippedIDs, int32 DrawCount=3)
virtual float	GetRequiredExp (int32 Level)
virtual FDT_LevelTable	GetLevelTable (int32 Level)
bool	HasLevelData () const
IDataAssetBundle(으)로부터 상속된 Public 멤버 함수
void	OnBundleLoaded (FGameplayTag BundleTag)
void	OnBundleReleased (FGameplayTag BundleTag)

Public 속성
TSoftObjectPtr< UDataTable >	SectionDataMap
TSoftObjectPtr< UDataTable >	WaveDataMap
TSoftObjectPtr< UDataTable >	SpawnDataMap
TSoftObjectPtr< UDataTable >	MonsterDataMap
TSoftObjectPtr< UDataTable >	ToastMessageDataMap
TSoftObjectPtr< UDataTable >	PortraitDataMap
TSoftObjectPtr< UDataTable >	ScenarioCutsceneDataMap
TSoftObjectPtr< UDataTable >	TutorialDataMap
TSoftObjectPtr< UDataTable >	ConstellationDataMap
TSoftObjectPtr< UDataTable >	BuffDataMap
TSoftObjectPtr< UDataTable >	SituationDataMap
TSoftObjectPtr< UDataTable >	LevelDataMap
friend	FStageManifestHandle

Private 멤버 함수
void	BuildCache ()

정적 Private 멤버 함수
template<typename TRow >
static void	FillRowMap (const TSoftObjectPtr< UDataTable > &TablePtr, const TCHAR *TableName, TMap< FName, TRow > &OutMap)

Private 속성
TMap< FName, FSectionData >	SectionMap
TMap< FName, FWaveDataCollection >	WaveMap
TMap< FName, TArray< FWaveSpawnEntry > >	SpawnMap
TMap< FName, FMonsterDataCollection >	MonsterMap
TMap< FName, FDT_ToastMessageTable >	ToastMessageMap
TMap< FName, FDT_PortraitTable >	PortraitMap
TMap< FName, FDT_ScenarioCutsceneTable >	ScenarioCutsceneMap
TMap< FName, FDT_TutorialTable >	TutorialMap
TMap< FName, FDT_ConstellationTable >	ConstellationMap
TMap< FName, FDT_BuffTable >	BuffMap
TMap< FName, FDT_SituationTable >	SituationMap
TMap< int32, FDT_LevelTable >	LevelMap

상세한 설명

프로그램 구동 극초기에 에셋 매니저가 불러오는 스테이지&웨이브 데이터 컨테이너.

생성자 & 소멸자 문서화

UStageManifest()

UStageManifest::UStageManifest

(

)

{
    SectionDataMap = GetEnvironmentSoftPtrByKey<UDataTable>("SectionData");
    WaveDataMap = GetEnvironmentSoftPtrByKey<UDataTable>("WaveData");
    SpawnDataMap = GetEnvironmentSoftPtrByKey<UDataTable>("SpawnData");
    MonsterDataMap = GetEnvironmentSoftPtrByKey<UDataTable>("MonsterData");
    ToastMessageDataMap = GetEnvironmentSoftPtrByKey<UDataTable>("ToastMessageData");
    PortraitDataMap = GetEnvironmentSoftPtrByKey<UDataTable>("PortraitData");
    ScenarioCutsceneDataMap = GetEnvironmentSoftPtrByKey<UDataTable>("ScenarioCutsceneData");
    TutorialDataMap = GetEnvironmentSoftPtrByKey<UDataTable>("TutorialData");
    ConstellationDataMap = GetEnvironmentSoftPtrByKey<UDataTable>("ConstellationData");
    BuffDataMap = GetEnvironmentSoftPtrByKey<UDataTable>("BuffData");
    SituationDataMap = GetEnvironmentSoftPtrByKey<UDataTable>("SituationData");
    LevelDataMap = GetEnvironmentSoftPtrByKey<UDataTable>("LevelData");
}

멤버 함수 문서화

BuildCache()

void UStageManifest::BuildCache ( )

private

{
    SectionMap.Empty();
    WaveMap.Empty();
    SpawnMap.Empty();
    MonsterMap.Empty();
    ToastMessageMap.Empty();
    PortraitMap.Empty();
    ScenarioCutsceneMap.Empty();
    TutorialMap.Empty();
    ConstellationMap.Empty();
    BuffMap.Empty();
    SituationMap.Empty();
    LevelMap.Empty();
 
    const UDataTable* SectionTable = SectionDataMap.LoadSynchronous();
    const UDataTable* WaveTable = WaveDataMap.LoadSynchronous();
    const UDataTable* SpawnTable = SpawnDataMap.LoadSynchronous();
    const UDataTable* MonsterTable = MonsterDataMap.LoadSynchronous();
 
    if (SectionTable == nullptr)
    {
        LOG_WARNING(LogCKAsset, "SectionDataMap 로드 실패: DataTable이 nullptr입니다.");
        return;
    }
 
    if (WaveTable == nullptr)
    {
        LOG_WARNING(LogCKAsset, "WaveDataMap 로드 실패: DataTable이 nullptr입니다.");
        return;
    }
 
    if (SpawnTable == nullptr)
    {
        LOG_WARNING(LogCKAsset, "SpawnDataMap 로드 실패: DataTable이 nullptr입니다.");
        return;
    }
 
    if (MonsterTable == nullptr)
    {
        LOG_WARNING(LogCKAsset, "MonsterDataMap 로드 실패: DataTable이 nullptr입니다.");
        return;
    }
 
    TArray<FDT_SectionTable*> SectionTableRows;
    SectionTable->GetAllRows(TEXT("UStageManifest::BuildCache"), SectionTableRows);
 
    TArray<FDT_WaveTable*> WaveTableRows;
    WaveTable->GetAllRows(TEXT("UStageManifest::BuildCache"), WaveTableRows);
 
    TArray<FDT_SpawnTable*> SpawnTableRows;
    SpawnTable->GetAllRows(TEXT("UStageManifest::BuildCache"), SpawnTableRows);
 
    TArray<FEnemyStatTableRow*> MonsterTableRows;
    MonsterTable->GetAllRows(TEXT("UStageManifest::BuildCache"), MonsterTableRows);
 
    for (const FEnemyStatTableRow* MonsterRow : MonsterTableRows)
    {
        if (MonsterMap.Contains(MonsterRow->Enemy_ID) == false)
        {
            MonsterMap.Add(MonsterRow->Enemy_ID, FMonsterDataCollection(MonsterRow->Enemy_ID));
        }
 
        MonsterMap[MonsterRow->Enemy_ID].MonsterList.Emplace(*MonsterRow);
    }
 
    for (const FDT_SpawnTable* SpawnRow : SpawnTableRows)
    {
        TArray<FWaveSpawnEntry> SpawnEntries;
        ExpandSpawnRow(*SpawnRow, SpawnEntries);
        SpawnMap.Add(SpawnRow->Spawn_ID, MoveTemp(SpawnEntries));
    }
 
    for (const FDT_WaveTable* WaveRow : WaveTableRows)
    {
        FWaveDataCollection Collection(WaveRow->Wave_ID, this);
        Collection.WaveTable = *WaveRow;
 
        TArray<FString> SpawnLines;
        WaveRow->Spawn_ID.ParseIntoArrayLines(SpawnLines, true);
 
        const FString* SpawnIDLine = nullptr;
 
        for (const FString& Line : SpawnLines)
        {
            if (Line.TrimStartAndEnd().IsEmpty() == false)
            {
                SpawnIDLine = &Line;
                break;
            }
        }
 
        if (SpawnIDLine == nullptr)
        {
            SpawnIDLine = &WaveRow->Spawn_ID;
        }
 
        if (SpawnLines.Num() > 1)
        {
            LOG_WARNING(LogCKAsset, "Wave '%s'의 Spawn_ID에 줄바꿈이 포함되어 첫 번째 줄만 사용합니다: %s", *WaveRow->Wave_ID.ToString(), **SpawnIDLine);
        }
 
        TArray<FString> Parts;
        SpawnIDLine->ParseIntoArray(Parts, TEXT("&"), true);
 
        for (const FString& Part : Parts)
        {
            const FString Trimmed = Part.TrimStartAndEnd();
 
            if (Trimmed.IsEmpty() == false)
            {
                Collection.ParsedSpawnIDs.Add(FName(*Trimmed));
            }
        }
 
        WaveMap.Add(WaveRow->Wave_ID, MoveTemp(Collection));
    }
 
    for (const FDT_SectionTable* SectionRow : SectionTableRows)
    {
        FSectionData SectionData(*SectionRow, this);
        SectionMap.Add(SectionRow->Section_ID, MoveTemp(SectionData));
    }
 
    // 아래 테이블들은 서로 독립적이다. 하나가 없다고 나머지를 건너뛰면 안 된다.
    FillRowMap(ToastMessageDataMap, TEXT("ToastMessageDataMap"), ToastMessageMap);
    FillRowMap(PortraitDataMap, TEXT("PortraitDataMap"), PortraitMap);
    FillRowMap(ScenarioCutsceneDataMap, TEXT("ScenarioCutsceneDataMap"), ScenarioCutsceneMap);
    FillRowMap(TutorialDataMap, TEXT("TutorialDataMap"), TutorialMap);
    FillRowMap(BuffDataMap, TEXT("BuffDataMap"), BuffMap);
    FillRowMap(SituationDataMap, TEXT("SituationDataMap"), SituationMap);
    FillRowMap(ConstellationDataMap, TEXT("ConstellationDataMap"), ConstellationMap);
 
    // 문자열 컬럼의 파싱은 로드할 때마다 다시 한다. 테이블을 재임포트하지 않아도 최신 값이 반영된다.
    for (TPair<FName, FDT_SituationTable>& Pair : SituationMap)
    {
        ParseSituationTags(Pair.Value);
    }
 
    for (TPair<FName, FDT_ConstellationTable>& Pair : ConstellationMap)
    {
        ParseConstellationReactionTags(Pair.Value);
    }
 
    // BuildCache 가 PIE 에서 실제로 도는지, 무엇을 채웠는지를 가른다. 진단용.
    LOG_INFO(LogCKAsset, "BuildCache 완료: Situation %d개 / Constellation %d개 / Buff %d개 / Level %d개",
        SituationMap.Num(), ConstellationMap.Num(), BuffMap.Num(), LevelMap.Num());
 
    for (const TPair<FName, FDT_ConstellationTable>& Pair : ConstellationMap)
    {
        LOG_INFO(LogCKAsset, "  Constellation %s : Reaction_Tags=\"%s\" -> 파싱=%s",
            *Pair.Key.ToString(), *Pair.Value.Reaction_Tags, *BroadcastTag::ToDisplayString(Pair.Value.ParsedReactionTags));
    }
 
    // 레벨 표는 행 이름이 아니라 레벨 숫자를 키로 쓴다.
    if (const UDataTable* LevelTable = LevelDataMap.LoadSynchronous())
    {
        for (const TPair<FName, uint8*>& Pair : LevelTable->GetRowMap())
        {
            const FDT_LevelTable* Row = reinterpret_cast<const FDT_LevelTable*>(Pair.Value);
 
            if (Row)
            {
                LevelMap.Add(Row->Level, *Row);
            }
        }
    }
    else
    {
        LOG_WARNING(LogCKAsset, "LevelDataMap 로드 실패: DataTable이 nullptr입니다.");
    }
}

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

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

DrawSituationChoices()

TArray< FDT_SituationTable > UStageManifest::DrawSituationChoices ( int32  PlayerLevel, const TArray< FName > &  EquippedIDs, int32  DrawCount = 3  )

virtual

{
    TArray<FDT_SituationTable> Result;
 
    // 지금까지 장착한 카드들이 모아온 방송 태그. 선행 조건 판정의 기준이 된다.
    ESituationTag OwnedTags = ESituationTag::None;
 
    for (const FName& EquippedID : EquippedIDs)
    {
        if (const FDT_SituationTable* EquippedRow = SituationMap.Find(EquippedID))
        {
            OwnedTags |= EquippedRow->ParsedTags;
        }
    }
 
    // 선행 조건은 태그와 상황 ID 를 모두 만족해야 통과한다. 비어 있으면 조건 없음이다.
    auto MeetsRequirements = [&OwnedTags, &EquippedIDs](const FDT_SituationTable& Row)
    {
        if (EnumHasAllFlags(OwnedTags, Row.RequiredTags) == false)
        {
            return false;
        }
 
        for (const FName& RequiredID : Row.RequiredSituationIDs)
        {
            if (EquippedIDs.Contains(RequiredID) == false)
            {
                return false;
            }
        }
 
        return true;
    };
 
    // 레벨 제한, 이미 장착한 항목, 선행 조건을 걸러 후보를 만든다.
    TArray<const FDT_SituationTable*> Candidates;
 
    for (const TPair<FName, FDT_SituationTable>& Pair : SituationMap)
    {
        const FDT_SituationTable& Row = Pair.Value;
 
        if (Row.Unlock_Level > PlayerLevel || EquippedIDs.Contains(Row.Situation_ID))
        {
            continue;
        }
 
        if (MeetsRequirements(Row) == false)
        {
            continue;
        }
 
        Candidates.Add(&Row);
    }
 
    // 뽑을 때마다 후보에서 제거해 같은 상황이 두 번 나오지 않게 한다.
    while (Result.Num() < DrawCount && Candidates.IsEmpty() == false)
    {
        const int32 PickedIndex = FMath::RandRange(0, Candidates.Num() - 1);
 
        Result.Add(*Candidates[PickedIndex]);
        Candidates.RemoveAt(PickedIndex);
    }
 
    if (Result.Num() < DrawCount)
    {
        LOG_WARNING(LogCKAsset, "레벨 %d 에서 뽑을 수 있는 상황이 %d개뿐입니다. (요청 %d개)", PlayerLevel, Result.Num(), DrawCount);
    }
 
    return Result;
}

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

FillRowMap()

template<typename TRow >

static void UStageManifest::FillRowMap ( const TSoftObjectPtr< UDataTable > &  TablePtr, const TCHAR *  TableName, TMap< FName, TRow > &  OutMap  )

inlinestaticprivate

    {
        const UDataTable* Table = TablePtr.LoadSynchronous();
 
        if (Table == nullptr)
        {
            LOG_WARNING(LogCKAsset, "%s 로드 실패: DataTable이 nullptr입니다.", TableName);
            return;
        }
 
        for (const TPair<FName, uint8*>& Pair : Table->GetRowMap())
        {
            if (const TRow* Row = reinterpret_cast<const TRow*>(Pair.Value))
            {
                OutMap.Add(Pair.Key, *Row);
            }
        }
    }

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

GetBuffTable()

FDT_BuffTable UStageManifest::GetBuffTable ( const FName &  RowID )

virtual

{
    if (const FDT_BuffTable* Row = BuffMap.Find(RowID))
    {
        return *Row;
    }
 
    LOG_WARNING(LogCKAsset, "BuffMap에서 RowID '%s'를 찾을 수 없습니다.", *RowID.ToString());
    return FDT_BuffTable();
}

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

GetConstellationMap()

FORCEINLINE const TMap< FName, FDT_ConstellationTable > & UStageManifest::GetConstellationMap ( ) const

inline

    {
        return ConstellationMap;
    }

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

GetConstellationTable()

FDT_ConstellationTable UStageManifest::GetConstellationTable ( const FName &  RowID )

virtual

{
    if (const FDT_ConstellationTable* Row = ConstellationMap.Find(RowID))
    {
        return *Row;
    }
 
    LOG_WARNING(LogCKAsset, "ConstellationMap에서 RowID '%s'를 찾을 수 없습니다.", *RowID.ToString());
    return FDT_ConstellationTable();
}

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

GetLevelTable()

FDT_LevelTable UStageManifest::GetLevelTable ( int32  Level )

virtual

{
    if (const FDT_LevelTable* Row = LevelMap.Find(Level))
    {
        return *Row;
    }
 
    LOG_WARNING(LogCKAsset, "LevelMap에서 레벨 %d 행을 찾을 수 없습니다.", Level);
    return FDT_LevelTable();
}

GetPortraitTable()

FDT_PortraitTable UStageManifest::GetPortraitTable ( const FName &  RowID )

virtual

{
    if (const FDT_PortraitTable* Row = PortraitMap.Find(RowID))
    {
        return *Row;
    }
 
    LOG_WARNING(LogCKAsset, "PortraitMap에서 RowID '%s'를 찾을 수 없습니다.", *RowID.ToString());
    return FDT_PortraitTable();
}

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

GetPrimaryAssetId()

FPrimaryAssetId UStageManifest::GetPrimaryAssetId ( ) const

overridevirtual

{
    return FPrimaryAssetId("StagesData", GetFName());
}

GetRandomConstellationTable()

FDT_ConstellationTable UStageManifest::GetRandomConstellationTable ( )

virtual

{
    if (ConstellationMap.IsEmpty())
    {
        LOG_WARNING(LogCKAsset, "ConstellationMap이 비어 있어 성좌를 뽑을 수 없습니다.");
        return FDT_ConstellationTable();
    }
 
    TArray<FName> ConstellationIDs;
    ConstellationMap.GetKeys(ConstellationIDs);
 
    const FName PickedID = ConstellationIDs[FMath::RandRange(0, ConstellationIDs.Num() - 1)];
 
    return ConstellationMap[PickedID];
}

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

GetRequiredExp()

float UStageManifest::GetRequiredExp ( int32  Level )

virtual

{
    if (const FDT_LevelTable* Row = LevelMap.Find(Level))
    {
        return Row->Required_Exp;
    }
 
    // 표에 없는 레벨은 최종 레벨로 본다.
    return 0.0f;
}

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

GetScenarioCutsceneTable()

FDT_ScenarioCutsceneTable UStageManifest::GetScenarioCutsceneTable ( const FName &  RowID )

virtual

{
    if (const FDT_ScenarioCutsceneTable* Row = ScenarioCutsceneMap.Find(RowID))
    {
        return *Row;
    }
 
    LOG_WARNING(LogCKAsset, "ScenarioCutsceneMap에서 RowID '%s'를 찾을 수 없습니다.", *RowID.ToString());
    return FDT_ScenarioCutsceneTable();
}

GetSectionTable()

FSectionData UStageManifest::GetSectionTable ( const FName &  SectionID )

virtual

{
    if (const FSectionData* SectionData = SectionMap.Find(SectionID))
    {
        return *SectionData;
    }
 
    LOG_WARNING(LogCKAsset, "TotalSectionDataCache에서 SectionID '%s'를 찾을 수 없습니다.", *SectionID.ToString());
    return FSectionData();
}

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

GetSituationTable()

FDT_SituationTable UStageManifest::GetSituationTable ( const FName &  RowID )

virtual

{
    if (const FDT_SituationTable* Row = SituationMap.Find(RowID))
    {
        return *Row;
    }
 
    LOG_WARNING(LogCKAsset, "SituationMap에서 RowID '%s'를 찾을 수 없습니다.", *RowID.ToString());
    return FDT_SituationTable();
}

GetToastMessageTable()

FDT_ToastMessageTable UStageManifest::GetToastMessageTable ( const FName &  RowID )

virtual

{
    if (const FDT_ToastMessageTable* Row = ToastMessageMap.Find(RowID))
    {
        return *Row;
    }
 
    LOG_WARNING(LogCKAsset, "ToastMessageMap에서 RowID '%s'를 찾을 수 없습니다.", *RowID.ToString());
    return FDT_ToastMessageTable();
}

GetTutorialTable()

FDT_TutorialTable UStageManifest::GetTutorialTable ( const FName &  RowID )

virtual

{
    if (const FDT_TutorialTable* Row = TutorialMap.Find(RowID))
    {
        return *Row;
    }
 
    LOG_WARNING(LogCKAsset, "TutorialMap에서 RowID '%s'를 찾을 수 없습니다.", *RowID.ToString());
    return FDT_TutorialTable();
}

HasLevelData()

bool UStageManifest::HasLevelData ( ) const

inline

    {
        return LevelMap.Num() > 0;
    }

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

OnBundleLoaded_Implementation()

void UStageManifest::OnBundleLoaded_Implementation ( FGameplayTag  BundleTag )

overridevirtual

{
    IDataAssetBundle::OnBundleLoaded_Implementation(BundleTag);
    BuildCache();
}

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

OnBundleReleased_Implementation()

void UStageManifest::OnBundleReleased_Implementation ( FGameplayTag  BundleTag )

overridevirtual

{
    IDataAssetBundle::OnBundleReleased_Implementation(BundleTag);
    SectionMap.Empty();
    WaveMap.Empty();
    SpawnMap.Empty();
    MonsterMap.Empty();
    ToastMessageMap.Empty();
    PortraitMap.Empty();
    ScenarioCutsceneMap.Empty();
    TutorialMap.Empty();
    ConstellationMap.Empty();
    BuffMap.Empty();
    SituationMap.Empty();
    LevelMap.Empty();
}

PostLoad()

void UStageManifest::PostLoad ( )

overridevirtual

{
    Super::PostLoad();
    BuildCache();
}

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

멤버 데이터 문서화

BuffDataMap

TSoftObjectPtr<UDataTable> UStageManifest::BuffDataMap

BuffMap

TMap<FName, FDT_BuffTable> UStageManifest::BuffMap

private

ConstellationDataMap

TSoftObjectPtr<UDataTable> UStageManifest::ConstellationDataMap

ConstellationMap

TMap<FName, FDT_ConstellationTable> UStageManifest::ConstellationMap

private

FStageManifestHandle

friend UStageManifest::FStageManifestHandle

LevelDataMap

TSoftObjectPtr<UDataTable> UStageManifest::LevelDataMap

LevelMap

TMap<int32, FDT_LevelTable> UStageManifest::LevelMap

private

MonsterDataMap

TSoftObjectPtr<UDataTable> UStageManifest::MonsterDataMap

MonsterMap

TMap<FName, FMonsterDataCollection> UStageManifest::MonsterMap

private

PortraitDataMap

TSoftObjectPtr<UDataTable> UStageManifest::PortraitDataMap

PortraitMap

TMap<FName, FDT_PortraitTable> UStageManifest::PortraitMap

private

ScenarioCutsceneDataMap

TSoftObjectPtr<UDataTable> UStageManifest::ScenarioCutsceneDataMap

ScenarioCutsceneMap

TMap<FName, FDT_ScenarioCutsceneTable> UStageManifest::ScenarioCutsceneMap

private

SectionDataMap

TSoftObjectPtr<UDataTable> UStageManifest::SectionDataMap

SectionMap

TMap<FName, FSectionData> UStageManifest::SectionMap

private

SituationDataMap

TSoftObjectPtr<UDataTable> UStageManifest::SituationDataMap

SituationMap

TMap<FName, FDT_SituationTable> UStageManifest::SituationMap

private

SpawnDataMap

TSoftObjectPtr<UDataTable> UStageManifest::SpawnDataMap

SpawnMap

TMap<FName, TArray<FWaveSpawnEntry> > UStageManifest::SpawnMap

private

ToastMessageDataMap

TSoftObjectPtr<UDataTable> UStageManifest::ToastMessageDataMap

ToastMessageMap

TMap<FName, FDT_ToastMessageTable> UStageManifest::ToastMessageMap

private

TutorialDataMap

TSoftObjectPtr<UDataTable> UStageManifest::TutorialDataMap

TutorialMap

TMap<FName, FDT_TutorialTable> UStageManifest::TutorialMap

private

WaveDataMap

TSoftObjectPtr<UDataTable> UStageManifest::WaveDataMap

WaveMap

TMap<FName, FWaveDataCollection> UStageManifest::WaveMap

private

---

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

• Source/CK_UE/Data/Stage/StageManifest.h
• Source/CK_UE/Data/Stage/StageManifest.cpp