Add tilemap object and property deserialization

Author: PatrickHoward

src/Resource/TilemapResource.cpp

@@ -407,6 +407,32 @@ void LoadObjectGroup(tmx::Map& map, tmx::ObjectGroup& layer, MapSegmentDto* mapS
             return;
         }
     }
+
+    for (const auto& object : layer.getObjects())
+    {
+        auto newEntityInstanceDto = EntityInstanceDto();
+
+        newEntityInstanceDto.properties.emplace("name", object.getName());
+        newEntityInstanceDto.properties.emplace("type", object.getType());
+
+        {
+            float x = object.getPosition().x;
+            float y = object.getPosition().y;
+
+            auto positionValue = std::to_string(x) + " " + std::to_string(y);
+
+            newEntityInstanceDto.properties.emplace("position", positionValue);
+        }
+
+        newEntityInstanceDto.properties.emplace("rotation", std::to_string(object.getRotation()));
+
+        for (const auto& prop : object.getProperties())
+        {
+            newEntityInstanceDto.properties.emplace(prop.getName(),GetTmxPropertyValue(prop));
+        }
+
+        mapSegmentDto->entities.push_back(std::move(newEntityInstanceDto));
+    }
 }
 
 MapSegmentDto ProcessMap(const std::string& path)
@@ -549,6 +575,17 @@ void DtoToSegment(MapSegment* segment, MapSegmentDto& segmentDto)
             layerDto.tileSize,
             layerDto.layerName);
     }
+
+    for (auto& entity : segmentDto.entities)
+    {
+        if (!entity.properties.contains("type")) continue;
+
+        EntityInstance entityInstance;
+        entityInstance.type = StringId(entity.properties["type"]);
+        entityInstance.properties = std::move(entity.properties);
+
+        segment->entities.push_back(entityInstance);
+    }
 }
 
 bool TilemapResource::LoadFromFile(const ResourceSettings& settings)

src/Scene/EntitySerializer.hpp

@@ -5,6 +5,7 @@
 
 #include <nlohmann/json.hpp>
 #include <Engine.hpp>
+#include <robin_hood.h>
 
 enum class EntitySerializerMode
 {
@@ -49,5 +50,5 @@ struct EntitySerializer
     }
 
     EntitySerializerMode mode;
-    std::unordered_map<std::string, std::string> properties;
+    robin_hood::unordered_flat_map<std::string, std::string> properties;
 };

src/Scene/MapSegment.hpp

@@ -46,7 +46,8 @@ struct MapLayer
 
 struct EntityInstance
 {
-    int totalProperties;
+    StringId type;
+    robin_hood::unordered_flat_map<std::string, std::string> properties;
 };
 
 struct MapSegment
@@ -59,12 +60,5 @@ struct MapSegment
     std::vector<MapLayer> layers;
     std::vector<EntityInstance> entities;
     std::vector<TileProperties*> tileProperties;
-
-
-    // TODO: deprecate
-    Vector2 startMarker;
-    Vector2 endMarker;
-
-private:
 };
 

src/Scene/Scene.cpp

@@ -202,7 +202,6 @@ void Scene::LoadMapSegment(const MapSegment& segment)
 {
     auto tileMap = CreateEntity<TilemapEntity>(Vector2(0, 0 ));
     tileMap->SetMapSegment(segment);
-
 }
 
 void Scene::StartTimer(float timeSeconds, const std::function<void()>& callback)

src/Scene/Scene.hpp

@@ -286,10 +286,8 @@ TEntity* Scene::CreateEntity(EntitySerializer& serializer, Args&& ... constructo
 	auto oldEntityUnderConstruction = entityUnderConstruction;
 
 	TEntity* entity = (TEntity*)AllocateMemory(sizeof(TEntity));
-
-	entity->scene = this;
-
 	entityUnderConstruction = entity;
+
 	new(entity) TEntity(std::forward<Args>(constructorArgs) ...);
 
 	Vector2 position;
@@ -299,16 +297,16 @@ TEntity* Scene::CreateEntity(EntitySerializer& serializer, Args&& ... constructo
 	    .Add("position", position)
 	    .Add("rotation", rotation);
 
-	entity->_position = position;
-	entity->_rotation = rotation;
-	entity->type = TEntity::Type;
-	entity->scene = this;
+    entity->_position = position;
+    entity->_rotation = rotation;
+    entity->type = TEntity::Type;
+    entity->scene = this;
 
-	RegisterEntity(entity);
-    ((Entity*)entity)->DoSerialize(serializer);
+    entity->DoSerialize(serializer);
 
-	((Entity*)entity)->OnAdded();
-	entityUnderConstruction = oldEntityUnderConstruction;
+    RegisterEntity(entity);
+    ((Entity*)entity)->OnAdded();
+    entityUnderConstruction = oldEntityUnderConstruction;
 
 	return entity;
 }
@@ -349,6 +347,7 @@ EntityList<TEntity> Scene::GetEntitiesOfType()
     return _entityManager.GetEntitiesOfType<TEntity>();
 }
 
