feat: add support for LDtk tilemap

Core/GDCore/Events/CodeGeneration/EventsCodeGenerator.cpp

@@ -726,6 +726,7 @@ gd::String EventsCodeGenerator::GenerateParameterCodes(
              metadata.GetType() == "fontResource" ||
              metadata.GetType() == "imageResource" ||
              metadata.GetType() == "jsonResource" ||
+             metadata.GetType() == "tilemapResource" ||
              metadata.GetType() == "videoResource" ||
              // Deprecated, old parameter names:
              metadata.GetType() == "password" || metadata.GetType() == "musicfile" ||

Core/GDCore/IDE/Project/ArbitraryResourceWorker.cpp

@@ -35,6 +35,11 @@ void ArbitraryResourceWorker::ExposeJson(gd::String& jsonName){
     // do.
 };
 
+void ArbitraryResourceWorker::ExposeTilemap(gd::String& tilemapName){
+    // Nothing to do by default - each child class can define here the action to
+    // do.
+};
+
 void ArbitraryResourceWorker::ExposeVideo(gd::String& videoName){
     // Nothing to do by default - each child class can define here the action to
     // do.
@@ -92,6 +97,65 @@ void ArbitraryResourceWorker::ExposeResources(
   }
 }
 
+void ArbitraryResourceWorker::ExposeEmbeddeds(gd::String& resourceName) {
+  if (resourcesManagers.empty()) return;
+  gd::ResourcesManager* resourcesManager = resourcesManagers[0];
+
+  gd::Resource& resource = resourcesManager->GetResource(resourceName);
+
+  if (!resource.GetMetadata().empty()) {
+    gd::SerializerElement serializerElement =
+        gd::Serializer::FromJSON(resource.GetMetadata());
+
+    if (serializerElement.HasChild("embeddedResourcesMapping")) {
+      bool anyEmbeddedResourceNameWasRenamed = false;
+      gd::SerializerElement& embeddedResourcesMappingElement =
+          serializerElement.GetChild("embeddedResourcesMapping");
+
+      for (const auto& child :
+           embeddedResourcesMappingElement.GetAllChildren()) {
+        const gd::String& targetResourceName =
+            child.second->GetValue().GetString();
+
+        if (resourcesManager->HasResource(targetResourceName)) {
+          std::cout << targetResourceName << std::endl;
+          gd::Resource& targetResource =
+              resourcesManager->GetResource(targetResourceName);
+          const gd::String& targetResourceKind = targetResource.GetKind();
+
+          gd::String potentiallyUpdatedTargetResourceName = targetResourceName;
+
+          if (targetResourceKind == "audio") {
+            ExposeAudio(potentiallyUpdatedTargetResourceName);
+          } else if (targetResourceKind == "bitmapFont") {
+            ExposeBitmapFont(potentiallyUpdatedTargetResourceName);
+          } else if (targetResourceKind == "font") {
+            ExposeFont(potentiallyUpdatedTargetResourceName);
+          } else if (targetResourceKind == "image") {
+            ExposeImage(potentiallyUpdatedTargetResourceName);
+          } else if (targetResourceKind == "json") {
+            ExposeJson(potentiallyUpdatedTargetResourceName);
+          } else if (targetResourceKind == "tilemap") {
+            ExposeTilemap(potentiallyUpdatedTargetResourceName);
+          } else if (targetResourceKind == "video") {
+            ExposeVideo(potentiallyUpdatedTargetResourceName);
+          }
+
+          if (potentiallyUpdatedTargetResourceName != targetResourceName) {
+            // The resource name was renamed. Also update the mapping.
+            child.second->SetStringValue(potentiallyUpdatedTargetResourceName);
+            anyEmbeddedResourceNameWasRenamed = true;
+          }
+        }
+      }
+
+      if (anyEmbeddedResourceNameWasRenamed) {
+        resource.SetMetadata(gd::Serializer::ToJSON(serializerElement));
+      }
+    }
+  }
+}
+
 void ArbitraryResourceWorker::ExposeResource(gd::Resource& resource) {
   if (!resource.UseFile()) return;
 
@@ -154,6 +218,10 @@ class ResourceWorkerInEventsWorker : public ArbitraryEventsWorker {
             gd::String updatedParameterValue = parameterValue;
             worker.ExposeJson(updatedParameterValue);
             instruction.SetParameter(parameterIndex, updatedParameterValue);
+          } else if (parameterMetadata.GetType() == "tilemapResource") {
+            gd::String updatedParameterValue = parameterValue;
+            worker.ExposeTilemap(updatedParameterValue);
+            instruction.SetParameter(parameterIndex, updatedParameterValue);
           }
         });
 

Core/GDCore/IDE/Project/ArbitraryResourceWorker.h

