refactor: use asset_type_t for ZoneDefinition

src/ZoneCommon/Game/IW3/AssetNameResolverIW3.cpp

@@ -0,0 +1,22 @@
+#include "AssetNameResolverIW3.h"
+
+#include "Game/IW3/GameAssetPoolIW3.h"
+#include "Utils/StringUtils.h"
+
+using namespace IW3;
+
+AssetNameResolver::AssetNameResolver()
+{
+    for (auto assetType = 0; assetType < ASSET_TYPE_COUNT; assetType++)
+        AddAssetTypeName(assetType, *GameAssetPoolIW3::AssetTypeNameByType(assetType));
+}
+
+GameId AssetNameResolver::GetGameId() const
+{
+    return GameId::IW3;
+}
+
+std::optional<const char*> AssetNameResolver::GetAssetTypeName(const asset_type_t assetType) const
+{
+    return GameAssetPoolIW3::AssetTypeNameByType(assetType);
+}

src/ZoneCommon/Game/IW3/AssetNameResolverIW3.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "Zone/AssetNameResolver.h"
+
+namespace IW3
+{
+    class AssetNameResolver final : public HashMapBasedAssetNameResolver
+    {
+    public:
+        AssetNameResolver();
+        [[nodiscard]] GameId GetGameId() const override;
+        [[nodiscard]] std::optional<const char*> GetAssetTypeName(asset_type_t assetType) const override;
+    };
+} // namespace IW3

src/ZoneCommon/Game/IW3/GameAssetPoolIW3.cpp

@@ -218,15 +218,15 @@ XAssetInfoGeneric* GameAssetPoolIW3::GetAsset(const asset_type_t type, const std
 #undef CASE_GET_ASSET
 }
 
-const char* GameAssetPoolIW3::AssetTypeNameByType(const asset_type_t assetType)
+std::optional<const char*> GameAssetPoolIW3::AssetTypeNameByType(const asset_type_t assetType)
 {
     if (assetType >= 0 && assetType < static_cast<int>(std::extent_v<decltype(ASSET_TYPE_NAMES)>))
         return ASSET_TYPE_NAMES[assetType];
 
-    return ASSET_TYPE_INVALID;
+    return std::nullopt;
 }
 
-const char* GameAssetPoolIW3::GetAssetTypeName(const asset_type_t assetType) const
+std::optional<const char*> GameAssetPoolIW3::GetAssetTypeName(const asset_type_t assetType) const
 {
     return AssetTypeNameByType(assetType);
 }

src/ZoneCommon/Game/IW3/GameAssetPoolIW3.h

@@ -5,12 +5,12 @@
 #include "Pool/ZoneAssetPools.h"
 
 #include <memory>
