Tileson  1.3.0
A helpful json parser for Tiled maps
Tile.hpp
Go to the documentation of this file.
1 //
2 // Created by robin on 22.03.2020.
3 //
4 
5 #ifndef TILESON_TILE_HPP
6 #define TILESON_TILE_HPP
7 
8 //#include "../external/json.hpp"
9 #include "../objects/Vector2.hpp"
10 #include "../objects/Color.hpp"
11 #include "Frame.hpp"
12 #include "Animation.hpp"
13 #include "../objects/PropertyCollection.hpp"
14 #include "Layer.hpp"
15 #include "../objects/Rect.hpp"
16 
17 namespace tson
18 {
19  class Tileset;
20 
21  class Tile
22  {
23  public:
24  inline Tile() = default;
25  inline Tile(IJson &json, tson::Tileset *tileset, tson::Map *map);
26  inline Tile(uint32_t id, tson::Tileset *tileset, tson::Map *map);
27  inline Tile(uint32_t id, tson::Map *map); //v1.2.0
28  inline bool parse(IJson &json, tson::Tileset *tileset, tson::Map *map);
29  inline bool parseId(IJson &json);
30 
31 
32  [[nodiscard]] inline uint32_t getId() const;
33 
34  [[nodiscard]] inline const fs::path &getImage() const;
35 
36  [[nodiscard]] inline const Vector2i &getImageSize() const;
37  [[nodiscard]] inline const std::string &getType() const;
38 
39  //[[nodiscard]] inline const std::vector<tson::Frame> &getAnimation() const;
40  [[nodiscard]] inline tson::Animation &getAnimation();
41  [[nodiscard]] inline const Layer &getObjectgroup() const;
42  [[nodiscard]] inline PropertyCollection &getProperties();
43  [[nodiscard]] inline const std::vector<int> &getTerrain() const;
44 
45  template <typename T>
46  inline T get(const std::string &name);
47  inline tson::Property * getProp(const std::string &name);
48 
49  //v1.2.0-stuff
50  inline void setProperties(const tson::PropertyCollection &properties);
51 
52  inline tson::Tileset * getTileset() const;
53  inline tson::Map * getMap() const;
54  inline const tson::Rect &getDrawingRect() const;
55  inline const tson::Vector2f getPosition(const std::tuple<int, int> &tileDataPos);
56  inline const tson::Vector2i getPositionInTileUnits(const std::tuple<int, int> &tileDataPos);
57  inline const tson::Vector2i getTileSize() const;
59  [[nodiscard]] inline TileFlipFlags getFlipFlags() const;
60  inline bool hasFlipFlags(TileFlipFlags flags);
61  [[nodiscard]] inline uint32_t getGid() const;
62 
63  inline void addTilesetAndPerformCalculations(tson::Tileset *tileset); //v1.2.0
64 
65 
66  private:
67  tson::Animation m_animation{};
68  uint32_t m_id {};
70  fs::path m_image;
72  tson::Vector2i m_imageSize;
73  tson::Layer m_objectgroup;
74  tson::PropertyCollection m_properties;
75  std::vector<int> m_terrain;
76  std::string m_type;
78  //v1.2.0-stuff
79  uint32_t m_gid {};
80  tson::Tileset * m_tileset;
81  tson::Map * m_map;
82  tson::Rect m_drawingRect;
84  inline void performDataCalculations();
85  inline void manageFlipFlagsByIdThenRemoveFlags(uint32_t &id);
86  friend class Layer;
87  };
88 
95  template<typename T>
96  T tson::Tile::get(const std::string &name)
97  {
98  return m_properties.getValue<T>(name);
99  }
100 }
101 
103 {
104  parse(json, tileset, map);
105 }
106 
111 tson::Tile::Tile(uint32_t id, tson::Tileset *tileset, tson::Map *map) : m_id {id}, m_gid {id}
112 {
113  m_tileset = tileset;
114  m_map = map;
115  manageFlipFlagsByIdThenRemoveFlags(m_gid);
116  performDataCalculations();
117 }
118 
123 tson::Tile::Tile(uint32_t id, tson::Map *map) : m_id {id}, m_gid {id}
124 {
125  m_map = map;
126  manageFlipFlagsByIdThenRemoveFlags(m_gid);
127 }
128 
134 {
135  m_tileset = tileset;
136  performDataCalculations();
137 }
138 
144 bool tson::Tile::parse(IJson &json, tson::Tileset *tileset, tson::Map *map)
145 {
146  m_tileset = tileset;
147  m_map = map;
148 
149  if(json.count("image") > 0) m_image = fs::path(json["image"].get<std::string>()); //Optional
150 
151  bool allFound = parseId(json);
152 
153  if(json.count("type") > 0) m_type = json["type"].get<std::string>(); //Optional
154  if(json.count("objectgroup") > 0) m_objectgroup = tson::Layer(json["objectgroup"], m_map); //Optional
155 
156  if(json.count("imagewidth") > 0 && json.count("imageheight") > 0)
157  m_imageSize = {json["imagewidth"].get<int>(), json["imageheight"].get<int>()}; //Optional
158 
159  //More advanced data
160  if(json.count("animation") > 0 && json["animation"].isArray())
161  {
162  auto &animation = json.array("animation");
163  std::vector<tson::Frame> frames;
164  std::for_each(animation.begin(), animation.end(), [&](std::unique_ptr<IJson> &item) { frames.emplace_back(*item); });
165  if(frames.size() > 0)
166  {
167  m_animation.setFrames(frames);
168  }
169  }
170  if(json.count("terrain") > 0 && json["terrain"].isArray())
171  {
172  auto &terrain = json.array("terrain");
173  std::for_each(terrain.begin(), terrain.end(), [&](std::unique_ptr<IJson> &item) { m_terrain.emplace_back(item->get<int>()); });
174  }
175 
176  if(json.count("properties") > 0 && json["properties"].isArray())
177  {
178  auto &properties = json.array("properties");
179  std::for_each(properties.begin(), properties.end(), [&](std::unique_ptr<IJson> &item) { m_properties.add(*item); });
180  }
181 
182  performDataCalculations();
183 
184  return allFound;
185 }
186 
191 uint32_t tson::Tile::getId() const
192 {
193  return m_id;
194 }
195 
201 const fs::path &tson::Tile::getImage() const { return m_image; }
202 
208 {
209  return m_imageSize;
210 }
211 
216 const std::string &tson::Tile::getType() const
217 {
218  return m_type;
219 }
220 
226 {
227  return m_animation;
228 }
229 
235 {
236  return m_objectgroup;
237 }
238 
244 {
245  return m_properties;
246 }
247 
252 const std::vector<int> &tson::Tile::getTerrain() const
253 {
254  return m_terrain;
255 }
256 
262 tson::Property *tson::Tile::getProp(const std::string &name)
263 {
264  if(m_properties.hasProperty(name))
265  return m_properties.getProperty(name);
266 
267  return nullptr;
268 }
269 
275 {
276  return m_tileset;
277 }
278 
284 {
285  return m_map;
286 }
287 
293 {
294  return m_drawingRect;
295 }
296 
307 const tson::Vector2i tson::Tile::getPositionInTileUnits(const std::tuple<int, int> &tileDataPos)
308 {
309  return {std::get<0>(tileDataPos), std::get<1>(tileDataPos)};
310 }
311 
312 void tson::Tile::manageFlipFlagsByIdThenRemoveFlags(uint32_t &id)
313 {
314  if (id & FLIPPED_HORIZONTALLY_FLAG) m_flipFlags |= TileFlipFlags::Horizontally;
315  if (id & FLIPPED_VERTICALLY_FLAG) m_flipFlags |= TileFlipFlags::Vertically;
316  if (id & FLIPPED_DIAGONALLY_FLAG) m_flipFlags |= TileFlipFlags::Diagonally;
317 
318  id &= ~(FLIPPED_HORIZONTALLY_FLAG | FLIPPED_VERTICALLY_FLAG | FLIPPED_DIAGONALLY_FLAG);
319 }
320 
322 {
323  return m_flipFlags;
324 }
325 
335 {
336  return ((m_flipFlags & flags) == flags) ? true : false;
337 }
338 
339 uint32_t tson::Tile::getGid() const
340 {
341  return m_gid;
342 }
343 
345 {
346  m_properties = properties;
347 }
348 
349 
350 #endif //TILESON_TILE_HPP
Definition: Animation.hpp:11
Definition: IJson.hpp:11
T get(std::string_view key)
Definition: IJson.hpp:72
virtual bool isArray() const =0
virtual size_t count(std::string_view key) const =0
virtual std::vector< std::unique_ptr< IJson > > array()=0
Definition: Layer.hpp:26
Definition: Map.hpp:25
Definition: PropertyCollection.hpp:15
Definition: Property.hpp:21
Definition: Rect.hpp:11
Definition: Tile.hpp:22
const fs::path & getImage() const
Definition: Tile.hpp:201
TileFlipFlags getFlipFlags() const
Definition: Tile.hpp:321
uint32_t getGid() const
Definition: Tile.hpp:339
const tson::Vector2f getPosition(const std::tuple< int, int > &tileDataPos)
Definition: tileson_forward.hpp:82
const std::string & getType() const
Definition: Tile.hpp:216
const std::vector< int > & getTerrain() const
Definition: Tile.hpp:252
PropertyCollection & getProperties()
Definition: Tile.hpp:243
const tson::Vector2i getTileSize() const
Definition: tileson_forward.hpp:25
tson::Property * getProp(const std::string &name)
Definition: Tile.hpp:262
bool parseId(IJson &json)
Definition: tileson_forward.hpp:33
bool hasFlipFlags(TileFlipFlags flags)
Definition: Tile.hpp:334
const Vector2i & getImageSize() const
Definition: Tile.hpp:207
bool parse(IJson &json, tson::Tileset *tileset, tson::Map *map)
Definition: Tile.hpp:144
const Layer & getObjectgroup() const
Definition: Tile.hpp:234
tson::Tileset * getTileset() const
Definition: Tile.hpp:274
Tile()=default
const tson::Vector2i getPositionInTileUnits(const std::tuple< int, int > &tileDataPos)
Definition: Tile.hpp:307
tson::Animation & getAnimation()
Definition: Tile.hpp:225
void addTilesetAndPerformCalculations(tson::Tileset *tileset)
Definition: Tile.hpp:133
tson::Map * getMap() const
Definition: Tile.hpp:283
void setProperties(const tson::PropertyCollection &properties)
Definition: Tile.hpp:344
uint32_t getId() const
Definition: Tile.hpp:191
T get(const std::string &name)
Definition: Tile.hpp:96
const tson::Rect & getDrawingRect() const
Definition: Tile.hpp:292
Definition: Tileset.hpp:24
Definition: Base64.hpp:12
TileFlipFlags
Definition: Enums.hpp:74