+// TODO: Deprecate
 template<typename TEntity>
 TEntity* Scene::GetFirstNamedEntityOfType(StringId name)
 {

src/Scene/TilemapEntity.cpp

@@ -70,6 +70,15 @@ void TilemapEntity::SetMapSegment(const MapSegment& mapSegment)
         scene->isometricSettings.tileSize = Vector2(64, 32);
     }
 
+    for (auto& entityDictionary : mapSegment.entities)
+    {
+        EntitySerializer entitySerializer;
+        entitySerializer.properties = entityDictionary.properties;
+        entitySerializer.mode = EntitySerializerMode::Read;
+
+        scene->CreateEntity(entityDictionary.type, entitySerializer);
+    }
+
     _mapSegment = &mapSegment;
 
     scene->isometricSettings.BuildFromMapSegment(mapSegment, pathFinder, this);

src/System/Serialization.hpp

@@ -3,6 +3,7 @@
 #include <map>
 #include <vector>
 #include <string>
+#include <robin_hood.h>
 
 #include "Math/Rectangle.hpp"
 #include "Math/Vector2.hpp"
@@ -38,19 +39,20 @@ void ReadVector(BinaryStreamReader& reader, std::vector<T>& outV)
 }
 
 template<typename TKey, typename TValue>
-void WriteMap(BinaryStreamWriter& writer, const std::map<TKey, TValue> m)
+void WriteMap(BinaryStreamWriter& writer, const std::map<TKey, TValue>& map)
 {
-    writer.WriteInt(m.size());
+    writer.WriteInt(map.size());
 
-    for (auto& item : m)
+    for (auto& pair
+    : map)
     {
-        Write(writer, item.first);
-        Write(writer, item.second);
+        Write(writer, pair.first);
+        Write(writer, pair.second);
     }
 }
 
 template<typename TKey, typename TValue>
-void ReadMap(BinaryStreamReader& reader, std::map<TKey, TValue>& m)
+void ReadMap(BinaryStreamReader& reader, std::map<TKey, TValue>& map)
 {
     int size = reader.ReadInt();
     for(int i = 0; i < size; ++i)
@@ -61,7 +63,35 @@ void ReadMap(BinaryStreamReader& reader, std::map<TKey, TValue>& m)
         Read(reader, key);
         Read(reader, value);
 
-        m.insert({key, value});
+        map.insert({ key, value});
+    }
+}
+
+template<typename TKey, typename TValue>
+void WriteMap(BinaryStreamWriter& writer, const robin_hood::unordered_flat_map<TKey, TValue>& map)
+{
+    writer.WriteInt(map.size());
+
+    for (auto& pair : map)
+    {
+        Write(writer, pair.first);
+        Write(writer, pair.second);
+    }
+}
+
+template<typename TKey, typename TValue>
+void ReadMap(BinaryStreamReader& reader, robin_hood::unordered_flat_map<TKey, TValue>& map)
+{
+    auto size = reader.ReadInt();
+    for (int i = 0; i < size; ++i)
+    {
+        TKey key;
+        TValue value;
+
+        Read(reader, key);
+        Read(reader, value);
+
+        map.insert({key, value});
     }
 }
 

src/System/TileMapSerialization.hpp

@@ -4,6 +4,7 @@
 #include <string>
 #include <map>
 #include <Math/Polygon.hpp>
+#include <robin_hood.h>
 
 #include "BinaryStreamReader.hpp"
 #include "Math/Rectangle.hpp"
@@ -77,13 +78,13 @@ struct EntityInstanceDto
 
 	}
 
-    EntityInstanceDto(const std::map<std::string, std::string>& properties_)
+    EntityInstanceDto(const robin_hood::unordered_flat_map<std::string, std::string>& properties_)
         : properties(properties_)
 	{
 
 	}
 
-    std::map<std::string, std::string> properties;
+    robin_hood::unordered_flat_map<std::string, std::string> properties;
 };
 
 struct MapSegmentDto