+#include <optional>
 
 class GameAssetPoolIW3 final : public ZoneAssetPools
 {
     int m_priority;
 
-    static constexpr const char* ASSET_TYPE_INVALID = "invalid_asset_type";
     static const char* ASSET_TYPE_NAMES[];
 
 protected:
@@ -54,8 +54,8 @@ public:
 
     _NODISCARD XAssetInfoGeneric* GetAsset(asset_type_t type, const std::string& name) const override;
 
-    static const char* AssetTypeNameByType(asset_type_t assetType);
-    _NODISCARD const char* GetAssetTypeName(asset_type_t assetType) const override;
+    static std::optional<const char*> AssetTypeNameByType(asset_type_t assetType);
+    _NODISCARD std::optional<const char*> GetAssetTypeName(asset_type_t assetType) const override;
 
     static asset_type_t AssetTypeCount();
     _NODISCARD asset_type_t GetAssetTypeCount() const override;

src/ZoneCommon/Game/IW4/AssetNameResolverIW4.cpp

@@ -0,0 +1,22 @@
+#include "AssetNameResolverIW4.h"
+
+#include "Game/IW4/GameAssetPoolIW4.h"
+#include "Utils/StringUtils.h"
+
+using namespace IW4;
+
+AssetNameResolver::AssetNameResolver()
+{
+    for (auto assetType = 0; assetType < ASSET_TYPE_COUNT; assetType++)
+        AddAssetTypeName(assetType, *GameAssetPoolIW4::AssetTypeNameByType(assetType));
+}
+
+GameId AssetNameResolver::GetGameId() const
+{
+    return GameId::IW4;
+}
+
+std::optional<const char*> AssetNameResolver::GetAssetTypeName(const asset_type_t assetType) const
+{
+    return GameAssetPoolIW4::AssetTypeNameByType(assetType);
+}

src/ZoneCommon/Game/IW4/AssetNameResolverIW4.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "Zone/AssetNameResolver.h"
+
+namespace IW4
+{
+    class AssetNameResolver final : public HashMapBasedAssetNameResolver
+    {
+    public:
+        AssetNameResolver();
+        [[nodiscard]] GameId GetGameId() const override;
+        [[nodiscard]] std::optional<const char*> GetAssetTypeName(asset_type_t assetType) const override;
+    };
+} // namespace IW4

src/ZoneCommon/Game/IW4/GameAssetPoolIW4.cpp

@@ -259,15 +259,15 @@ XAssetInfoGeneric* GameAssetPoolIW4::GetAsset(const asset_type_t type, const std
 #undef CASE_GET_ASSET
 }
 
-const char* GameAssetPoolIW4::AssetTypeNameByType(const asset_type_t assetType)
+std::optional<const char*> GameAssetPoolIW4::AssetTypeNameByType(const asset_type_t assetType)
 {
     if (assetType >= 0 && assetType < static_cast<int>(std::extent_v<decltype(ASSET_TYPE_NAMES)>))
         return ASSET_TYPE_NAMES[assetType];
 
-    return ASSET_TYPE_INVALID;
+    return std::nullopt;
 }
 
-const char* GameAssetPoolIW4::GetAssetTypeName(const asset_type_t assetType) const
+std::optional<const char*> GameAssetPoolIW4::GetAssetTypeName(const asset_type_t assetType) const
 {
     return AssetTypeNameByType(assetType);
 }

src/ZoneCommon/Game/IW4/GameAssetPoolIW4.h

@@ -62,8 +62,8 @@ public:
 
     _NODISCARD XAssetInfoGeneric* GetAsset(asset_type_t type, const std::string& name) const override;
 
-    static const char* AssetTypeNameByType(asset_type_t assetType);
-    _NODISCARD const char* GetAssetTypeName(asset_type_t assetType) const override;
+    static std::optional<const char*> AssetTypeNameByType(asset_type_t assetType);
+    _NODISCARD std::optional<const char*> GetAssetTypeName(asset_type_t assetType) const override;
 
     static asset_type_t AssetTypeCount();
     _NODISCARD asset_type_t GetAssetTypeCount() const override;

src/ZoneCommon/Game/IW5/AssetNameResolverIW5.cpp

@@ -0,0 +1,22 @@
+#include "AssetNameResolverIW5.h"
+
+#include "Game/IW5/GameAssetPoolIW5.h"
+#include "Utils/StringUtils.h"
+
+using namespace IW5;
+
+AssetNameResolver::AssetNameResolver()
+{
+    for (auto assetType = 0; assetType < ASSET_TYPE_COUNT; assetType++)
+        AddAssetTypeName(assetType, *GameAssetPoolIW5::AssetTypeNameByType(assetType));
+}
+
+GameId AssetNameResolver::GetGameId() const
+{
+    return GameId::IW5;
+}
+
+std::optional<const char*> AssetNameResolver::GetAssetTypeName(const asset_type_t assetType) const
+{
+    return GameAssetPoolIW5::AssetTypeNameByType(assetType);
+}

src/ZoneCommon/Game/IW5/AssetNameResolverIW5.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "Zone/AssetNameResolver.h"
+
+namespace IW5
+{
+    class AssetNameResolver final : public HashMapBasedAssetNameResolver
+    {
+    public:
+        AssetNameResolver();
+        [[nodiscard]] GameId GetGameId() const override;
+        [[nodiscard]] std::optional<const char*> GetAssetTypeName(asset_type_t assetType) const override;
+    };
+} // namespace IW5

src/ZoneCommon/Game/IW5/GameAssetPoolIW5.cpp

@@ -316,15 +316,15 @@ XAssetInfoGeneric* GameAssetPoolIW5::GetAsset(const asset_type_t type, const std
 #undef CASE_GET_ASSET
 }
 
-const char* GameAssetPoolIW5::AssetTypeNameByType(const asset_type_t assetType)
+std::optional<const char*> GameAssetPoolIW5::AssetTypeNameByType(const asset_type_t assetType)
 {
     if (assetType >= 0 && assetType < static_cast<int>(std::extent_v<decltype(ASSET_TYPE_NAMES)>))
         return ASSET_TYPE_NAMES[assetType];
 
-    return ASSET_TYPE_INVALID;
+    return std::nullopt;
 }
 
-const char* GameAssetPoolIW5::GetAssetTypeName(const asset_type_t assetType) const
+std::optional<const char*> GameAssetPoolIW5::GetAssetTypeName(const asset_type_t assetType) const
 {
     return AssetTypeNameByType(assetType);
 }

src/ZoneCommon/Game/IW5/GameAssetPoolIW5.h

@@ -66,8 +66,8 @@ public:
 
     _NODISCARD XAssetInfoGeneric* GetAsset(asset_type_t type, const std::string& name) const override;
 
-    static const char* AssetTypeNameByType(asset_type_t assetType);
-    _NODISCARD const char* GetAssetTypeName(asset_type_t assetType) const override;
+    static std::optional<const char*> AssetTypeNameByType(asset_type_t assetType);
+    _NODISCARD std::optional<const char*> GetAssetTypeName(asset_type_t assetType) const override;
 
     static asset_type_t AssetTypeCount();
     _NODISCARD asset_type_t GetAssetTypeCount() const override;

src/ZoneCommon/Game/T5/AssetNameResolverT5.cpp

@@ -0,0 +1,22 @@
+#include "AssetNameResolverT5.h"
+
+#include "Game/T5/GameAssetPoolT5.h"
+#include "Utils/StringUtils.h"
+
+using namespace T5;
+
+AssetNameResolver::AssetNameResolver()
+{
+    for (auto assetType = 0; assetType < ASSET_TYPE_COUNT; assetType++)
+        AddAssetTypeName(assetType, *GameAssetPoolT5::AssetTypeNameByType(assetType));
+}
+
+GameId AssetNameResolver::GetGameId() const
+{
+    return GameId::T5;
+}
+
+std::optional<const char*> AssetNameResolver::GetAssetTypeName(const asset_type_t assetType) const
+{
+    return GameAssetPoolT5::AssetTypeNameByType(assetType);
+}

src/ZoneCommon/Game/T5/AssetNameResolverT5.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "Zone/AssetNameResolver.h"
+
+namespace T5
+{
+    class AssetNameResolver final : public HashMapBasedAssetNameResolver
+    {
+    public:
+        AssetNameResolver();
+        [[nodiscard]] GameId GetGameId() const override;
+        [[nodiscard]] std::optional<const char*> GetAssetTypeName(asset_type_t assetType) const override;
+    };
+} // namespace T5

src/ZoneCommon/Game/T5/GameAssetPoolT5.cpp

@@ -249,15 +249,15 @@ XAssetInfoGeneric* GameAssetPoolT5::GetAsset(const asset_type_t type, const std:
 #undef CASE_GET_ASSET
 }
 
-const char* GameAssetPoolT5::AssetTypeNameByType(const asset_type_t assetType)
+std::optional<const char*> GameAssetPoolT5::AssetTypeNameByType(const asset_type_t assetType)
 {
     if (assetType >= 0 && assetType < static_cast<int>(std::extent_v<decltype(ASSET_TYPE_NAMES)>))
         return ASSET_TYPE_NAMES[assetType];
 
-    return ASSET_TYPE_INVALID;
+    return std::nullopt;
 }
 
-const char* GameAssetPoolT5::GetAssetTypeName(const asset_type_t assetType) const
+std::optional<const char*> GameAssetPoolT5::GetAssetTypeName(const asset_type_t assetType) const
 {
     return AssetTypeNameByType(assetType);
 }

src/ZoneCommon/Game/T5/GameAssetPoolT5.h

@@ -58,8 +58,8 @@ public:
 
     _NODISCARD XAssetInfoGeneric* GetAsset(asset_type_t type, const std::string& name) const override;
 
-    static const char* AssetTypeNameByType(asset_type_t assetType);
-    _NODISCARD const char* GetAssetTypeName(asset_type_t assetType) const override;
+    static std::optional<const char*> AssetTypeNameByType(asset_type_t assetType);
+    _NODISCARD std::optional<const char*> GetAssetTypeName(asset_type_t assetType) const override;
 
     static asset_type_t AssetTypeCount();
     _NODISCARD asset_type_t GetAssetTypeCount() const override;

src/ZoneCommon/Game/T6/AssetNameResolverT6.cpp

@@ -0,0 +1,22 @@
+#include "AssetNameResolverT6.h"
+
+#include "Game/T6/GameAssetPoolT6.h"
+#include "Utils/StringUtils.h"
+
+using namespace T6;
+
+AssetNameResolver::AssetNameResolver()
+{
+    for (auto assetType = 0; assetType < ASSET_TYPE_COUNT; assetType++)
+        AddAssetTypeName(assetType, *GameAssetPoolT6::AssetTypeNameByType(assetType));
+}
+
+GameId AssetNameResolver::GetGameId() const
+{
+    return GameId::T6;
+}
+
+std::optional<const char*> AssetNameResolver::GetAssetTypeName(const asset_type_t assetType) const
+{
+    return GameAssetPoolT6::AssetTypeNameByType(assetType);
+}

src/ZoneCommon/Game/T6/AssetNameResolverT6.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "Zone/AssetNameResolver.h"
+
+namespace T6
+{
+    class AssetNameResolver final : public HashMapBasedAssetNameResolver
+    {
+    public:
+        AssetNameResolver();
+        [[nodiscard]] GameId GetGameId() const override;
+        [[nodiscard]] std::optional<const char*> GetAssetTypeName(asset_type_t assetType) const override;
+    };
+} // namespace T6

src/ZoneCommon/Game/T6/GameAssetPoolT6.cpp

@@ -366,15 +366,15 @@ XAssetInfoGeneric* GameAssetPoolT6::GetAsset(const asset_type_t type, const std:
 #undef CASE_GET_ASSET
 }
 
-const char* GameAssetPoolT6::AssetTypeNameByType(const asset_type_t assetType)
+std::optional<const char*> GameAssetPoolT6::AssetTypeNameByType(const asset_type_t assetType)
 {
     if (assetType >= 0 && assetType < static_cast<int>(std::extent_v<decltype(ASSET_TYPE_NAMES)>))
         return ASSET_TYPE_NAMES[assetType];
 
-    return ASSET_TYPE_INVALID;
+    return std::nullopt;
 }
 
-const char* GameAssetPoolT6::GetAssetTypeName(const asset_type_t assetType) const
+std::optional<const char*> GameAssetPoolT6::GetAssetTypeName(const asset_type_t assetType) const
 {
     return AssetTypeNameByType(assetType);
 }

src/ZoneCommon/Game/T6/GameAssetPoolT6.h

@@ -74,8 +74,8 @@ public:
 
     _NODISCARD XAssetInfoGeneric* GetAsset(asset_type_t type, const std::string& name) const override;
 
-    static const char* AssetTypeNameByType(asset_type_t assetType);
-    _NODISCARD const char* GetAssetTypeName(asset_type_t assetType) const override;
+    static std::optional<const char*> AssetTypeNameByType(asset_type_t assetType);
+    _NODISCARD std::optional<const char*> GetAssetTypeName(asset_type_t assetType) const override;
 
     static asset_type_t AssetTypeCount();
     _NODISCARD asset_type_t GetAssetTypeCount() const override;

src/ZoneCommon/Parsing/ZoneDefinition/Sequence/SequenceZoneDefinitionAssetList.cpp

@@ -13,7 +13,7 @@ SequenceZoneDefinitionAssetList::SequenceZoneDefinitionAssetList()
     });
 }
 
