v1.4.4

source/game/StarTilesetDatabase.hpp

@@ -0,0 +1,142 @@
+#ifndef STAR_TILESET_DATABASE_HPP
+#define STAR_TILESET_DATABASE_HPP
+
+#include "StarDungeonGenerator.hpp"
+#include "StarJson.hpp"
+#include "StarLexicalCast.hpp"
+#include "StarLruCache.hpp"
+#include "StarSet.hpp"
+
+namespace Star {
+
+STAR_CLASS(TilesetDatabase);
+
+namespace Tiled {
+  STAR_CLASS(Tile);
+  STAR_CLASS(Tileset);
+
+  extern EnumMap<TileLayer> const LayerNames;
+
+  // Tiled properties are all String values (due to its original format being
+  // XML). This class wraps and converts the String properties into more useful
+  // types, parsing them as Json for instance.
+  class Properties {
+  public:
+    Properties();
+    Properties(Json const& json);
+
+    Json toJson() const;
+
+    // Returns a new properties set where this properties object overrides
+    // the properties parameter.
+    Properties inherit(Json const& properties) const;
+    Properties inherit(Properties const& properties) const;
+
+    bool contains(String const& name) const;
+
+    template <typename T>
+    T get(String const& name) const;
+
+    template <typename T>
+    Maybe<T> opt(String const& name) const;
+
+    template <typename T>
+    void set(String const& name, T const& value);
+
+  private:
+    Json m_properties;
+  };
+
+  class Tile : public Dungeon::Tile {
+  public:
+    Tile(Properties const& properties, TileLayer layer, bool flipX = false);
+
+    Properties properties;
+  };
+
+  class Tileset {
+  public:
+    Tileset(Json const& json);
+
+    TileConstPtr const& getTile(size_t id, TileLayer layer) const;
+    size_t size() const;
+
+  private:
+    List<TileConstPtr> const& tiles(TileLayer layer) const;
+
+    List<TileConstPtr> m_tilesBack, m_tilesFront;
+  };
+}
+
+class TilesetDatabase {
+public:
+  TilesetDatabase();
+
+  Tiled::TilesetConstPtr get(String const& path) const;
+
+private:
+  static Tiled::TilesetConstPtr readTileset(String const& path);
+
+  mutable Mutex m_cacheMutex;
+  mutable HashLruCache<String, Tiled::TilesetConstPtr> m_tilesetCache;
+};
+
+namespace Tiled {
+  template <typename T>
+  struct PropertyConverter {
+    static T to(String const& propertyValue) {
+      return lexicalCast<T>(propertyValue);
+    }
+    static String from(T const& propertyValue) {
+      return toString(propertyValue);
+    }
+  };
+
+  template <>
+  struct PropertyConverter<Json> {
+    static Json to(String const& propertyValue);
+    static String from(Json const& propertyValue);
+  };
+
+  template <>
+  struct PropertyConverter<String> {
+    static String to(String const& propertyValue);
+    static String from(String const& propertyValue);
+  };
+
+  template <typename T>
+  T getProperty(Json const& properties, String const& propertyName) {
+    return PropertyConverter<T>::to(properties.get(propertyName).toString());
+  }
+
+  template <typename T>
+  Maybe<T> optProperty(Json const& properties, String const& propertyName) {
+    if (Maybe<String> propertyValue = properties.optString(propertyName))
+      return PropertyConverter<T>::to(*propertyValue);
+    return {};
+  }
+
+  template <typename T>
+  Json setProperty(Json const& properties, String const& propertyName, T const& propertyValue) {
+    return properties.set(propertyName, PropertyConverter<T>::from(propertyValue));
+  }
+
+  template <typename T>
+  T Properties::get(String const& name) const {
+    return getProperty<T>(m_properties, name);
+  }
+
+  template <typename T>
+  Maybe<T> Properties::opt(String const& name) const {
+    return optProperty<T>(m_properties, name);
+  }
+
+  template <typename T>
+  void Properties::set(String const& name, T const& propertyValue) {
+    m_properties = setProperty(m_properties, name, propertyValue);
+  }
+}
+
+}
+
+#endif