print packet variant type vector2

ZTzTopia · Feb 24, 2024 · ac245d1 · ac245d1
1 parent bafcf9a
commit ac245d1
Show file tree

Hide file tree

Showing 3 changed files with 51 additions and 18 deletions.
diff --git a/.gitignore b/.gitignore
@@ -7,6 +7,7 @@
 /build
 /cmake-build-debug
 /cmake-build-release
+/cmake-build-relwithdebinfo
 /out
 
 # Ignore CMake user preset files

diff --git a/src/extension/parser/parser_impl.hpp b/src/extension/parser/parser_impl.hpp
@@ -69,17 +69,37 @@ class ParserExtension final : public IParserExtension {
                 case packet::VariantType::FLOAT:
                     spdlog::info("\t[FLOAT]: {}", std::get<float>(var));
                     break;
-                case packet::VariantType::STRING:
+                case packet::VariantType::STRING: {
+                    TextParse text_parse{ std::get<std::string>(var) };
+                    if (!text_parse.empty()) {
+                        std::vector key_values{ text_parse.get_key_values() };
+                        if (key_values.size() == 1) {
+                            spdlog::info("\t[STRING]: {}", key_values[0]);
+                            break;
+                        }
+
+                        spdlog::info("\t[STRING]:");
+                        for (const auto& key_value : text_parse.get_key_values()) {
+                            spdlog::info("\t\t{}", key_value);
+                        }
+
+                        break;
+                    }
+
                     spdlog::info("\t[STRING]: {}", std::get<std::string>(var));
                     break;
+                }
+                case packet::VariantType::VEC2:
+                    const glm::vec2 vec2{ std::get<glm::vec2>(var) };
+                    spdlog::info("\t[VEC2]: x: {}, y: {}", vec2.x, vec2.y);
+                    break;
                 case packet::VariantType::UNSIGNED:
                     spdlog::info("\t[UNSIGNED]: {}", std::get<uint32_t>(var));
                     break;
                 case packet::VariantType::SIGNED:
                     spdlog::info("\t[SIGNED]: {}", std::get<int32_t>(var));
                     break;
                 default:
-                    spdlog::warn("Unknown variant type");
                     break;
                 }
             }

diff --git a/src/utils/text_parse.hpp b/src/utils/text_parse.hpp
@@ -12,12 +12,21 @@ class TextParse {
     {
         for (const auto& line : tokenize(str, "\n")) {
             std::vector tokens{ tokenize(line, delimiter) };
+
+            if (tokens.empty()) {
+                continue;
+            }
+
+            if (tokens.size() == 1) {
+                continue;
+            }
+
             std::string key{ tokens.front() };
 
             tokens.erase(tokens.begin());
             tokens.shrink_to_fit();
 
-            m_data.emplace(key, tokens);
+            data_.emplace(key, tokens);
         }
     }
 
@@ -37,8 +46,8 @@ class TextParse {
 
     [[nodiscard]] std::string get(const std::string& key, const int index = 0) const
     {
-        const auto it{ m_data.find(key) };
-        if (it == m_data.end()) {
+        const auto it{ data_.find(key) };
+        if (it == data_.end()) {
             return {};
         }
 
@@ -75,38 +84,38 @@ class TextParse {
 
     void add(const std::string& key, const std::vector<std::string>& value)
     {
-        m_data.emplace(key, value);
+        data_.emplace(key, value);
     }
 
     void set(const std::string& key, const std::vector<std::string>& value)
     {
-        if (!m_data.contains(key)) {
+        if (!data_.contains(key)) {
             return;
         }
 
-        m_data[key] = value;
+        data_[key] = value;
     }
 
     void remove(const std::string& key)
     {
-        const auto it{ m_data.find(key) };
-        if (it == m_data.end()) {
+        const auto it{ data_.find(key) };
+        if (it == data_.end()) {
             return;
         }
 
-        m_data.erase(it);
+        data_.erase(it);
     }
 
     [[nodiscard]] std::string get_raw(const std::string& delimiter = "|", const std::string& prepend_text = "") const
     {
         std::string raw_data{};
-        for (auto it = m_data.cbegin(); it != m_data.cend(); ++it) {
+        for (auto it = data_.cbegin(); it != data_.cend(); ++it) {
             raw_data += prepend_text + it->first;
             for (const auto& token : it->second) {
                 raw_data += delimiter + token;
             }
 
-            if (std::next(it) != m_data.cend() && !std::next(it)->first.empty()) {
+            if (std::next(it) != data_.cend() && !std::next(it)->first.empty()) {
                 raw_data += '\n';
             }
         }
@@ -117,18 +126,21 @@ class TextParse {
     [[nodiscard]] std::vector<std::string> get_key_values(const std::string& delimiter = "|") const
     {
         std::vector<std::string> key_values{};
-        for (auto it = m_data.cbegin(); it != m_data.cend(); ++it) {
+        for (auto it = data_.cbegin(); it != data_.cend(); ++it) {
+            std::string key_value{ it->first };
             for (const auto& token : it->second) {
-                key_values.emplace_back(it->first + delimiter + token);
+                key_value += delimiter + token;
             }
+
+            key_values.emplace_back(key_value);
         }
 
         return key_values;
     }
 
-    [[nodiscard]] std::unordered_map<std::string, std::vector<std::string>> get_data() const { return m_data; }
-    [[nodiscard]] bool empty() const { return m_data.empty(); }
+    [[nodiscard]] std::unordered_map<std::string, std::vector<std::string>> get_data() const { return data_; }
+    [[nodiscard]] bool empty() const { return data_.empty(); }
 
 private:
-    std::unordered_map<std::string, std::vector<std::string>> m_data;
+    std::unordered_map<std::string, std::vector<std::string>> data_;
 };