-void SequenceZoneDefinitionAssetList::ProcessMatch(ZoneDefinition* state, SequenceResult<ZoneDefinitionParserValue>& result) const
+void SequenceZoneDefinitionAssetList::ProcessMatch(ZoneDefinitionParserState* state, SequenceResult<ZoneDefinitionParserValue>& result) const
 {
-    state->m_asset_lists.emplace_back(result.NextCapture(CAPTURE_ASSET_LIST_NAME).FieldValue());
+    state->m_definition->m_asset_lists.emplace_back(result.NextCapture(CAPTURE_ASSET_LIST_NAME).FieldValue());
 }

src/ZoneCommon/Parsing/ZoneDefinition/Sequence/SequenceZoneDefinitionAssetList.h

@@ -7,7 +7,7 @@ class SequenceZoneDefinitionAssetList final : public ZoneDefinitionParser::seque
     static constexpr auto CAPTURE_ASSET_LIST_NAME = 1;
 
 protected:
-    void ProcessMatch(ZoneDefinition* state, SequenceResult<ZoneDefinitionParserValue>& result) const override;
+    void ProcessMatch(ZoneDefinitionParserState* state, SequenceResult<ZoneDefinitionParserValue>& result) const override;
 
 public:
     SequenceZoneDefinitionAssetList();

src/ZoneCommon/Parsing/ZoneDefinition/Sequence/SequenceZoneDefinitionBuild.cpp

