chore: respect previously set game when including additional zone files

src/Linker/Linker.cpp

@@ -59,6 +59,7 @@ class LinkerImpl final : public Linker
                     }
 
                     ZoneDefinitionInputStream zoneDefinitionInputStream(*definitionStream.m_stream, definitionFileName, m_args.m_verbose);
+                    zoneDefinitionInputStream.SetPreviouslySetGame(zoneDefinition.m_game);
                     includeDefinition = zoneDefinitionInputStream.ReadDefinition();
                 }
 

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

@@ -1,10 +1,5 @@
 #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"
 
@@ -64,7 +59,7 @@ void SequenceZoneDefinitionMetaData::ProcessMatch(ZoneDefinitionParserState* sta
     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();
+    const auto& value = valueToken.FieldValue();
 
     utils::MakeStringLowerCase(key);
 
@@ -78,8 +73,7 @@ void SequenceZoneDefinitionMetaData::ProcessMatch(ZoneDefinitionParserState* sta
         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->SetGame(*game);
-        state->m_asset_name_resolver = IAssetNameResolver::GetResolverForGame(*game);
     }
     else if (key == METADATA_GDT)
     {

src/ZoneCommon/Parsing/ZoneDefinition/ZoneDefinitionParser.cpp

@@ -7,9 +7,11 @@
 #include "Sequence/SequenceZoneDefinitionInclude.h"
 #include "Sequence/SequenceZoneDefinitionMetaData.h"
 
-ZoneDefinitionParser::ZoneDefinitionParser(ZoneDefinitionLexer* lexer)
+ZoneDefinitionParser::ZoneDefinitionParser(ZoneDefinitionLexer* lexer, const std::optional<GameId> maybeGame)
     : AbstractParser(lexer, std::make_unique<ZoneDefinitionParserState>())
 {
+    if (maybeGame)
+        m_state->SetGame(*maybeGame);
 }
 
 const std::vector<AbstractParser<ZoneDefinitionParserValue, ZoneDefinitionParserState>::sequence_t*>& ZoneDefinitionParser::GetTestsForState()

src/ZoneCommon/Parsing/ZoneDefinition/ZoneDefinitionParser.h

@@ -1,17 +1,20 @@
 #pragma once
 
+#include "Game/IGame.h"
 #include "Parsing/Impl/AbstractParser.h"
 #include "Zone/Definition/ZoneDefinition.h"
 #include "ZoneDefinitionLexer.h"
 #include "ZoneDefinitionParserState.h"
 #include "ZoneDefinitionParserValue.h"
 
+#include <optional>
+
 class ZoneDefinitionParser final : public AbstractParser<ZoneDefinitionParserValue, ZoneDefinitionParserState>
 {
 protected:
     const std::vector<sequence_t*>& GetTestsForState() override;
 
 public:
-    explicit ZoneDefinitionParser(ZoneDefinitionLexer* lexer);
+    explicit ZoneDefinitionParser(ZoneDefinitionLexer* lexer, std::optional<GameId> maybeGame = std::nullopt);
     std::unique_ptr<ZoneDefinition> GetParsedValue();
 };

src/ZoneCommon/Parsing/ZoneDefinition/ZoneDefinitionParserState.cpp

@@ -5,3 +5,9 @@ ZoneDefinitionParserState::ZoneDefinitionParserState()
       m_definition(std::make_unique<ZoneDefinition>())
 {
 }
+
+void ZoneDefinitionParserState::SetGame(const GameId game)
+{
+    m_definition->m_game = game;
+    m_asset_name_resolver = IAssetNameResolver::GetResolverForGame(game);
+}

src/ZoneCommon/Parsing/ZoneDefinition/ZoneDefinitionParserState.h

@@ -10,6 +10,8 @@ class ZoneDefinitionParserState
 public:
     ZoneDefinitionParserState();
 
+    void SetGame(GameId game);
+
     const IAssetNameResolver* m_asset_name_resolver;
     std::unique_ptr<ZoneDefinition> m_definition;
 };

src/ZoneCommon/Zone/Definition/ZoneDefinitionStream.cpp

@@ -1,18 +1,19 @@
 #include "ZoneDefinitionStream.h"
 
+#include "Parsing/Impl/CommentRemovingStreamProxy.h"
 #include "Parsing/Impl/DefinesStreamProxy.h"
 #include "Parsing/Impl/ParserSingleInputStream.h"
-#include "Parsing/Simple/SimpleLexer.h"
 #include "Parsing/ZoneDefinition/ZoneDefinitionLexer.h"
 #include "Parsing/ZoneDefinition/ZoneDefinitionParser.h"
 
-#include <Parsing/Impl/CommentRemovingStreamProxy.h>
 #include <chrono>
+#include <format>
 
 ZoneDefinitionInputStream::ZoneDefinitionInputStream(std::istream& stream, std::string fileName, bool verbose)
     : m_file_name(std::move(fileName)),
       m_verbose(verbose),
-      m_stream(nullptr)
+      m_stream(nullptr),
+      m_previously_set_game(std::nullopt)
 {
     OpenBaseStream(stream);
     SetupStreamProxies();
@@ -29,21 +30,23 @@ void ZoneDefinitionInputStream::SetupStreamProxies()
 {
     m_open_streams.emplace_back(std::make_unique<CommentRemovingStreamProxy>(m_open_streams.back().get()));
     auto definesProxy = std::make_unique<DefinesStreamProxy>(m_open_streams.back().get());
-    definesProxy->AddDefine(DefinesStreamProxy::Define(ZONE_CODE_GENERATOR_DEFINE_NAME, ZONE_CODE_GENERATOR_DEFINE_VALUE));
     m_open_streams.emplace_back(std::move(definesProxy));
 
     m_stream = m_open_streams.back().get();
 }
 
+void ZoneDefinitionInputStream::SetPreviouslySetGame(GameId game)
+{
+    m_previously_set_game = game;
+}
+
 std::unique_ptr<ZoneDefinition> ZoneDefinitionInputStream::ReadDefinition()
 {
     if (m_verbose)
-    {
+        std::cout << std::format("Reading zone definition file: {}\n", m_file_name);
-        std::cout << "Reading zone definition file: " << m_file_name << "\n";
-    }
 
     const auto lexer = std::make_unique<ZoneDefinitionLexer>(m_stream);
-    const auto parser = std::make_unique<ZoneDefinitionParser>(lexer.get());
+    const auto parser = std::make_unique<ZoneDefinitionParser>(lexer.get(), m_previously_set_game);
 
     const auto start = std::chrono::steady_clock::now();
     std::unique_ptr<ZoneDefinition> definition;
@@ -52,9 +55,7 @@ std::unique_ptr<ZoneDefinition> ZoneDefinitionInputStream::ReadDefinition()
     const auto end = std::chrono::steady_clock::now();
 
     if (m_verbose)
-    {
+        std::cout << std::format("Processing zone definition took {}ms\n", std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count());
-        std::cout << "Processing zone definition took " << std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count() << "ms\n";
-    }
 
     return std::move(definition);
 }

src/ZoneCommon/Zone/Definition/ZoneDefinitionStream.h

@@ -1,33 +1,34 @@
 #pragma once
+
+#include "Game/IGame.h"
 #include "Parsing/IParserLineStream.h"
 #include "ZoneDefinition.h"
 
 #include <iostream>
 #include <memory>
+#include <optional>
 
 class ZoneDefinitionInputStream
 {
-    static constexpr const char* ZONE_CODE_GENERATOR_DEFINE_NAME = "__zonecodegenerator";
+public:
-    static constexpr const char* ZONE_CODE_GENERATOR_DEFINE_VALUE = "1";
+    ZoneDefinitionInputStream(std::istream& stream, std::string fileName, bool verbose);
+
+    void SetPreviouslySetGame(GameId game);
+    std::unique_ptr<ZoneDefinition> ReadDefinition();
+
+private:
+    bool OpenBaseStream(std::istream& stream);
+    void SetupStreamProxies();
 
     std::string m_file_name;
     bool m_verbose;
     IParserLineStream* m_stream;
     std::vector<std::unique_ptr<IParserLineStream>> m_open_streams;
-
+    std::optional<GameId> m_previously_set_game;
-    bool OpenBaseStream(std::istream& stream);
-    void SetupStreamProxies();
-
-public:
-    ZoneDefinitionInputStream(std::istream& stream, std::string fileName, bool verbose);
-
-    std::unique_ptr<ZoneDefinition> ReadDefinition();
 };
 
 class ZoneDefinitionOutputStream
 {
-    std::ostream& m_stream;
-
 public:
     explicit ZoneDefinitionOutputStream(std::ostream& stream);
 
@@ -35,4 +36,7 @@ public:
     void WriteComment(const std::string& comment) const;
     void WriteMetaData(const std::string& metaDataKey, const std::string& metaDataValue) const;
     void WriteEntry(const std::string& entryKey, const std::string& entryValue) const;
+
+private:
+    std::ostream& m_stream;
 };