Layer.hpp

Go to the documentation of this file.

//
// Created by robin on 22.03.2020.
//
 
#ifndef TILESON_LAYER_HPP
#define TILESON_LAYER_HPP
 
#include <set>
//#include "../external/json.hpp"
#include "../objects/Vector2.hpp"
#include "../objects/Color.hpp"
#include "Chunk.hpp"
#include "Object.hpp"
#include "../objects/TileObject.hpp"
#include "../objects/Property.hpp"
#include "../objects/PropertyCollection.hpp"
#include "../common/Enums.hpp"
#include "../objects/FlaggedTile.hpp"
 
namespace tson
{
    class Tile;
    class Map;
 
    class Layer
    {
        public:
            inline Layer() = default;
            inline Layer(IJson &json, tson::Map *map);
            inline bool parse(IJson &json, tson::Map *map); //Defined in tileson_forward
 
            [[nodiscard]] inline const std::string &getCompression() const;
            [[nodiscard]] inline const std::vector<uint32_t> &getData() const;
            [[nodiscard]] inline const std::string &getBase64Data() const;
            [[nodiscard]] inline const std::string &getDrawOrder() const;
            [[nodiscard]] inline const std::string &getEncoding() const;
            [[nodiscard]] inline int getId() const;
            [[nodiscard]] inline const std::string &getImage() const;
            [[nodiscard]] inline const std::string &getName() const;
            [[nodiscard]] inline const Vector2f &getOffset() const;
            [[nodiscard]] inline float getOpacity() const;
            [[nodiscard]] inline const Vector2i &getSize() const;
            [[nodiscard]] inline const Colori &getTransparentColor() const;
            [[nodiscard]] inline const Vector2f &getParallax() const;
            [[nodiscard]] inline bool hasRepeatX() const;
            [[nodiscard]] inline bool hasRepeatY() const;
 
            [[nodiscard]] inline LayerType getType() const;
            [[nodiscard]] inline const std::string &getClassType() const;
            [[nodiscard]] inline tson::TiledClass *getClass(); 
            [[nodiscard]] inline const std::string &getTypeStr() const;
            [[nodiscard]] inline bool isVisible() const;
            [[nodiscard]] inline int getX() const;
            [[nodiscard]] inline int getY() const;
 
            [[nodiscard]] inline std::vector<tson::Chunk> &getChunks();
            [[nodiscard]] inline std::vector<tson::Layer> &getLayers();
            [[nodiscard]] inline std::vector<tson::Object> &getObjects();
            [[nodiscard]] inline PropertyCollection &getProperties();
 
            inline tson::Object *getObj(int id);
            inline tson::Object *firstObj(const std::string &name);
            inline std::vector<tson::Object> getObjectsByName(const std::string &name);
            inline std::vector<tson::Object> getObjectsByType(tson::ObjectType type);
 
            template <typename T>
            inline T get(const std::string &name);
            inline tson::Property * getProp(const std::string &name);
 
            inline void assignTileMap(std::map<uint32_t, tson::Tile*> *tileMap);
            inline void createTileData(const Vector2i &mapSize, bool isInfiniteMap);
 
            [[nodiscard]] inline const std::map<std::tuple<int, int>, tson::Tile *> &getTileData() const;
            inline tson::Tile * getTileData(int x, int y);
 
            //v1.2.0-stuff
            [[nodiscard]] inline const Colori &getTintColor() const;
            [[nodiscard]] inline tson::Map *getMap() const;
 
            [[nodiscard]] inline std::map<std::tuple<int, int>, tson::TileObject> &getTileObjects();
            inline tson::TileObject * getTileObject(int x, int y);
            [[nodiscard]] inline const std::set<uint32_t> &getUniqueFlaggedTiles() const;
            inline void resolveFlaggedTiles();
 
        private:
            inline void setTypeByString();
 
