Merge pull request #2025 from Narre/nested_tilesets

Tiles from other tilesets can now be imported from the strf files

Author: Semphriss

src/supertux/tile_set_parser.cpp

@@ -39,8 +39,24 @@ TileSetParser::TileSetParser(TileSet& tileset, const std::string& filename) :
 }
 
 void
-TileSetParser::parse()
+TileSetParser::parse(int32_t start, int32_t end, int32_t offset, bool imported)
 {
+  if (offset && start + offset < 1) {
+    start = -offset + 1;
+    log_warning << "The defined offset would assign non-positive ids to tiles, tiles below " << -offset + 1 << " will be ignored." << std::endl;
+  }
+  if (end < 0) {
+    log_warning << "Cannot import tiles with negative IDs." << std::endl;
+    return;
+  }
+  if (start < 0) {
+    log_warning << "Cannot import tiles with negative IDs. Importing will start at ID 1." << std::endl;
+    start = 1;
+  }
+  if (imported && !end) {
+    log_warning << "Importing a tileset with no upper ID limit can cause ID conflicts if the imported tileset is expanded in the future." <<std::endl;
+  }
+
   m_tiles_path = FileSystem::dirname(m_filename);
 
   auto doc = ReaderDocument::from_file(m_filename);
@@ -56,11 +72,13 @@ TileSetParser::parse()
     if (iter.get_key() == "tile")
     {
       ReaderMapping tile_mapping = iter.as_mapping();
-      parse_tile(tile_mapping);
+      parse_tile(tile_mapping, start, end, offset);
     }
     else if (iter.get_key() == "tilegroup")
     {
       /* tilegroups are only interesting for the editor */
+      /* ignore tilegroups for imported tilesets */
+      if (imported) continue;
       ReaderMapping reader = iter.as_mapping();
       Tilegroup tilegroup;
       reader.get("name", tilegroup.name);
@@ -70,10 +88,12 @@ TileSetParser::parse()
     else if (iter.get_key() == "tiles")
     {
       ReaderMapping tiles_mapping = iter.as_mapping();
-      parse_tiles(tiles_mapping);
+      parse_tiles(tiles_mapping, start, end, offset);
     }
     else if (iter.get_key() == "autotileset")
     {
+      /* ignore autotiles for imported tilesets */
+      if (imported) continue;
       ReaderMapping reader = iter.as_mapping();
       std::string autotile_filename;
       if (!reader.get("source", autotile_filename))
@@ -87,25 +107,51 @@ TileSetParser::parse()
         parser->parse();
       }
     }
+    else if (iter.get_key() == "import-tileset")
+    {
+      ReaderMapping reader = iter.as_mapping();
+      std::string import_filename;
+      int32_t import_start = 0, import_end = 0, import_offset = 0;
+      reader.get("file", import_filename);
+      reader.get("start", import_start);
+      reader.get("end", import_end);
+      reader.get("offset", import_offset);
+      if (import_start + import_offset < start) {
+        import_start = (start - import_offset) < 0 ? 0 : (start - import_offset);
+      }
+      if (end && (!import_end || (import_end + import_offset) > end)) {
+        import_end = end - import_offset;
+      }
+      if (import_end < import_start) {
+        if (!imported) log_warning << "The defined range has a negative size, no tiles will be imported." << std::endl;
+        continue;
+      }
+      import_offset += offset;
+      TileSetParser import_parser(m_tileset, import_filename);
+      import_parser.parse(import_start, import_end, import_offset, true);
+    }
     else
     {
       log_warning << "Unknown symbol '" << iter.get_key() << "' in tileset file" << std::endl;
     }
   }
-  if (g_config->developer_mode)
+  /* only create the unassigned tilegroup from the parent strf */
+  if (g_config->developer_mode && !imported)
   {
     m_tileset.add_unassigned_tilegroup();
   }
 }
 
 void
-TileSetParser::parse_tile(const ReaderMapping& reader)
+TileSetParser::parse_tile(const ReaderMapping& reader, int32_t min, int32_t max, int32_t offset)
 {
   uint32_t id;
   if (!reader.get("id", id))
   {
     throw std::runtime_error("Missing tile-id.");
   }
+  if (max && (id < static_cast<uint32_t>(min) || id > static_cast<uint32_t>(max))) return;
+  id += offset;
 
   uint32_t attributes = 0;
 
@@ -182,7 +228,7 @@ TileSetParser::parse_tile(const ReaderMapping& reader)
 }
 
 void
