Я пересоздал репозиторий из-за большого количества мусора в прошлом

Core/Game/SaveMap/ISave.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <memory>
+
+class SaveMap;
+
+class ISave
+{
+public:
+    virtual ~ISave() = default;
+    virtual std::shared_ptr<SaveMap> save() = 0;
+    virtual void load(std::shared_ptr<SaveMap> save) = 0;
+};

Core/Game/SaveMap/SaveMap.cpp

@@ -0,0 +1,587 @@
+#include "SaveMap.h"
+
+#include <cstring>
+#include <filesystem>
+#include <stdexcept>
+#include "Game/ObjectFactory.h"
+
+extern std::vector<ObjectFactory> factories;
+extern std::vector<ObjectFactory> base_object_factories;
+
+ISave* SaveMap::MakeObjectByName(const std::string& name)
+{
+    for (ObjectFactory& factory : base_object_factories)
+    {
+        if (name == factory.name) {
+            return factory.factory();
+        }
+    }
+    for (ObjectFactory& factory : factories)
+    {
+        if (name == factory.name) {
+            return factory.factory();
+        }
+    }
+    throw std::runtime_error("Object not found");
+}
+
+SaveMap::SaveMap(const char* class_name) : class_name(class_name)
+{
+    if (class_name == nullptr)
+        throw std::runtime_error("Can't create save map with null name");
+}
+
+SaveMap::SaveMap(const std::string& json_data)
+{
+    for (size_t i = 0; i < json_data.length() - 1;)
+    {
+        size_t key_begin = i = json_data.find_first_of('\"', i) + 1;
+        size_t key_end = i = json_data.find_first_of('\"', i);
+
+        std::string name = json_data.substr(key_begin, key_end - key_begin);
+
+        if (class_name.empty())
+        {
+            size_t begin = json_data.find(':', i) + 2;
+            size_t end = i = json_data.find('\"', begin);
+            i++;
+            class_name = json_data.substr(begin, end - begin);
+            continue;
+        }
+        
+        if (name[0] == 'i') {
+            size_t begin = json_data.find(':', i) + 1;
+            size_t end = i = json_data.find_first_of(",}", i);
+            i++;
+            std::string value = json_data.substr(begin, end - begin);
+            save_long[name.c_str() + 1] = std::stoll(value);
+        } else if (name[0] == 'd')
+        {
+            size_t begin = json_data.find(':', i) + 1;
+            size_t end = i = json_data.find_first_of(",}", i);
+            i++;
+            std::string value = json_data.substr(begin, end - begin);
+            save_double[name.c_str() + 1] = std::stod(value);
+        } else if (name[0] == 's')
+        {
+            size_t begin = json_data.find(':', i) + 2;
+            size_t end = i = json_data.find('\"', begin);
+            i++;
+            std::string value = json_data.substr(begin, end - begin);
+            save_string[name.c_str() + 1] = value;
+        } else if (name[0] == 'o')
+        {
+            size_t begin = i = json_data.find('{', i);
+            int open = 1, close = 0;
+            while (close < open)
+            {
+                i++;
+                if (json_data[i] == '{')
+                    open++;
+                else if (json_data[i] == '}')
+                    close++;
+            }
+
+            size_t end = i;
+            i++;
+
+            std::string object_json = json_data.substr(begin, end - begin + 1);
+            
+            begin = object_json.find(':') + 2;
+            end = object_json.find('\"', begin);
+            
+            std::string object_name = object_json.substr(begin, end - begin);
+            ISave* object_ptr = MakeObjectByName(object_name);
+
+            object_ptr->load(std::make_shared<SaveMap>(object_json));
+            save_objects[name.c_str() + 1] = object_ptr;
+        } else if (name[0] == 'v')
+        {
+            std::string key = name.substr(2, name.length() - 2);
+
+            size_t begin_arr = i = json_data.find('[', i);
+            int open = 1, close = 0;
+            while (close < open)
+            {
+                i++;
+                if (json_data[i] == '[')
+                    open++;
+                else if (json_data[i] == ']')
+                    close++;
+            }
+            size_t end_arr = i;
+            i++;
+
+            std::string arr_data = json_data.substr(begin_arr, end_arr - begin_arr + 1);
+            if (name[1] == 'i')
+            {
+                save_vector_integer[key] = std::vector<long long>();
+                if (arr_data.length() == 2)
+                    continue;
+                std::vector<long long>& vector_integer = save_vector_integer[key];
+
+                size_t j = 1;
+                while (j < arr_data.length())
+                {
+                    size_t end_val = arr_data.find_first_of(",]", j);
+                    vector_integer.push_back(std::stoll(arr_data.substr(j, end_val - j)));
+                    j = end_val + 1;
+                }
+            } else if (name[1] == 'd')
+            {
+                save_vector_double[key] = std::vector<double>();
+                if (arr_data.length() == 2)
+                    continue;
+                std::vector<double>& vector_double = save_vector_double[key];
+
+                size_t j = 1;
+                while (j < arr_data.length())
+                {
+                    size_t end_val = arr_data.find_first_of(",]", j);
+                    vector_double.push_back(std::stod(arr_data.substr(j, end_val - j)));
+                    j = end_val + 1;
+                }
+            } else if (name[1] == 's')
+            {
+                save_vector_strings[key] = std::vector<std::string>();
+                if (arr_data.length() == 2)
+                    continue;
+                std::vector<std::string>& vector_strings = save_vector_strings[key];
+
+                size_t j = 2;
+                while (j < arr_data.length())
+                {
+                    size_t begin = j;
+                    size_t end = j = arr_data.find('\"', begin + 1);
+                    std::string value = arr_data.substr(begin, end - begin);
+                    vector_strings.push_back(value);
+                    j += 3;
+                }
+            } else if (name[1] == 'o')
+            {
+                save_vector_objects[key] = std::vector<ISave*>();
+                if (arr_data.length() == 2)
+                    continue;
+                std::vector<ISave*>& vector_object = save_vector_objects[key];
+
+                size_t j = 1;
+                while (j < arr_data.length())
+                {
+                    size_t beg_val = j;
+                    open = 1;
+                    close = 0;
+                    while (close < open)
+                    {
+                        j++;
+                        if (arr_data[j] == '{')
+                            open++;
+                        else if (arr_data[j] == '}')
+                            close++;
+                    }
+                    size_t end_val = j;
+                    j++;
+                    std::string object_json = arr_data.substr(beg_val, end_val - beg_val + 1);
+            
+                    size_t begin_name = object_json.find(':') + 2;
+                    size_t end_name = object_json.find('\"', begin_name);
+            
+                    std::string object_name = object_json.substr(begin_name, end_name - begin_name);
+                    ISave* object_ptr = MakeObjectByName(object_name);
+
+                    object_ptr->load(std::make_shared<SaveMap>(object_json));
+                    vector_object.push_back(object_ptr);
+
+                    j = arr_data.find_first_of(",]", j) + 1;
+                }
+            }
+        }
+        else if (name[0] == 'l')
+        {
+            std::string key = name.substr(2, name.length() - 2);
+
+            size_t begin_arr = i = json_data.find('[', i);
+            int open = 1, close = 0;
+            while (close < open)
+            {
+                i++;
+                if (json_data[i] == '[')
+                    open++;
+                else if (json_data[i] == ']')
+                    close++;
+            }
+            size_t end_arr = i;
+            i++;
+
+            std::string arr_data = json_data.substr(begin_arr, end_arr - begin_arr + 1);
+            if (name[1] == 'i')
+            {
+                save_list_integer[key] = std::list<long long>();
+                if (arr_data.length() == 2)
+                    continue;
+                std::list<long long>& list_integer = save_list_integer[key];
+
+                size_t j = 1;
+                while (j < arr_data.length())
+                {
+                    size_t end_val = arr_data.find_first_of(",]", j);
+                    list_integer.push_back(std::stoll(arr_data.substr(j, end_val - j)));
+                    j = end_val + 1;
+                }
+            }
+            else if (name[1] == 'd')
+            {
+                save_list_double[key] = std::list<double>();
+                if (arr_data.length() == 2)
+                    continue;
+                std::list<double>& list_double = save_list_double[key];
+
+                size_t j = 1;
+                while (j < arr_data.length())
+                {
+                    size_t end_val = arr_data.find_first_of(",]", j);
+                    list_double.push_back(std::stod(arr_data.substr(j, end_val - j)));
+                    j = end_val + 1;
+                }
+            } else if (name[1] == 's')
+            {
+                save_list_strings[key] = std::list<std::string>();
+                if (arr_data.length() == 2)
+                    continue;
+                std::list<std::string>& list_strings = save_list_strings[key];
+
+                size_t j = 2;
+                while (j < arr_data.length())
+                {
+                    size_t begin = j;
+                    size_t end = j = arr_data.find('\"', begin + 1);
+                    std::string value = arr_data.substr(begin, end - begin);
+                    list_strings.push_back(value);
+                    j += 3;
+                }
+            } else if (name[1] == 'o')
+            {
+                save_list_objects[key] = std::list<ISave*>();
+                if (arr_data.length() == 2)
+                    continue;
+                std::list<ISave*>& list_object = save_list_objects[key];
+
+                size_t j = 1;
+                while (j < arr_data.length())
+                {
+                    size_t beg_val = j;
+                    open = 1;
+                    close = 0;
+                    while (close < open)
+                    {
+                        j++;
+                        if (arr_data[j] == '{')
+                            open++;
+                        else if (arr_data[j] == '}')
+                            close++;
+                    }
+                    size_t end_val = j;
+                    j++;
+                    std::string object_json = arr_data.substr(beg_val, end_val - beg_val + 1);
+
+                    size_t begin_name = object_json.find(':') + 2;
+                    size_t end_name = object_json.find('\"', begin_name);
+
+                    std::string object_name = object_json.substr(begin_name, end_name - begin_name);
+                    ISave* object_ptr = MakeObjectByName(object_name);
+   
+                    object_ptr->load(std::make_shared<SaveMap>(object_json));
+                    list_object.push_back(object_ptr);
+
+                    j = arr_data.find_first_of(",]", j) + 1;
+                }
+            }
+            }
+        else if (name == "Parent parameters") {
+            size_t parent_begin = i = json_data.find('{', i);
+            int open = 1, close = 0;
+            while (close < open)
+            {
+                i++;
+                if (json_data[i] == '{')
+                    open++;
+                else if (json_data[i] == '}')
+                    close++;
+            }
+
+            size_t parent_end = i;
+            i++;
+            
+            std::string str = json_data.substr(parent_begin, parent_end - parent_begin + 1);
+            parent = std::make_shared<SaveMap>(str);
+        }
+    }
+}
+
+std::shared_ptr<SaveMap> SaveMap::SaveInteger(const char* name, int value) noexcept
+{
+    save_long[name] = value;
+    return std::shared_ptr<SaveMap>(this);
+}
+
+std::shared_ptr<SaveMap> SaveMap::SaveDouble(const char* name, double value) noexcept
+{
+    save_double[name] = value;
+    return std::shared_ptr<SaveMap>(this);
+}
+
+std::shared_ptr<SaveMap> SaveMap::SaveString(const char* name, const std::string& value) noexcept
+{
+    save_string[name] = value;
+    return std::shared_ptr<SaveMap>(this);
+}
+
+std::shared_ptr<SaveMap> SaveMap::SaveObject(const char* name, ISave* object) noexcept
+{
+    save_objects[name] = object;
+    return std::shared_ptr<SaveMap>(this);
+}
+
+std::shared_ptr<SaveMap> SaveMap::SaveVectorInteger(const char* name, std::vector<long long>&& value) noexcept
+{
+    save_vector_integer[name] = std::move(value);
+    return std::shared_ptr<SaveMap>(this);
+}
+
+std::shared_ptr<SaveMap> SaveMap::SaveVectorDouble(const char* name, std::vector<double>&& value) noexcept
+{
+    save_vector_double[name] = std::move(value);
+    return std::shared_ptr<SaveMap>(this);
+}
+
+std::shared_ptr<SaveMap> SaveMap::SaveVectorStrings(const char* name, std::vector<std::string>&& value) noexcept
+{
+    save_vector_strings[name] = std::move(value);
+    return std::shared_ptr<SaveMap>(this);
+}
+
+std::shared_ptr<SaveMap> SaveMap::SaveVectorObject(const char* name, std::vector<ISave*>&& value) noexcept
+{
+    save_vector_objects[name] = std::move(value);
+    return std::shared_ptr<SaveMap>(this);
+}
+
+std::shared_ptr<SaveMap> SaveMap::SaveListInteger(const char* name, std::list<long long>&& value) noexcept
+{
+    save_list_integer[name] = std::move(value);
+    return std::shared_ptr<SaveMap>(this);
+}
+
+std::shared_ptr<SaveMap> SaveMap::SaveListDouble(const char* name, std::list<double>&& value) noexcept
+{
+    save_list_double[name] = std::move(value);
+    return std::shared_ptr<SaveMap>(this);
+}
+
+std::shared_ptr<SaveMap> SaveMap::SaveListStrings(const char* name, std::list<std::string>&& value) noexcept
+{
+    save_list_strings[name] = std::move(value);
+    return std::shared_ptr<SaveMap>(this);
+}
+
+std::shared_ptr<SaveMap> SaveMap::SaveListObject(const char* name, std::list<ISave*>&& value) noexcept
+{
+    save_list_objects[name] = std::move(value);
+    return std::shared_ptr<SaveMap>(this);
+}
+
+long long SaveMap::GetInteger(const char* name)
+{
+    return save_long[name];
+}
+
+double SaveMap::GetDouble(const char* name)
+{
+    return save_double[name];
+}
+
+const char* SaveMap::GetString(const char* name)
+{
+    return save_string[name].c_str();
+}
+
+ISave* SaveMap::GetObject(const char* name)
+{
+    return save_objects[name];
+}
+
+std::vector<long long>& SaveMap::GetVectorInteger(const char* name)
+{
+    return save_vector_integer[name];
+}
+
+std::vector<double>& SaveMap::GetVectorDouble(const char* name)
+{
+    return save_vector_double[name];
+}
+
+std::vector<std::string> SaveMap::GetVectorString(const char* name)
+{
+    return save_vector_strings[name];
+}
+
+std::vector<ISave*>& SaveMap::GetVectorObject(const char* name)
+{
+    return save_vector_objects[name];
+}
+
+std::list<long long>& SaveMap::GetListInteger(const char* name)
+{
+    return save_list_integer[name];
+}
+
+std::list<double>& SaveMap::GetListDouble(const char* name)
+{
+    return save_list_double[name];
+}
+
+std::list<std::string>& SaveMap::GetListString(const char* name)
+{
+    return save_list_strings[name];
+}
+
+std::list<ISave*>& SaveMap::GetListObject(const char* name)
+{
+    return save_list_objects[name];
+}
+
+std::string SaveMap::serialize() noexcept
+{
+    std::string buffer = R"({"Class name":")" + class_name + '\"';
+
+    for (auto& [key, value] : save_long)
+        buffer += ",\"i" + key + "\":" + std::to_string(value);
+
+    for (auto& [key, value] : save_double)
+        buffer += ",\"d" + key + "\":" + std::to_string(value);
+
+    for (auto& [key, value] : save_string)
+        buffer += ",\"s" + key + "\":\"" + value + '\"';
+
+    for (auto& [key, value] : save_objects)
+        buffer += ",\"o" + key + "\":\"" + value->save()->serialize();
+
+    for (auto& [key, value] : save_vector_integer)
+    {
+        if (value.empty())
+        {
+            buffer += ",\"vi" + key + "\":[]";
+            continue;       
+        }
+        buffer += ",\"vi" + key + "\":[";
+        for (auto& item : value)
+            buffer += std::to_string(item) + ',';
+        buffer.replace(buffer.length() - 1, buffer.length() - 1, "]");
+    }
+
+    for (auto& [key, value] : save_vector_double)
+    {
+        if (value.empty())
+        {
+            buffer += ",\"vd" + key + "\":[]";
+            continue;       
+        }
+        buffer += ",\"vd" + key + "\":[";
+        for (auto& item : value)
+            buffer += std::to_string(item) + ',';
+        buffer.replace(buffer.length() - 1, buffer.length() - 1, "]");
+    }
+
+    for (auto& [key, value] : save_vector_objects)
+    {
+        if (value.empty())
+        {
+            buffer += ",\"vo" + key + "\":[]";
+            continue;       
+        }
+        buffer += ",\"vo" + key + "\":[";
+        for (auto& item : value)
+            buffer += item->save()->serialize() + ',';
+        buffer.replace(buffer.length() - 1, buffer.length() - 1, "]");
+    }
+
+    for (auto& [key, value] : save_vector_strings)
+    {
+        if (value.empty())
+        {
+            buffer += ",\"vs" + key + "\":[]";
+            continue;       
+        }
+        buffer += ",\"vs" + key + "\":[";
+        for (auto& item : value)
+            buffer += '\"' + item + "\",";
+        buffer.replace(buffer.length() - 1, buffer.length() - 1, "]");
+    }
+
+    for (auto& [key, value] : save_list_integer)
+    {
+        if (value.empty())
+        {
+            buffer += ",\"li" + key + "\":[]";
+            continue;       
+        }
+        buffer += ",\"li" + key + "\":[";
+        for (auto& item : value)
+            buffer += std::to_string(item) + ',';
+        buffer.replace(buffer.length() - 1, buffer.length() - 1, "]");
+    }
+
+    for (auto& [key, value] : save_list_double)
+    {
+        if (value.empty())
+        {
+            buffer += ",\"ld" + key + "\":[]";
+            continue;       
+        }
+        buffer += ",\"ld" + key + "\":[";
+        for (auto& item : value)
+            buffer += std::to_string(item) + ',';
+        buffer.replace(buffer.length() - 1, buffer.length() - 1, "]");
+    }
+
+    for (auto& [key, value] : save_list_objects)
+    {
+        if (value.empty())
+        {
+            buffer += ",\"lo" + key + "\":[]";
+            continue;       
+        }
+        buffer += ",\"lo" + key + "\":[";
+        for (auto& item : value)
+            buffer += item->save()->serialize() + ',';
+        buffer.replace(buffer.length() - 1, buffer.length() - 1, "]");
+    }
+
+    for (auto& [key, value] : save_list_strings)
+    {
+        if (value.empty())
+        {
+            buffer += ",\"ls" + key + "\":[]";
+            continue;       
+        }
+        buffer += ",\"ls" + key + "\":[";
+        for (auto& item : value)
+            buffer += '\"' + item + "\",";
+        buffer.replace(buffer.length() - 1, buffer.length() - 1, "]");
+    }
+
+    if (parent != nullptr) {
+        buffer += ",\"Parent parameters\":" + parent->serialize() + '}';
+    } else
+        buffer += '}';
+    
+    return buffer;
+}
+
+SaveMap* SaveMap::connect_to(std::shared_ptr<SaveMap> parent)
+{
+    if (this->parent != nullptr)
+        throw std::runtime_error("Can't connect to second parent");
+    
+    this->parent = parent;
+    return this;
+}