            std::vector<tson::Chunk>                       m_chunks;                          
            std::string                                    m_compression;                     
            std::vector<uint32_t>                          m_data;                            
            std::string                                    m_base64Data;                      
            std::string                                    m_drawOrder;                       
            std::string                                    m_encoding;                        
            int                                            m_id{};                            
            std::string                                    m_image;                           
            std::vector<tson::Layer>                       m_layers;                          
            std::string                                    m_name;                            
            std::vector<tson::Object>                      m_objects;                         
            tson::Vector2f                                 m_offset;                          
            float                                          m_opacity{};                       
            tson::PropertyCollection                       m_properties;                      
            tson::Vector2i                                 m_size;                            
            tson::Colori                                   m_transparentColor;                
            std::string                                    m_typeStr;                         
            LayerType                                      m_type {LayerType::Undefined};     
            bool                                           m_visible{};                       
            int                                            m_x{};                             
            int                                            m_y{};                             
            tson::Vector2f                                 m_parallax{1.f, 1.f};    
            bool                                           m_repeatX {};                         
            bool                                           m_repeatY {};                         
            std::map<uint32_t, tson::Tile*>                *m_tileMap;
            std::map<std::tuple<int, int>, tson::Tile*>    m_tileData;                        
            //v1.2.0-stuff
            tson::Colori                                        m_tintColor;                  
            inline void decompressData();                                                     
            inline void queueFlaggedTile(size_t x, size_t y, uint32_t id);                    
            tson::Map *                                         m_map;                        
            std::map<std::tuple<int, int>, tson::TileObject>    m_tileObjects;
            std::set<uint32_t>                                  m_uniqueFlaggedTiles;
            std::vector<tson::FlaggedTile>                      m_flaggedTiles;
 
            std::string                                         m_classType{};              
            std::shared_ptr<tson::TiledClass>                   m_class {};
    };
 
    template<typename T>
    T Layer::get(const std::string &name)
    {
        return m_properties.getValue<T>(name);
    }
}
 
tson::Layer::Layer(IJson &json, tson::Map *map)
{
    parse(json, map);
}
 
void tson::Layer::queueFlaggedTile(size_t x, size_t y, uint32_t id)
{
    uint32_t tileId = id;
    tileId &= ~(FLIPPED_HORIZONTALLY_FLAG | FLIPPED_VERTICALLY_FLAG | FLIPPED_DIAGONALLY_FLAG);
    m_uniqueFlaggedTiles.insert(id);
    m_flaggedTiles.emplace_back(x, y, id, tileId);
}
 
std::vector<tson::Object> tson::Layer::getObjectsByName(const std::string &name)
{
    std::vector<tson::Object> found;
 
    std::copy_if(m_objects.begin(), m_objects.end(), std::back_inserter(found), [&](const tson::Object &item)
    {
        return item.getName() == name;
    });
 
    return found;
}
 
 
 
std::vector<tson::Object> tson::Layer::getObjectsByType(tson::ObjectType type)
{
    std::vector<tson::Object> found;
 
    std::copy_if(m_objects.begin(), m_objects.end(), std::back_inserter(found), [&](const tson::Object &item)
    {
        return item.getObjectType() == type;
    });
 
    return found;
}
 
tson::Object *tson::Layer::firstObj(const std::string &name)
{
    auto result = std::find_if(m_objects.begin(), m_objects.end(), [&](const tson::Object &obj){return obj.getName() == name; });
    if(result == m_objects.end())
        return nullptr;
 
    return &result.operator*();
}
 
tson::Object *tson::Layer::getObj(int id)
{
    auto result = std::find_if(m_objects.begin(), m_objects.end(), [&](const tson::Object &obj){return obj.getId() == id; });
    if(result == m_objects.end())
        return nullptr;
 
    return &result.operator*();
}
 
void tson::Layer::setTypeByString()
{
    if(m_typeStr == "tilelayer") m_type = LayerType::TileLayer;
    else if(m_typeStr == "objectgroup") m_type = LayerType::ObjectGroup;
    else if(m_typeStr == "imagelayer") m_type = LayerType::ImageLayer;
    else if(m_typeStr == "group") m_type = LayerType::Group;
    else m_type = LayerType::Undefined;
}
 
const std::string &tson::Layer::getCompression() const
{
    return m_compression;
}
 
const std::vector<uint32_t> &tson::Layer::getData() const
{
    return m_data;
}
 
const std::string &tson::Layer::getBase64Data() const
{
    return m_base64Data;
}
 
const std::string &tson::Layer::getDrawOrder() const
{
    return m_drawOrder;
}
 
const std::string &tson::Layer::getEncoding() const
{
    return m_encoding;
}
 
int tson::Layer::getId() const
{
    return m_id;
}
 
const std::string &tson::Layer::getImage() const
{
    return m_image;
}
 
const std::string &tson::Layer::getName() const
{
    return m_name;
}
 
const tson::Vector2f &tson::Layer::getOffset() const
{
    return m_offset;
}
 
float tson::Layer::getOpacity() const
{
    return m_opacity;
}
 