@@ -13,7 +13,7 @@ SequenceZoneDefinitionBuild::SequenceZoneDefinitionBuild()
     });
 }
 
-void SequenceZoneDefinitionBuild::ProcessMatch(ZoneDefinition* state, SequenceResult<ZoneDefinitionParserValue>& result) const
+void SequenceZoneDefinitionBuild::ProcessMatch(ZoneDefinitionParserState* state, SequenceResult<ZoneDefinitionParserValue>& result) const
 {
-    state->m_targets_to_build.emplace_back(result.NextCapture(CAPTURE_BUILD_TARGET_NAME).FieldValue());
+    state->m_definition->m_targets_to_build.emplace_back(result.NextCapture(CAPTURE_BUILD_TARGET_NAME).FieldValue());
 }

src/ZoneCommon/Parsing/ZoneDefinition/Sequence/SequenceZoneDefinitionBuild.h

@@ -7,7 +7,7 @@ class SequenceZoneDefinitionBuild final : public ZoneDefinitionParser::sequence_
     static constexpr auto CAPTURE_BUILD_TARGET_NAME = 1;
 
 protected:
-    void ProcessMatch(ZoneDefinition* state, SequenceResult<ZoneDefinitionParserValue>& result) const override;
+    void ProcessMatch(ZoneDefinitionParserState* state, SequenceResult<ZoneDefinitionParserValue>& result) const override;
 
 public:
     SequenceZoneDefinitionBuild();

src/ZoneCommon/Parsing/ZoneDefinition/Sequence/SequenceZoneDefinitionEntry.cpp

@@ -19,19 +19,23 @@ SequenceZoneDefinitionEntry::SequenceZoneDefinitionEntry()
     });
 }
 
-void SequenceZoneDefinitionEntry::ProcessMatch(ZoneDefinition* state, SequenceResult<ZoneDefinitionParserValue>& result) const
+void SequenceZoneDefinitionEntry::ProcessMatch(ZoneDefinitionParserState* state, SequenceResult<ZoneDefinitionParserValue>& result) const
 {
-    const auto& assetNameCapture = result.NextCapture(CAPTURE_ASSET_NAME);
+    const auto& typeNameToken = result.NextCapture(CAPTURE_TYPE_NAME);
 
+    if (!state->m_asset_name_resolver)
+        throw ParsingException(typeNameToken.GetPos(), "Must define game before first asset");
+
+    const auto maybeAssetType = state->m_asset_name_resolver->GetAssetTypeByName(typeNameToken.FieldValue());
+    if (!maybeAssetType)
+        throw ParsingException(typeNameToken.GetPos(), "Unknown asset type");
+
+    const auto& assetNameToken = result.NextCapture(CAPTURE_ASSET_NAME);
     std::string assetName;
-    if (assetNameCapture.m_type == ZoneDefinitionParserValueType::STRING)
-    {
-        assetName = assetNameCapture.StringValue();
-    }
+    if (typeNameToken.m_type == ZoneDefinitionParserValueType::STRING)
+        assetName = typeNameToken.StringValue();
     else
-    {
-        assetName = assetNameCapture.FieldValue();
-    }
+        assetName = typeNameToken.FieldValue();
 
-    state->m_assets.emplace_back(result.NextCapture(CAPTURE_TYPE_NAME).FieldValue(), assetName, result.NextTag() == TAG_REFERENCE);
+    state->m_definition->m_assets.emplace_back(*maybeAssetType, assetName, result.NextTag() == TAG_REFERENCE);
 }

src/ZoneCommon/Parsing/ZoneDefinition/Sequence/SequenceZoneDefinitionEntry.h

@@ -10,7 +10,7 @@ class SequenceZoneDefinitionEntry final : public ZoneDefinitionParser::sequence_
     static constexpr auto CAPTURE_ASSET_NAME = 2;
 
 protected:
-    void ProcessMatch(ZoneDefinition* state, SequenceResult<ZoneDefinitionParserValue>& result) const override;
+    void ProcessMatch(ZoneDefinitionParserState* state, SequenceResult<ZoneDefinitionParserValue>& result) const override;
 
 public:
     SequenceZoneDefinitionEntry();

src/ZoneCommon/Parsing/ZoneDefinition/Sequence/SequenceZoneDefinitionIgnore.cpp

@@ -13,7 +13,7 @@ SequenceZoneDefinitionIgnore::SequenceZoneDefinitionIgnore()
     });
 }
 
-void SequenceZoneDefinitionIgnore::ProcessMatch(ZoneDefinition* state, SequenceResult<ZoneDefinitionParserValue>& result) const
+void SequenceZoneDefinitionIgnore::ProcessMatch(ZoneDefinitionParserState* state, SequenceResult<ZoneDefinitionParserValue>& result) const
 {
-    state->m_ignores.emplace_back(result.NextCapture(CAPTURE_IGNORE_NAME).FieldValue());
+    state->m_definition->m_ignores.emplace_back(result.NextCapture(CAPTURE_IGNORE_NAME).FieldValue());
 }

src/ZoneCommon/Parsing/ZoneDefinition/Sequence/SequenceZoneDefinitionIgnore.h

@@ -7,7 +7,7 @@ class SequenceZoneDefinitionIgnore final : public ZoneDefinitionParser::sequence
     static constexpr auto CAPTURE_IGNORE_NAME = 1;
 
 protected:
-    void ProcessMatch(ZoneDefinition* state, SequenceResult<ZoneDefinitionParserValue>& result) const override;
+    void ProcessMatch(ZoneDefinitionParserState* state, SequenceResult<ZoneDefinitionParserValue>& result) const override;
 
 public:
     SequenceZoneDefinitionIgnore();

src/ZoneCommon/Parsing/ZoneDefinition/Sequence/SequenceZoneDefinitionInclude.cpp

@@ -13,7 +13,7 @@ SequenceZoneDefinitionInclude::SequenceZoneDefinitionInclude()
     });
 }
 