Core/Game/SaveMap/SaveMap.h

@@ -0,0 +1,77 @@
+#pragma once
+
+#include "ISave.h"
+
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+#include <list>
+
+class SaveMap final
+{
+    std::string class_name;
+    std::shared_ptr<SaveMap> parent;
+
+    // Индивидуальные значения
+    std::map<std::string, long long> save_long;
+    std::map<std::string, double> save_double;
+    std::map<std::string, std::string> save_string;
+    std::map<std::string, ISave*> save_objects;
+    
+    // Массивы
+    std::map<std::string, std::vector<long long>> save_vector_integer;
+    std::map<std::string, std::vector<double>> save_vector_double;
+    std::map<std::string, std::vector<ISave*>> save_vector_objects;
+    std::map<std::string, std::vector<std::string>> save_vector_strings;
+
+    // Связаные списки
+    std::map<std::string, std::list<long long>> save_list_integer;
+    std::map<std::string, std::list<double>> save_list_double;
+    std::map<std::string, std::list<ISave*>> save_list_objects;
+    std::map<std::string, std::list<std::string>> save_list_strings;
+
+    static ISave* MakeObjectByName(const std::string& name);
+
+public:
+    // Создаёт пустой объект для заполнения
+    SaveMap(const char* class_name);
+    // Токенезирут JSON строку
+    SaveMap(const std::string& json_data);
+
+    // Методы созранения значений
+    std::shared_ptr<SaveMap> SaveInteger(const char* name, int value) noexcept;
+    std::shared_ptr<SaveMap> SaveDouble(const char* name, double value) noexcept;
+    std::shared_ptr<SaveMap> SaveString(const char* name, const std::string& value) noexcept;
+    std::shared_ptr<SaveMap> SaveObject(const char* name, ISave* object) noexcept;
+    std::shared_ptr<SaveMap> SaveVectorInteger(const char* name, std::vector<long long>&& value) noexcept;
+    std::shared_ptr<SaveMap> SaveVectorDouble(const char* name, std::vector<double>&& value) noexcept;
+    std::shared_ptr<SaveMap> SaveVectorStrings(const char* name, std::vector<std::string>&& value) noexcept;
+    std::shared_ptr<SaveMap> SaveVectorObject(const char* name, std::vector<ISave*>&& value) noexcept;
+    std::shared_ptr<SaveMap> SaveListInteger(const char* name, std::list<long long>&& value) noexcept;
+    std::shared_ptr<SaveMap> SaveListDouble(const char* name, std::list<double>&& value) noexcept;
+    std::shared_ptr<SaveMap> SaveListStrings(const char* name, std::list<std::string>&& value) noexcept;
+    std::shared_ptr<SaveMap> SaveListObject(const char* name, std::list<ISave*>&& value) noexcept;
+
+    // Методы получения значенй
+    long long GetInteger(const char* name);
+    double GetDouble(const char* name);
+    const char* GetString(const char* name);
+    ISave* GetObject(const char* name);
+    std::vector<long long>& GetVectorInteger(const char* name);
+    std::vector<double>& GetVectorDouble(const char* name);
+    std::vector<std::string> GetVectorString(const char* name);
+    std::vector<ISave*>& GetVectorObject(const char* name);
+    std::list<long long>& GetListInteger(const char* name);
+    std::list<double>& GetListDouble(const char* name);
+    std::list<std::string>& GetListString(const char* name);
+    std::list<ISave*>& GetListObject(const char* name);
+    
+    std::shared_ptr<SaveMap> getParent() const { return parent; }
+    const std::string& getClassName() const { return class_name; }
+
+    // Собирает все токены в JSON объект
+    std::string serialize() noexcept;
+
+    SaveMap* connect_to(std::shared_ptr<SaveMap> parent);
+};