const tson::Vector2i &tson::Layer::getSize() const
{
    return m_size;
}
 
const tson::Colori &tson::Layer::getTransparentColor() const
{
    return m_transparentColor;
}
 
const std::string &tson::Layer::getTypeStr() const
{
    return m_typeStr;
}
 
bool tson::Layer::isVisible() const
{
    return m_visible;
}
 
int tson::Layer::getX() const
{
    return m_x;
}
 
int tson::Layer::getY() const
{
    return m_y;
}
 
std::vector<tson::Chunk> &tson::Layer::getChunks()
{
    return m_chunks;
}
 
std::vector<tson::Layer> &tson::Layer::getLayers()
{
    return m_layers;
}
 
std::vector<tson::Object> &tson::Layer::getObjects()
{
    return m_objects;
}
 
tson::PropertyCollection &tson::Layer::getProperties()
{
    return m_properties;
}
 
tson::Property *tson::Layer::getProp(const std::string &name)
{
    if(m_properties.hasProperty(name))
        return m_properties.getProperty(name);
    return nullptr;
}
 
tson::LayerType tson::Layer::getType() const
{
    return m_type;
}
 
void tson::Layer::assignTileMap(std::map<uint32_t, tson::Tile *> *tileMap)
{
    m_tileMap = tileMap;
}
 
const std::map<std::tuple<int, int>, tson::Tile *> &tson::Layer::getTileData() const
{
    return m_tileData;
}
 
tson::Tile *tson::Layer::getTileData(int x, int y)
{
    return (m_tileData.count({x, y}) > 0) ? m_tileData[{x,y}] : nullptr;
}
 
tson::Map *tson::Layer::getMap() const
{
    return m_map;
}
 
void tson::Layer::createTileData(const Vector2i &mapSize, bool isInfiniteMap)
{
    size_t x = 0;
    size_t y = 0;
    if(!isInfiniteMap)
    {
        std::for_each(m_data.begin(), m_data.end(), [&](uint32_t tileId)
        {
            if (static_cast<int>(x) == mapSize.x)
            {
                ++y;
                x = 0;
            }
 
            if (tileId > 0 && m_tileMap->count(tileId) > 0)
            {
                m_tileData[{static_cast<int>(x), static_cast<int>(y)}] = m_tileMap->at(tileId);
                m_tileObjects[{static_cast<int>(x), static_cast<int>(y)}] = {{static_cast<int>(x), static_cast<int>(y)}, m_tileData[{static_cast<int>(x), static_cast<int>(y)}]};
            }
            else if(tileId > 0 && m_tileMap->count(tileId) == 0) //Tile with flip flags!
            {
                queueFlaggedTile(x, y, tileId);
            }
            x++;
        });
 
    }
}
 
std::map<std::tuple<int, int>, tson::TileObject> &tson::Layer::getTileObjects()
{
    return m_tileObjects;
}
 
tson::TileObject *tson::Layer::getTileObject(int x, int y)
{
    return (m_tileObjects.count({x, y}) > 0) ? &m_tileObjects[{x,y}] : nullptr;
}
 
const std::set<uint32_t> &tson::Layer::getUniqueFlaggedTiles() const
{
    return m_uniqueFlaggedTiles;
}
 
void tson::Layer::resolveFlaggedTiles()
{
    std::for_each(m_flaggedTiles.begin(), m_flaggedTiles.end(), [&](const tson::FlaggedTile &tile)
    {
        if (tile.id > 0 && m_tileMap->count(tile.id) > 0)
        {
            m_tileData[{static_cast<int>(tile.x), static_cast<int>(tile.y)}] = m_tileMap->at(tile.id);
            m_tileObjects[{static_cast<int>(tile.x), static_cast<int>(tile.y)}] = {{static_cast<int>(tile.x), static_cast<int>(tile.y)}, m_tileData[{static_cast<int>(tile.x), static_cast<int>(tile.y)}]};
        }
    });
}
 
const tson::Colori &tson::Layer::getTintColor() const
{
    return m_tintColor;
}
 
const tson::Vector2f &tson::Layer::getParallax() const
{
    return m_parallax;
}
 
bool tson::Layer::hasRepeatX() const
{
    return m_repeatX;
}
 
bool tson::Layer::hasRepeatY() const
{
    return m_repeatY;
}
 
const std::string &tson::Layer::getClassType() const
{
    return m_classType;
}
 
 
#endif //TILESON_LAYER_HPP