@@ -75,6 +75,11 @@ class GD_CORE_API ArbitraryResourceWorker {
    */
   virtual void ExposeJson(gd::String &jsonName);
 
+  /**
+   * \brief Expose a Tilemap, which is always a reference to a "tilemap" resource.
+   */
+  virtual void ExposeTilemap(gd::String &tilemapName);
+
   /**
    * \brief Expose a video, which is always a reference to a "video" resource.
    */
@@ -96,6 +101,11 @@ class GD_CORE_API ArbitraryResourceWorker {
    */
   virtual void ExposeFile(gd::String &resourceFileName) = 0;
 
+  /**
+   * \brief Expose the embedded resources of the specified resource.
+   */
+  virtual void ExposeEmbeddeds(gd::String &resourceName);
+
  protected:
   const std::vector<gd::ResourcesManager *> &GetResources() {
     return resourcesManagers;

Core/GDCore/IDE/Project/ResourcesInUseHelper.h

@@ -40,13 +40,15 @@ class ResourcesInUseHelper : public gd::ArbitraryResourceWorker {
   std::set<gd::String>& GetAllAudios() { return GetAll("audio"); };
   std::set<gd::String>& GetAllFonts() { return GetAll("font"); };
   std::set<gd::String>& GetAllJsons() { return GetAll("json"); };
+  std::set<gd::String>& GetAllTilemaps() { return GetAll("tilemap"); };
   std::set<gd::String>& GetAllVideos() { return GetAll("video"); };
   std::set<gd::String>& GetAllBitmapFonts() { return GetAll("bitmapFont"); };
   std::set<gd::String>& GetAll(const gd::String& resourceType) {
     if (resourceType == "image") return allImages;
     if (resourceType == "audio") return allAudios;
     if (resourceType == "font") return allFonts;
     if (resourceType == "json") return allJsons;
+    if (resourceType == "tilemap") return allTilemaps;
     if (resourceType == "video") return allVideos;
     if (resourceType == "bitmapFont") return allBitmapFonts;
 
@@ -68,6 +70,9 @@ class ResourcesInUseHelper : public gd::ArbitraryResourceWorker {
   virtual void ExposeJson(gd::String& jsonResourceName) override {
     allJsons.insert(jsonResourceName);
   };
+  virtual void ExposeTilemap(gd::String& tilemapResourceName) override {
+    allTilemaps.insert(tilemapResourceName);
+  };
   virtual void ExposeVideo(gd::String& videoResourceName) override {
     allVideos.insert(videoResourceName);
   };
@@ -80,6 +85,7 @@ class ResourcesInUseHelper : public gd::ArbitraryResourceWorker {
   std::set<gd::String> allAudios;
   std::set<gd::String> allFonts;
   std::set<gd::String> allJsons;
+  std::set<gd::String> allTilemaps;
   std::set<gd::String> allVideos;
   std::set<gd::String> allBitmapFonts;
   std::set<gd::String> emptyResources;

Core/GDCore/IDE/Project/ResourcesRenamer.h

@@ -49,6 +49,9 @@ class ResourcesRenamer : public gd::ArbitraryResourceWorker {
   virtual void ExposeJson(gd::String& jsonResourceName) override {
     RenameIfNeeded(jsonResourceName);
   };
+  virtual void ExposeTilemap(gd::String& tilemapResourceName) override {
+    RenameIfNeeded(tilemapResourceName);
+  };
   virtual void ExposeVideo(gd::String& videoResourceName) override {
     RenameIfNeeded(videoResourceName);
   };

Core/GDCore/Project/CustomObjectConfiguration.cpp

@@ -38,7 +38,7 @@ gd::ObjectConfiguration &CustomObjectConfiguration::GetChildObjectConfiguration(
     return badObjectConfiguration;
   }
   const auto &eventsBasedObject = project->GetEventsBasedObject(GetType());
-  
+
   if (!eventsBasedObject.HasObjectNamed(objectName)) {
     gd::LogError("Tried to get the configuration of a child-object:" + objectName
                 + " that doesn't exist in the event-based object: " + GetType());
@@ -78,7 +78,7 @@ bool CustomObjectConfiguration::UpdateProperty(const gd::String& propertyName,
     }
     const auto &eventsBasedObject = project->GetEventsBasedObject(GetType());
     const auto &properties = eventsBasedObject.GetPropertyDescriptors();
-    
+
     return gd::CustomConfigurationHelper::UpdateProperty(
         properties,
         objectContent,
@@ -125,8 +125,7 @@ void CustomObjectConfiguration::DoUnserializeFrom(Project& project,
   }
 }
 
-void CustomObjectConfiguration::ExposeResources(
-    gd::ArbitraryResourceWorker& worker) {
+void CustomObjectConfiguration::ExposeResources(gd::ArbitraryResourceWorker& worker) {
   std::map<gd::String, gd::PropertyDescriptor> properties = GetProperties();
 
   for (auto& property : properties) {
@@ -148,6 +147,8 @@ void CustomObjectConfiguration::ExposeResources(
         worker.ExposeVideo(newPropertyValue);
       } else if (resourceType == "json") {
         worker.ExposeJson(newPropertyValue);
+      } else if (resourceType == "tilemap") {
+        worker.ExposeTilemap(newPropertyValue);
       } else if (resourceType == "bitmapFont") {
         worker.ExposeBitmapFont(newPropertyValue);
       }

Core/GDCore/Project/CustomObjectConfiguration.h

@@ -87,9 +87,9 @@ class CustomObjectConfiguration : public gd::ObjectConfiguration {
   /**
    * Initialize configuration using another configuration. Used by copy-ctor
    * and assign-op.
-   * 
+   *
    * Don't forget to update me if members were changed!
-   * 
+   *
    * It's needed because there is no default copy for childObjectConfigurations
    * and it must be a deep copy.
    */

Core/GDCore/Project/ObjectConfiguration.h

@@ -12,6 +12,7 @@
 
 #include "GDCore/Project/Behavior.h"
 #include "GDCore/Project/EffectsContainer.h"
+#include "GDCore/Project/ResourcesManager.h"
 #include "GDCore/Project/VariablesContainer.h"
 #include "GDCore/String.h"
 #include "GDCore/Tools/MakeUnique.h"

Core/GDCore/Project/Project.cpp

@@ -982,8 +982,10 @@ void Project::ExposeResources(gd::ArbitraryResourceWorker& worker) {
   // (this time for effects). Ideally, this method could be moved outside of
   // gd::Project.
 
+  gd::ResourcesManager* resourcesManager = &GetResourcesManager();
+
   // Add project resources
-  worker.ExposeResources(&GetResourcesManager());
+  worker.ExposeResources(resourcesManager);
   platformSpecificAssets.ExposeResources(worker);
 
   // Add layouts resources

Core/GDCore/Project/ResourcesManager.cpp

@@ -85,6 +85,8 @@ std::shared_ptr<Resource> ResourcesManager::CreateResource(
     return std::make_shared<VideoResource>();
   else if (kind == "json")
     return std::make_shared<JsonResource>();
+  else if (kind == "tilemap")
+    return std::make_shared<TilemapResource>();
   else if (kind == "bitmapFont")
     return std::make_shared<BitmapFontResource>();
 
@@ -650,6 +652,40 @@ bool JsonResource::UpdateProperty(const gd::String& name,
   return true;
 }
 
+void TilemapResource::SetFile(const gd::String& newFile) {
+  file = NormalizePathSeparator(newFile);
+}
+
+void TilemapResource::UnserializeFrom(const SerializerElement& element) {
+  SetUserAdded(element.GetBoolAttribute("userAdded"));
+  SetFile(element.GetStringAttribute("file"));
+  DisablePreload(element.GetBoolAttribute("disablePreload", false));
+}
+
+void TilemapResource::SerializeTo(SerializerElement& element) const {
+  element.SetAttribute("userAdded", IsUserAdded());
+  element.SetAttribute("file", GetFile());
+  element.SetAttribute("disablePreload", IsPreloadDisabled());
+}
+
+std::map<gd::String, gd::PropertyDescriptor> TilemapResource::GetProperties()
+    const {
+  std::map<gd::String, gd::PropertyDescriptor> properties;
+  properties["disablePreload"]
+      .SetValue(disablePreload ? "true" : "false")
+      .SetType("Boolean")
+      .SetLabel(_("Disable preloading at game startup"));
+
+  return properties;
+}
+
+bool TilemapResource::UpdateProperty(const gd::String& name,
+                                  const gd::String& value) {
+  if (name == "disablePreload") disablePreload = value == "1";
+
+  return true;
+}
+
 void BitmapFontResource::SetFile(const gd::String& newFile) {
   file = NormalizePathSeparator(newFile);
 }

Core/GDCore/Project/ResourcesManager.h

@@ -373,6 +373,47 @@ class GD_CORE_API JsonResource : public Resource {
   gd::String file;
 };
 
+/**
+ * \brief Describe a tilemap file used by a project.
+ *
+ * \see Resource
+ * \ingroup ResourcesManagement
+ */
+class GD_CORE_API TilemapResource : public Resource {
+ public:
+  TilemapResource() : Resource(), disablePreload(false) { SetKind("tilemap"); };
+  virtual ~TilemapResource(){};
+  virtual TilemapResource* Clone() const override {
+    return new TilemapResource(*this);
+  }
+
+  virtual const gd::String& GetFile() const override { return file; };
+  virtual void SetFile(const gd::String& newFile) override;
+
+  virtual bool UseFile() const override { return true; }
+
+  std::map<gd::String, gd::PropertyDescriptor> GetProperties() const override;
+  bool UpdateProperty(const gd::String& name, const gd::String& value) override;
+
+  void SerializeTo(SerializerElement& element) const override;
+
+  void UnserializeFrom(const SerializerElement& element) override;
+
+  /**
+   * \brief Return true if the loading at game startup must be disabled
+   */
+  bool IsPreloadDisabled() const { return disablePreload; }
+
+  /**
+   * \brief Set if the tilemap preload at game startup must be disabled
+   */
+  void DisablePreload(bool disable = true) { disablePreload = disable; }
+
+ private:
+  bool disablePreload;  ///< If "true", don't load the tilemap at game startup
+  gd::String file;
+};
+
 /**
  * \brief Describe a bitmap font file used by a project.
  *