-void SequenceZoneDefinitionInclude::ProcessMatch(ZoneDefinition* state, SequenceResult<ZoneDefinitionParserValue>& result) const
+void SequenceZoneDefinitionInclude::ProcessMatch(ZoneDefinitionParserState* state, SequenceResult<ZoneDefinitionParserValue>& result) const
 {
-    state->m_includes.emplace_back(result.NextCapture(CAPTURE_INCLUDE_NAME).FieldValue());
+    state->m_definition->m_includes.emplace_back(result.NextCapture(CAPTURE_INCLUDE_NAME).FieldValue());
 }

src/ZoneCommon/Parsing/ZoneDefinition/Sequence/SequenceZoneDefinitionInclude.h

@@ -7,7 +7,7 @@ class SequenceZoneDefinitionInclude final : public ZoneDefinitionParser::sequenc
     static constexpr auto CAPTURE_INCLUDE_NAME = 1;
 
 protected:
-    void ProcessMatch(ZoneDefinition* state, SequenceResult<ZoneDefinitionParserValue>& result) const override;
+    void ProcessMatch(ZoneDefinitionParserState* state, SequenceResult<ZoneDefinitionParserValue>& result) const override;
 
 public:
     SequenceZoneDefinitionInclude();

src/ZoneCommon/Parsing/ZoneDefinition/Sequence/SequenceZoneDefinitionMetaData.cpp

@@ -1,6 +1,51 @@
 #include "SequenceZoneDefinitionMetaData.h"
 
+#include "Game/IW3/AssetNameResolverIW3.h"
+#include "Game/IW4/AssetNameResolverIW4.h"
+#include "Game/IW5/AssetNameResolverIW5.h"
+#include "Game/T5/AssetNameResolverT5.h"
+#include "Game/T6/AssetNameResolverT6.h"
 #include "Parsing/ZoneDefinition/Matcher/ZoneDefinitionMatcherFactory.h"
+#include "Utils/StringUtils.h"
+
+#include <format>
+#include <optional>
+
+namespace
+{
+    constexpr auto METADATA_GAME = "game";
+    constexpr auto METADATA_GDT = "gdt";
+    constexpr auto METADATA_NAME = "name";
+    constexpr auto METADATA_TYPE = "type";
+
+    std::optional<GameId> GetGameByName(const std::string& gameName)
+    {
+        auto upperGameName = gameName;
+        utils::MakeStringUpperCase(upperGameName);
+
+        for (auto i = 0u; i < static_cast<unsigned>(GameId::COUNT); i++)
+        {
+            if (upperGameName == GameId_Names[i])
+                return static_cast<GameId>(i);
+        }
+
+        return std::nullopt;
+    }
+
+    std::optional<ProjectType> GetProjectTypeByName(const std::string& projectTypeName)
+    {
+        auto lowerProjectTypeName = projectTypeName;
+        utils::MakeStringLowerCase(lowerProjectTypeName);
+
+        for (auto i = 0u; i < static_cast<unsigned>(ProjectType::COUNT); i++)
+        {
+            if (lowerProjectTypeName == ProjectType_Names[i])
+                return static_cast<ProjectType>(i);
+        }
+
+        return std::nullopt;
+    }
+} // namespace
 
 SequenceZoneDefinitionMetaData::SequenceZoneDefinitionMetaData()
 {
@@ -14,7 +59,44 @@ SequenceZoneDefinitionMetaData::SequenceZoneDefinitionMetaData()
     });
 }
 
-void SequenceZoneDefinitionMetaData::ProcessMatch(ZoneDefinition* state, SequenceResult<ZoneDefinitionParserValue>& result) const
+void SequenceZoneDefinitionMetaData::ProcessMatch(ZoneDefinitionParserState* state, SequenceResult<ZoneDefinitionParserValue>& result) const
 {
-    state->AddMetaData(result.NextCapture(CAPTURE_KEY).FieldValue(), result.NextCapture(CAPTURE_VALUE).FieldValue());
+    const auto& keyToken = result.NextCapture(CAPTURE_KEY);
+    auto key = keyToken.FieldValue();
+    const auto& valueToken = result.NextCapture(CAPTURE_VALUE);
+    const auto& value = result.NextCapture(CAPTURE_VALUE).FieldValue();
+
+    utils::MakeStringLowerCase(key);
+
+    if (key == METADATA_GAME)
+    {
+        const auto game = GetGameByName(value);
+        if (!game)
+            throw ParsingException(valueToken.GetPos(), "Unknown game name");
+
+        const auto previousGame = state->m_definition->m_game;
+        if (previousGame != GameId::COUNT && previousGame != *game)
+            throw ParsingException(valueToken.GetPos(), std::format("Game was previously defined as: {}", GameId_Names[static_cast<unsigned>(previousGame)]));
+
+        state->m_definition->m_game = *game;
+        state->m_asset_name_resolver = IAssetNameResolver::GetResolverForGame(*game);
+    }
+    else if (key == METADATA_GDT)
+    {
+        state->m_definition->m_gdts.emplace_back(value);
+    }
+    else if (key == METADATA_NAME)
+    {
+        state->m_definition->m_name = value;
+    }
+    else if (key == METADATA_TYPE)
+    {
+        const auto projectType = GetProjectTypeByName(value);
+        if (!projectType)
+            throw ParsingException(valueToken.GetPos(), "Unknown project type name");
+    }
+    else
+    {
+        state->m_definition->m_properties.AddProperty(key, value);
+    }
 }

src/ZoneCommon/Parsing/ZoneDefinition/Sequence/SequenceZoneDefinitionMetaData.h

@@ -8,7 +8,7 @@ class SequenceZoneDefinitionMetaData final : public ZoneDefinitionParser::sequen
     static constexpr auto CAPTURE_VALUE = 2;
 
 protected:
-    void ProcessMatch(ZoneDefinition* state, SequenceResult<ZoneDefinitionParserValue>& result) const override;
+    void ProcessMatch(ZoneDefinitionParserState* state, SequenceResult<ZoneDefinitionParserValue>& result) const override;
 
 public:
     SequenceZoneDefinitionMetaData();

src/ZoneCommon/Parsing/ZoneDefinition/ZoneDefinitionParser.cpp

@@ -8,11 +8,11 @@
 #include "Sequence/SequenceZoneDefinitionMetaData.h"
 
 ZoneDefinitionParser::ZoneDefinitionParser(ZoneDefinitionLexer* lexer)
-    : AbstractParser(lexer, std::make_unique<ZoneDefinition>())
+    : AbstractParser(lexer, std::make_unique<ZoneDefinitionParserState>())
 {
 }
 
-const std::vector<AbstractParser<ZoneDefinitionParserValue, ZoneDefinition>::sequence_t*>& ZoneDefinitionParser::GetTestsForState()
+const std::vector<AbstractParser<ZoneDefinitionParserValue, ZoneDefinitionParserState>::sequence_t*>& ZoneDefinitionParser::GetTestsForState()
 {
     static std::vector<sequence_t*> tests({
         new SequenceZoneDefinitionMetaData(),
@@ -28,5 +28,5 @@ const std::vector<AbstractParser<ZoneDefinitionParserValue, ZoneDefinition>::seq
 
 std::unique_ptr<ZoneDefinition> ZoneDefinitionParser::GetParsedValue()
 {
-    return std::move(m_state);
+    return std::move(m_state->m_definition);
 }

src/ZoneCommon/Parsing/ZoneDefinition/ZoneDefinitionParser.h

@@ -3,9 +3,10 @@
 #include "Parsing/Impl/AbstractParser.h"
 #include "Zone/Definition/ZoneDefinition.h"
 #include "ZoneDefinitionLexer.h"
+#include "ZoneDefinitionParserState.h"
 #include "ZoneDefinitionParserValue.h"
 
-class ZoneDefinitionParser final : public AbstractParser<ZoneDefinitionParserValue, ZoneDefinition>
+class ZoneDefinitionParser final : public AbstractParser<ZoneDefinitionParserValue, ZoneDefinitionParserState>
 {
 protected:
     const std::vector<sequence_t*>& GetTestsForState() override;

src/ZoneCommon/Parsing/ZoneDefinition/ZoneDefinitionParserState.cpp

@@ -0,0 +1,7 @@
+#include "ZoneDefinitionParserState.h"
+
+ZoneDefinitionParserState::ZoneDefinitionParserState()
+    : m_asset_name_resolver(nullptr),
+      m_definition(std::make_unique<ZoneDefinition>())
+{
+}

src/ZoneCommon/Parsing/ZoneDefinition/ZoneDefinitionParserState.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include "Zone/AssetNameResolver.h"
+#include "Zone/Definition/ZoneDefinition.h"
+
+#include <memory>
+
+class ZoneDefinitionParserState
+{
+public:
+    ZoneDefinitionParserState();
+
+    const IAssetNameResolver* m_asset_name_resolver;
+    std::unique_ptr<ZoneDefinition> m_definition;
+};

src/ZoneCommon/Pool/ZoneAssetPools.h

@@ -6,6 +6,7 @@
 
 #include <cstddef>
 #include <memory>
+#include <optional>
 #include <string>
 #include <vector>
 
@@ -42,7 +43,7 @@ public:
     _NODISCARD virtual XAssetInfoGeneric* GetAssetOrAssetReference(asset_type_t type, const std::string& name) const;
 
     _NODISCARD virtual asset_type_t GetAssetTypeCount() const = 0;
-    _NODISCARD virtual const char* GetAssetTypeName(asset_type_t assetType) const = 0;
+    _NODISCARD virtual std::optional<const char*> GetAssetTypeName(asset_type_t assetType) const = 0;
 
     virtual void InitPoolStatic(asset_type_t type, size_t capacity) = 0;
     virtual void InitPoolDynamic(asset_type_t type) = 0;

src/ZoneCommon/Zone/AssetList/AssetList.cpp

@@ -1,12 +1,13 @@
 #include "AssetList.h"
 
 AssetListEntry::AssetListEntry()
-    : m_is_reference(false)
+    : m_type(0u),
+      m_is_reference(false)
 {
 }
 
-AssetListEntry::AssetListEntry(std::string type, std::string name, const bool isReference)
-    : m_type(std::move(type)),
+AssetListEntry::AssetListEntry(const asset_type_t type, std::string name, const bool isReference)
+    : m_type(type),
       m_name(std::move(name)),
       m_is_reference(isReference)
 {

src/ZoneCommon/Zone/AssetList/AssetList.h

@@ -1,16 +1,19 @@
 #pragma once
+
+#include "Zone/ZoneTypes.h"
+
 #include <string>
 #include <vector>
 
 class AssetListEntry
 {
 public:
-    std::string m_type;
+    asset_type_t m_type;
     std::string m_name;
     bool m_is_reference;
 
     AssetListEntry();
-    AssetListEntry(std::string type, std::string name, bool isReference);
+    AssetListEntry(asset_type_t type, std::string name, bool isReference);
 };
 
 class AssetList

src/ZoneCommon/Zone/AssetList/AssetListStream.cpp

@@ -1,13 +1,18 @@
 #include "AssetListStream.h"
 
-AssetListInputStream::AssetListInputStream(std::istream& stream)
-    : m_stream(stream)
+#include <format>
+
+AssetListInputStream::AssetListInputStream(std::istream& stream, const GameId game)
+    : m_stream(stream),
+      m_asset_name_resolver(IAssetNameResolver::GetResolverForGame(game))
 {
 }
 
-bool AssetListInputStream::NextEntry(AssetListEntry& entry) const
+bool AssetListInputStream::NextEntry(AssetListEntry& entry, bool* failure) const
 {
     std::vector<std::string> row;
+    if (failure)
+        *failure = false;
 
     while (true)
     {
@@ -17,7 +22,17 @@ bool AssetListInputStream::NextEntry(AssetListEntry& entry) const
         if (row.empty())
             continue;
 
-        entry.m_type = row[0];
+        const auto& typeName = row[0];
+        const auto maybeType = m_asset_name_resolver->GetAssetTypeByName(typeName);
+        if (!maybeType)
+        {
+            std::cerr << std::format("Unknown asset type name \"{}\"\n", typeName);
+            if (failure)
+                *failure = true;
+            return false;
+        }
+
+        entry.m_type = *maybeType;
         if (row.size() >= 3 && row[1].empty())
         {
             entry.m_name = row[2];
@@ -33,14 +48,15 @@ bool AssetListInputStream::NextEntry(AssetListEntry& entry) const
     }
 }
 
-AssetListOutputStream::AssetListOutputStream(std::ostream& stream)
-    : m_stream(stream)
+AssetListOutputStream::AssetListOutputStream(std::ostream& stream, const GameId game)
+    : m_stream(stream),
+      m_asset_name_resolver(IAssetNameResolver::GetResolverForGame(game))
 {
 }
 
 void AssetListOutputStream::WriteEntry(const AssetListEntry& entry)
 {
-    m_stream.WriteColumn(entry.m_type);
+    m_stream.WriteColumn(*m_asset_name_resolver->GetAssetTypeName(entry.m_type));
     m_stream.WriteColumn(entry.m_name);
     m_stream.NextRow();
 }

src/ZoneCommon/Zone/AssetList/AssetListStream.h

@@ -1,25 +1,31 @@
 #pragma once
 #include "AssetList.h"
 #include "Csv/CsvStream.h"
+#include "Game/IGame.h"
 
+#include <Zone/AssetNameResolver.h>
 #include <iostream>
 
 class AssetListInputStream
 {
-    CsvInputStream m_stream;
-
 public:
-    explicit AssetListInputStream(std::istream& stream);
+    AssetListInputStream(std::istream& stream, GameId game);
 
-    bool NextEntry(AssetListEntry& entry) const;
+    bool NextEntry(AssetListEntry& entry, bool* failure) const;
+
+private:
+    CsvInputStream m_stream;
+    const IAssetNameResolver* m_asset_name_resolver;
 };
 
 class AssetListOutputStream
 {
-    CsvOutputStream m_stream;
-
 public:
-    explicit AssetListOutputStream(std::ostream& stream);
+    AssetListOutputStream(std::ostream& stream, GameId game);
 
     void WriteEntry(const AssetListEntry& entry);
+
+private:
+    CsvOutputStream m_stream;
+    const IAssetNameResolver* m_asset_name_resolver;
 };

src/ZoneCommon/Zone/AssetNameResolver.cpp

@@ -0,0 +1,45 @@
+#include "AssetNameResolver.h"
+
+#include "Game/IW3/AssetNameResolverIW3.h"
+#include "Game/IW4/AssetNameResolverIW4.h"
+#include "Game/IW5/AssetNameResolverIW5.h"
+#include "Game/T5/AssetNameResolverT5.h"
+#include "Game/T6/AssetNameResolverT6.h"
+#include "Utils/StringUtils.h"
+
+#include <cassert>
+
+const IAssetNameResolver* IAssetNameResolver::GetResolverForGame(GameId game)
+{
+    static const IAssetNameResolver* assetNameResolvers[static_cast<unsigned>(GameId::COUNT)]{
+        new IW3::AssetNameResolver(),
+        new IW4::AssetNameResolver(),
+        new IW5::AssetNameResolver(),
+        new T5::AssetNameResolver(),
+        new T6::AssetNameResolver(),
+    };
+
+    assert(static_cast<unsigned>(game) < static_cast<unsigned>(GameId::COUNT));
+    const auto* result = assetNameResolvers[static_cast<unsigned>(game)];
+    assert(result);
+
+    return result;
+}
+
+void HashMapBasedAssetNameResolver::AddAssetTypeName(asset_type_t assetType, std::string name)
+{
+    utils::MakeStringLowerCase(name);
+    m_asset_types_by_name.emplace(std::move(name), assetType);
+}
+
+std::optional<asset_type_t> HashMapBasedAssetNameResolver::GetAssetTypeByName(const std::string& assetTypeName) const
+{
+    std::string lowerCaseName = assetTypeName;
+    utils::MakeStringLowerCase(lowerCaseName);
+
+    const auto existingAssetType = m_asset_types_by_name.find(assetTypeName);
+    if (existingAssetType != m_asset_types_by_name.end())
+        return existingAssetType->second;
+
+    return std::nullopt;
+}

src/ZoneCommon/Zone/AssetNameResolver.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include "Game/IGame.h"
+#include "Zone/ZoneTypes.h"
+
+#include <optional>
+#include <string>
+#include <unordered_map>
+
+class IAssetNameResolver
+{
+public:
+    IAssetNameResolver() = default;
+    virtual ~IAssetNameResolver() = default;
+    IAssetNameResolver(const IAssetNameResolver& other) = default;
+    IAssetNameResolver(IAssetNameResolver&& other) noexcept = default;
+    IAssetNameResolver& operator=(const IAssetNameResolver& other) = default;
+    IAssetNameResolver& operator=(IAssetNameResolver&& other) noexcept = default;
+
+    [[nodiscard]] virtual GameId GetGameId() const = 0;
+    [[nodiscard]] virtual std::optional<asset_type_t> GetAssetTypeByName(const std::string& assetTypeName) const = 0;
+    [[nodiscard]] virtual std::optional<const char*> GetAssetTypeName(asset_type_t assetType) const = 0;
+
+    static const IAssetNameResolver* GetResolverForGame(GameId game);
+};
+
+class HashMapBasedAssetNameResolver : public IAssetNameResolver
+{
+public:
+    [[nodiscard]] std::optional<asset_type_t> GetAssetTypeByName(const std::string& assetTypeName) const override;
+
+protected:
+    void AddAssetTypeName(asset_type_t assetType, std::string name);
+
+private:
+    std::unordered_map<std::string, asset_type_t> m_asset_types_by_name;
+};

src/ZoneCommon/Zone/Definition/ZoneDefinition.cpp

@@ -1,55 +1,44 @@
 #include "ZoneDefinition.h"
 
-ZoneDefinitionEntry::ZoneDefinitionEntry()
-    : m_is_reference(false)
-{
-}
-
-ZoneDefinitionEntry::ZoneDefinitionEntry(std::string type, std::string name, const bool isReference)
-    : m_asset_type(std::move(type)),
+ZoneDefinitionAsset::ZoneDefinitionAsset(const asset_type_t type, std::string name, const bool isReference)
+    : m_asset_type(type),
       m_asset_name(std::move(name)),
       m_is_reference(isReference)
 {
 }
 
-ZoneMetaDataEntry::ZoneMetaDataEntry() = default;
+ZoneDefinitionProperties::ZoneDefinitionProperties() = default;
 
-ZoneMetaDataEntry::ZoneMetaDataEntry(std::string key, std::string value)
-    : m_key(std::move(key)),
-      m_value(std::move(value))
+void ZoneDefinitionProperties::AddProperty(std::string key, std::string value)
 {
+    m_properties.emplace(std::move(key), std::move(value));
 }
 
-void ZoneDefinition::AddMetaData(std::string key, std::string value)
+void ZoneDefinitionProperties::Include(const ZoneDefinitionProperties& otherProperties)
+{
+    for (const auto& property : otherProperties.m_properties)
+        AddProperty(property.first, property.second);
+}
+
+ZoneDefinition::ZoneDefinition()
+    : m_type(ProjectType::NONE),
+      m_game(GameId::COUNT)
 {
-    auto metaData = std::make_unique<ZoneMetaDataEntry>(std::move(key), std::move(value));
-    auto* metaDataPtr = metaData.get();
-    m_metadata.emplace_back(std::move(metaData));
-    m_metadata_lookup.emplace(std::make_pair(metaDataPtr->m_key, metaDataPtr));
 }
 
 void ZoneDefinition::Include(const AssetList& assetListToInclude)
 {
     for (const auto& entry : assetListToInclude.m_entries)
-    {
         m_assets.emplace_back(entry.m_type, entry.m_name, false);
-    }
 }
 
 void ZoneDefinition::Include(const ZoneDefinition& definitionToInclude)
 {
-    for (const auto& metaData : definitionToInclude.m_metadata)
-    {
-        AddMetaData(metaData->m_key, metaData->m_value);
-    }
+    m_properties.Include(definitionToInclude.m_properties);
 
     for (const auto& ignore : definitionToInclude.m_ignores)
-    {
         m_ignores.emplace_back(ignore);
-    }
 
     for (const auto& asset : definitionToInclude.m_assets)
-    {
         m_assets.emplace_back(asset);
-    }
 }

src/ZoneCommon/Zone/Definition/ZoneDefinition.h

@@ -1,46 +1,66 @@
 #pragma once
 
+#include "Game/IGame.h"
 #include "Zone/AssetList/AssetList.h"
+#include "Zone/ZoneTypes.h"
 
-#include <memory>
 #include <string>
 #include <unordered_map>
 #include <vector>
 
-class ZoneDefinitionEntry
+enum class ProjectType
 {
-public:
-    std::string m_asset_type;
-    std::string m_asset_name;
-    bool m_is_reference;
+    NONE,
+    FASTFILE,
+    IPAK,
 
-    ZoneDefinitionEntry();
-    ZoneDefinitionEntry(std::string type, std::string name, bool isReference);
+    COUNT
 };
 
-class ZoneMetaDataEntry
+static constexpr const char* ProjectType_Names[]{
+    "none",
+    "fastfile",
+    "ipak",
+};
+static_assert(std::extent_v<decltype(ProjectType_Names)> == static_cast<unsigned>(ProjectType::COUNT));
+
+class ZoneDefinitionAsset
 {
 public:
-    std::string m_key;
-    std::string m_value;
+    ZoneDefinitionAsset(asset_type_t type, std::string name, bool isReference);
 
-    ZoneMetaDataEntry();
-    ZoneMetaDataEntry(std::string key, std::string value);
+    asset_type_t m_asset_type;
+    std::string m_asset_name;
+    bool m_is_reference;
+};
+
+class ZoneDefinitionProperties
+{
+public:
+    ZoneDefinitionProperties();
+
+    void AddProperty(std::string key, std::string value);
+    void Include(const ZoneDefinitionProperties& otherProperties);
+
+    std::unordered_map<std::string, std::string> m_properties;
 };
 
 class ZoneDefinition
 {
 public:
+    ZoneDefinition();
+
+    void Include(const AssetList& assetListToInclude);
+    void Include(const ZoneDefinition& definitionToInclude);
+
     std::string m_name;
-    std::vector<std::unique_ptr<ZoneMetaDataEntry>> m_metadata;
-    std::unordered_multimap<std::string, ZoneMetaDataEntry*> m_metadata_lookup;
+    ProjectType m_type;
+    GameId m_game;
+    ZoneDefinitionProperties m_properties;
     std::vector<std::string> m_includes;
     std::vector<std::string> m_asset_lists;
     std::vector<std::string> m_ignores;
     std::vector<std::string> m_targets_to_build;
-    std::vector<ZoneDefinitionEntry> m_assets;
-
-    void AddMetaData(std::string key, std::string value);
-    void Include(const AssetList& assetListToInclude);
-    void Include(const ZoneDefinition& definitionToInclude);
+    std::vector<std::string> m_gdts;
+    std::vector<ZoneDefinitionAsset> m_assets;
 };