resolve entity references

Author: Madour

include/LDtkLoader/DataTypes.hpp

@@ -111,11 +111,17 @@ namespace ldtk {
 
     bool operator==(const IID& lhs, const IID& rhs);
 
+    class Entity;
     struct EntityRef {
+        EntityRef(IID ent, IID  layer, IID level, IID world);
         IID entity_iid;
         IID layer_iid;
         IID level_iid;
         IID world_iid;
+        auto operator->() const -> const Entity*;
+    private:
+        friend class Project;
+        const Entity* ref = nullptr;
     };
 }
 

include/LDtkLoader/containers/FieldsContainer.hpp

@@ -46,9 +46,11 @@ namespace ldtk {
         void addArrayField(const std::string& name, const ArrayField<T>& field);
 
     private:
+        friend class Project;
         std::vector<std::unique_ptr<IField>> m_gc;
         std::unordered_map<std::string, IField*> m_fields;
         std::unordered_map<std::string, IField*> m_array_fields;
+        static std::vector<EntityRef*> tmp_entity_refs_vector;
     };
 
     template <FieldType T>

src/DataTypes.cpp

@@ -68,6 +68,17 @@ bool ldtk::operator==(const IID& lhs, const IID& rhs) {
     return lhs.str() == rhs.str();
 }
 
+EntityRef::EntityRef(IID ent, IID  layer, IID level, IID world) :
+entity_iid(std::move(ent)),
+layer_iid(std::move(layer)),
+level_iid(std::move(level)),
+world_iid(std::move(world))
+{}
+
+auto EntityRef::operator->() const -> const Entity* {
+    return ref;
+}
+
 auto operator<<(std::ostream& os, const ldtk::Color& col) -> std::ostream& {
     os << "rgb(" << (int)col.r << ", " << (int)col.g << ", " << (int)col.b << ")";
     return os;

src/FieldsContainer.cpp

@@ -5,6 +5,8 @@
 
 using namespace ldtk;
 
+std::vector<EntityRef*> FieldsContainer::tmp_entity_refs_vector;
+
 FieldsContainer::FieldsContainer(const nlohmann::json& j, const World* w) {
     parseFields(j, w);
 }
@@ -100,16 +102,24 @@ void FieldsContainer::parseFields(const nlohmann::json& j, const World* w) {
             }
             else if (field_type == "Array<EntityRef>") {
                 std::vector<Field<EntityRef>> values;
+                values.reserve(field_value.size());
                 for (const auto& v : field_value) {
-                    if (v.is_null())
+                    if (v.is_null()) {
                         values.emplace_back(null);
-                    else
+                    }
+                    else {
                         values.emplace_back(EntityRef{
                             IID(v["entityIid"].get<std::string>()), IID(v["layerIid"].get<std::string>()),
                             IID(v["levelIid"].get<std::string>()), IID(v["worldIid"].get<std::string>())
                         });
+                    }
                 }
                 addArrayField(field_name, values);
+                auto& this_field = *dynamic_cast<ArrayField<EntityRef>*>(m_array_fields.at(field_name));
+                for (auto& ent_ref : this_field) {
+                    tmp_entity_refs_vector.emplace_back(&ent_ref.value());
+                }
+
             }
         }
         // simple fields
@@ -163,13 +173,17 @@ void FieldsContainer::parseFields(const nlohmann::json& j, const World* w) {
                 addField<FilePath>(field_name, field_value.get<std::string>());
         }
         else if (field_type == "EntityRef") {
-            if (field_value.is_null())
+            if (field_value.is_null()) {
                 addField<EntityRef>(field_name, null);
-            else
+            }
+            else {
                 addField<EntityRef>(field_name, {IID(field_value["entityIid"].get<std::string>()),
                                                  IID(field_value["layerIid"].get<std::string>()),
                                                  IID(field_value["levelIid"].get<std::string>()),
                                                  IID(field_value["worldIid"].get<std::string>())});
+                auto& this_field = *dynamic_cast<Field<EntityRef>*>(m_fields.at(field_name));
+                tmp_entity_refs_vector.emplace_back(&this_field.value());
+            }
         }
     }
 }

src/Project.cpp

@@ -72,7 +72,14 @@ void Project::loadFromFile(const std::string& filepath) {
         }
     }
 
-    // TODO : resolve EntityRefs using iids
+    // resolve all EntityRefs in the project
+    for (auto* ref : FieldsContainer::tmp_entity_refs_vector) {
+        auto& world = (m_worlds.size() == 1 ? getWorld() : getWorld(ref->world_iid));
+        ref->ref = &world.getLevel(ref->level_iid)
+                         .getLayer(ref->layer_iid)
+                         .getEntity(ref->entity_iid);
+    }
+    FieldsContainer::tmp_entity_refs_vector.clear();
 }
 
 auto Project::getFilePath() const -> const FilePath& {