-TileSetParser::parse_tiles(const ReaderMapping& reader)
+TileSetParser::parse_tiles(const ReaderMapping& reader, int32_t min, int32_t max, int32_t offset)
 {
   // List of ids (use 0 if the tile should be ignored)
   std::vector<uint32_t> ids;
@@ -271,65 +317,65 @@ TileSetParser::parse_tiles(const ReaderMapping& reader)
 
       for (size_t i = 0; i < ids.size(); ++i)
       {
-        if (ids[i] != 0)
-        {
-          const int x = static_cast<int>(32 * (i % width));
-          const int y = static_cast<int>(32 * (i / width));
-
-          std::vector<SurfacePtr> regions;
-          regions.reserve(surfaces.size());
-          std::transform(surfaces.begin(), surfaces.end(), std::back_inserter(regions),
-              [x, y] (const SurfacePtr& surface) { 
-                return surface->region(Rect(x, y, Size(32, 32)));
-              });
-
-          std::vector<SurfacePtr> editor_regions;
-          editor_regions.reserve(editor_surfaces.size());
-          std::transform(editor_surfaces.begin(), editor_surfaces.end(), std::back_inserter(editor_regions),
-              [x, y] (const SurfacePtr& surface) { 
-                return surface->region(Rect(x, y, Size(32, 32)));
-              });
-
-          auto tile = std::make_unique<Tile>(regions,
-                                             editor_regions,
-                                             (has_attributes ? attributes[i] : 0),
-                                             (has_datas ? datas[i] : 0),
-                                             fps);
-
-          m_tileset.add_tile(ids[i], std::move(tile));
-        }
+        if (!ids[i] || (max && (ids[i] < static_cast<uint32_t>(min) || ids[i] > static_cast<uint32_t>(max)))) continue;
+        ids[i] += offset;
+
+        const int x = static_cast<int>(32 * (i % width));
+        const int y = static_cast<int>(32 * (i / width));
+
+        std::vector<SurfacePtr> regions;
+        regions.reserve(surfaces.size());
+        std::transform(surfaces.begin(), surfaces.end(), std::back_inserter(regions),
+            [x, y] (const SurfacePtr& surface) { 
+              return surface->region(Rect(x, y, Size(32, 32)));
+            });
+
+        std::vector<SurfacePtr> editor_regions;
+        editor_regions.reserve(editor_surfaces.size());
+        std::transform(editor_surfaces.begin(), editor_surfaces.end(), std::back_inserter(editor_regions),
+            [x, y] (const SurfacePtr& surface) { 
+              return surface->region(Rect(x, y, Size(32, 32)));
+            });
+
+        auto tile = std::make_unique<Tile>(regions,
+                                           editor_regions,
+                                           (has_attributes ? attributes[i] : 0),
+                                           (has_datas ? datas[i] : 0),
+                                           fps);
+
+        m_tileset.add_tile(ids[i], std::move(tile));
       }
     }
     else // (!shared_surface)
     {
       for (size_t i = 0; i < ids.size(); ++i)
       {
-        if (ids[i] != 0)
-        {
-          int x = static_cast<int>(32 * (i % width));
-          int y = static_cast<int>(32 * (i / width));
-
-          std::vector<SurfacePtr> surfaces;
-          boost::optional<ReaderMapping> surfaces_mapping;
-          if (reader.get("image", surfaces_mapping) ||
-             reader.get("images", surfaces_mapping)) {
-            surfaces = parse_imagespecs(*surfaces_mapping, Rect(x, y, Size(32, 32)));
-          }
-
-          std::vector<SurfacePtr> editor_surfaces;
-          boost::optional<ReaderMapping> editor_surfaces_mapping;
-          if (reader.get("editor-images", editor_surfaces_mapping)) {
-            editor_surfaces = parse_imagespecs(*editor_surfaces_mapping, Rect(x, y, Size(32, 32)));
-          }
-
-          auto tile = std::make_unique<Tile>(surfaces,
-                                             editor_surfaces,
-                                             (has_attributes ? attributes[i] : 0),
-                                             (has_datas ? datas[i] : 0),
-                                             fps);
-
-          m_tileset.add_tile(ids[i], std::move(tile));
+        if(!ids[i] || (max && (ids[i] < static_cast<uint32_t>(min) || ids[i] > static_cast<uint32_t>(max)))) continue;
+        ids[i] += offset;
+
+        int x = static_cast<int>(32 * (i % width));
+        int y = static_cast<int>(32 * (i / width));
+
+        std::vector<SurfacePtr> surfaces;
+        boost::optional<ReaderMapping> surfaces_mapping;
+        if (reader.get("image", surfaces_mapping) ||
+           reader.get("images", surfaces_mapping)) {
+          surfaces = parse_imagespecs(*surfaces_mapping, Rect(x, y, Size(32, 32)));
+        }
+
+        std::vector<SurfacePtr> editor_surfaces;
+        boost::optional<ReaderMapping> editor_surfaces_mapping;
+        if (reader.get("editor-images", editor_surfaces_mapping)) {
+          editor_surfaces = parse_imagespecs(*editor_surfaces_mapping, Rect(x, y, Size(32, 32)));
         }
+
+        auto tile = std::make_unique<Tile>(surfaces,
+                                           editor_surfaces,
+                                           (has_attributes ? attributes[i] : 0),
+                                           (has_datas ? datas[i] : 0),
+                                           fps);
+
+        m_tileset.add_tile(ids[i], std::move(tile));
       }
     }
   }

src/supertux/tile_set_parser.hpp

@@ -38,11 +38,11 @@ class TileSetParser final
 public:
   TileSetParser(TileSet& tileset, const std::string& filename);
 
-  void parse();
+  void parse(int32_t start = 0, int32_t end = 0, int32_t offset = 0, bool imported = false);
 
 private:
-  void parse_tile(const ReaderMapping& reader);
-  void parse_tiles(const ReaderMapping& reader);
+  void parse_tile(const ReaderMapping& reader, int32_t min, int32_t max, int32_t offset);
+  void parse_tiles(const ReaderMapping& reader, int32_t min, int32_t max, int32_t offset);
   std::vector<SurfacePtr> parse_imagespecs(const ReaderMapping& cur,
                                            const boost::optional<Rect>& region = boost::none) const;