Tile.hpp

Go to the documentation of this file.

//
// Created by robin on 22.03.2020.
//
 
#ifndef TILESON_TILE_HPP
#define TILESON_TILE_HPP
 
//#include "../external/json.hpp"
#include "../objects/Vector2.hpp"
#include "../objects/Color.hpp"
#include "Frame.hpp"
#include "Animation.hpp"
#include "../objects/PropertyCollection.hpp"
#include "Layer.hpp"
#include "../objects/Rect.hpp"
 
namespace tson
{
    class Tileset;
    class TiledClass;
 
    class Tile
    {
        public:
            inline Tile() = default;
            inline Tile(IJson &json, tson::Tileset *tileset, tson::Map *map);
            inline Tile(uint32_t id, tson::Tileset *tileset, tson::Map *map);
            inline Tile(uint32_t id, tson::Map *map); //v1.2.0
            inline bool parse(IJson &json, tson::Tileset *tileset, tson::Map *map);
            inline bool parseId(IJson &json);
 
            [[nodiscard]] inline uint32_t getId() const;
            [[nodiscard]] inline const fs::path &getImage() const;
            [[nodiscard]] inline const Vector2i &getImageSize() const;
            [[nodiscard]] inline const std::string &getType() const;
            [[nodiscard]] inline const std::string &getClassType() const;
            [[nodiscard]] inline tson::TiledClass *getClass(); 
            //[[nodiscard]] inline const std::vector<tson::Frame> &getAnimation() const;
            [[nodiscard]] inline tson::Animation &getAnimation();
            [[nodiscard]] inline Layer &getObjectgroup();
            [[nodiscard]] inline PropertyCollection &getProperties();
            [[nodiscard]] inline const std::vector<int> &getTerrain() const;
 
            template <typename T>
            inline T get(const std::string &name);
            inline tson::Property * getProp(const std::string &name);
 
            //v1.2.0-stuff
            inline void setProperties(const tson::PropertyCollection &properties);
 
            [[nodiscard]] inline tson::Tileset * getTileset() const;
            [[nodiscard]] inline tson::Map * getMap() const;
            [[nodiscard]] inline const tson::Rect &getDrawingRect() const;
            [[nodiscard]] inline const Rect &getSubRectangle() const;
 
            inline const tson::Vector2f getPosition(const std::tuple<int, int> &tileDataPos);
            inline const tson::Vector2i getPositionInTileUnits(const std::tuple<int, int> &tileDataPos);
            [[nodiscard]] inline const tson::Vector2i getTileSize() const;                       
            [[nodiscard]] inline TileFlipFlags getFlipFlags() const;
            inline bool hasFlipFlags(TileFlipFlags flags);
            [[nodiscard]] inline uint32_t getGid() const;
 
            inline void addTilesetAndPerformCalculations(tson::Tileset *tileset); //v1.2.0
 
 
        private:
            tson::Animation                  m_animation{};      
            uint32_t                         m_id {};            
            fs::path                         m_image;            
            tson::Vector2i                   m_imageSize;        
            tson::Layer                      m_objectgroup;         
            tson::PropertyCollection         m_properties;      
            std::vector<int>                 m_terrain;          
            std::string                      m_type;             
            //v1.2.0-stuff
            uint32_t                    m_gid {};                                    
            tson::Tileset *             m_tileset;                                   
            tson::Map *                 m_map;                                       
            tson::Rect                  m_drawingRect;                               
            tson::Rect                  m_subRect;                                   
            tson::TileFlipFlags         m_flipFlags = TileFlipFlags::None;           
            inline void performDataCalculations();                                   
            inline void manageFlipFlagsByIdThenRemoveFlags(uint32_t &id);
            friend class Layer;
            std::shared_ptr<tson::TiledClass> m_class {};
    };
 
    template<typename T>
    T tson::Tile::get(const std::string &name)
    {
        return m_properties.getValue<T>(name);
    }
}
 
tson::Tile::Tile(IJson &json, tson::Tileset *tileset, tson::Map *map)
{
    parse(json, tileset, map);
}
 
tson::Tile::Tile(uint32_t id, tson::Tileset *tileset, tson::Map *map) : m_id {id}, m_gid {id}
{
    m_tileset = tileset;
    m_map = map;
    manageFlipFlagsByIdThenRemoveFlags(m_gid);
    performDataCalculations();
}
 
tson::Tile::Tile(uint32_t id, tson::Map *map) : m_id {id}, m_gid {id}
{
    m_map = map;
    manageFlipFlagsByIdThenRemoveFlags(m_gid);
}
 
void tson::Tile::addTilesetAndPerformCalculations(tson::Tileset *tileset)
{
    m_tileset = tileset;
    performDataCalculations();
}
 
 
 
uint32_t tson::Tile::getId() const
{
    return m_id;
}
 
const fs::path &tson::Tile::getImage() const { return m_image; }
 
const tson::Vector2i &tson::Tile::getImageSize() const
{
    return m_imageSize;
}
 
const std::string &tson::Tile::getType() const
{
    return m_type;
}
 
const std::string &tson::Tile::getClassType() const
{
    return m_type;
}
 
tson::Animation &tson::Tile::getAnimation()
{
    return m_animation;
}
 
tson::Layer &tson::Tile::getObjectgroup()
{
    return m_objectgroup;
}
 
tson::PropertyCollection &tson::Tile::getProperties()
{
    return m_properties;
}
 
const std::vector<int> &tson::Tile::getTerrain() const
{
    return m_terrain;
}
 
tson::Property *tson::Tile::getProp(const std::string &name)
{
    if(m_properties.hasProperty(name))
        return m_properties.getProperty(name);
 
    return nullptr;
}
 
tson::Tileset *tson::Tile::getTileset() const
{
    return m_tileset;
}
 
tson::Map *tson::Tile::getMap() const
{
    return m_map;
}
 
const tson::Rect &tson::Tile::getDrawingRect() const
{
    return m_drawingRect;
}
 
const tson::Vector2i tson::Tile::getPositionInTileUnits(const std::tuple<int, int> &tileDataPos)
{
    return {std::get<0>(tileDataPos), std::get<1>(tileDataPos)};
}
 
void tson::Tile::manageFlipFlagsByIdThenRemoveFlags(uint32_t &id)
{
    if (id & FLIPPED_HORIZONTALLY_FLAG) m_flipFlags |= TileFlipFlags::Horizontally;
    if (id & FLIPPED_VERTICALLY_FLAG) m_flipFlags |= TileFlipFlags::Vertically;
    if (id & FLIPPED_DIAGONALLY_FLAG) m_flipFlags |= TileFlipFlags::Diagonally;
 
    id &= ~(FLIPPED_HORIZONTALLY_FLAG | FLIPPED_VERTICALLY_FLAG | FLIPPED_DIAGONALLY_FLAG);
}
 
tson::TileFlipFlags tson::Tile::getFlipFlags() const
{
    return m_flipFlags;
}
 
bool tson::Tile::hasFlipFlags(tson::TileFlipFlags flags)
{
    return ((m_flipFlags & flags) == flags) ? true : false;
}
 
uint32_t tson::Tile::getGid() const
{
    return m_gid;
}
 
void tson::Tile::setProperties(const tson::PropertyCollection &properties)
{
    m_properties = properties;
}
 
const tson::Rect &tson::Tile::getSubRectangle() const
{
    return m_subRect;
}
 
 
#endif //TILESON_TILE_HPP