Allow importing tiles from other tilesets

Author: Narre

src/supertux/tile_set_parser.cpp

@@ -39,7 +39,7 @@ TileSetParser::TileSetParser(TileSet& tileset, const std::string& filename) :
 }
 
 void
-TileSetParser::parse()
+TileSetParser::parse(uint32_t start, uint32_t end, int32_t offset)
 {
   m_tiles_path = FileSystem::dirname(m_filename);
 
@@ -56,11 +56,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 (end) continue;
       ReaderMapping reader = iter.as_mapping();
       Tilegroup tilegroup;
       reader.get("name", tilegroup.name);
@@ -70,10 +72,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 (end) continue;
       ReaderMapping reader = iter.as_mapping();
       std::string autotile_filename;
       if (!reader.get("source", autotile_filename))
@@ -87,25 +91,41 @@ TileSetParser::parse()
         parser->parse();
       }
     }
+    else if (iter.get_key() == "import-tileset")
+    {
+      ReaderMapping reader = iter.as_mapping();
+      std::string import_filename;
+      uint32_t start = 0, end = 0;
+      int32_t offset = 0;
+      reader.get("file", import_filename);
+      reader.get("start", start);
+      reader.get("end", end);
+      reader.get("offset", offset);
+      TileSetParser import_parser(m_tileset, import_filename);
+      import_parser.parse(start, end, offset);
+    }
     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 && !end)
   {
     m_tileset.add_unassigned_tilegroup();
   }
 }
 
 void
-TileSetParser::parse_tile(const ReaderMapping& reader)
+TileSetParser::parse_tile(const ReaderMapping& reader, uint32_t min, uint32_t max, int32_t offset)
 {
   uint32_t id;
   if (!reader.get("id", id))
   {
     throw std::runtime_error("Missing tile-id.");
   }
+  if (max && (id < min || id > max)) return;
+  id += offset;
 
   uint32_t attributes = 0;
 
@@ -182,7 +202,7 @@ TileSetParser::parse_tile(const ReaderMapping& reader)
 }
 
 void
-TileSetParser::parse_tiles(const ReaderMapping& reader)
+TileSetParser::parse_tiles(const ReaderMapping& reader, uint32_t min, uint32_t max, int32_t offset)
 {
   // List of ids (use 0 if the tile should be ignored)
   std::vector<uint32_t> ids;
@@ -271,65 +291,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] < min || ids[i] > 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] < min || ids[i] > 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(uint32_t start = 0, uint32_t end = 0, int32_t offset = 0);
 
 private:
-  void parse_tile(const ReaderMapping& reader);
-  void parse_tiles(const ReaderMapping& reader);
+  void parse_tile(const ReaderMapping& reader, uint32_t min, uint32_t max, int32_t offset);
+  void parse_tiles(const ReaderMapping& reader, uint32_t min, uint32_t max, int32_t offset);
   std::vector<SurfacePtr> parse_imagespecs(const ReaderMapping& cur,
                                            const boost::optional<Rect>& region = boost::none) const;