Tileset.hpp

Go to the documentation of this file.

//
// Created by robin on 22.03.2020.
//
 
#ifndef TILESON_TILESET_HPP
#define TILESON_TILESET_HPP
 
//#include "../external/json.hpp"
 
#include "../objects/Vector2.hpp"
#include "../objects/Color.hpp"
#include "../objects/PropertyCollection.hpp"
#include "Transformations.hpp"
#include "WangSet.hpp"
#include "Tile.hpp"
#include "Terrain.hpp"
#include "Grid.hpp"
#include <functional>
 
namespace tson
{
    class Map;
    class Tileset
    {
        public:
            inline Tileset() = default;
            inline explicit Tileset(IJson &json, tson::Map *map);
            inline bool parse(IJson &json, tson::Map *map);
 
            [[nodiscard]] inline int getColumns() const;
            [[nodiscard]] inline int getFirstgid() const;
 
            [[nodiscard]] inline const fs::path &getImagePath() const;
            [[nodiscard]] inline const fs::path &getImage() const;
            [[nodiscard]] inline const Vector2i &getImageSize() const;
            [[nodiscard]] inline int getMargin() const;
            [[nodiscard]] inline const std::string &getName() const;
            [[nodiscard]] inline int getSpacing() const;
            [[nodiscard]] inline int getTileCount() const;
            [[nodiscard]] inline const Vector2i &getTileSize() const;
            [[nodiscard]] inline const Colori &getTransparentColor() const;
            [[nodiscard]] inline const std::string &getType() const;
            [[nodiscard]] inline const std::string &getClassType() const;
            [[nodiscard]] inline tson::TiledClass *getClass(); 
            [[nodiscard]] inline std::vector<tson::Tile> &getTiles();
            [[nodiscard]] inline const std::vector<tson::WangSet> &getWangsets() const;
            [[nodiscard]] inline PropertyCollection &getProperties();
            [[nodiscard]] inline const std::vector<tson::Terrain> &getTerrains() const;
            [[nodiscard]] inline const Vector2i &getTileOffset() const;
            [[nodiscard]] inline const Grid &getGrid() const;
            [[nodiscard]] inline TileRenderSize getTileRenderSize() const;
            [[nodiscard]] inline FillMode getFillMode() const;
 
            inline tson::Tile * getTile(uint32_t id);
            inline tson::Terrain * getTerrain(const std::string &name);
 
            template <typename T>
            inline T get(const std::string &name);
            inline tson::Property * getProp(const std::string &name);
 
            //v1.2.0-stuff
            [[nodiscard]] inline tson::Map *getMap() const;
            [[nodiscard]] inline ObjectAlignment getObjectAlignment() const;
 
            inline static tson::ObjectAlignment StringToAlignment(std::string_view str);
 
            //v1.3.0
            inline tson::Vector2i getMarginSpacingOffset(const tson::Vector2i &posInTileUnits);
            inline tson::WangSet * getWangset(const std::string &name);
            inline const Transformations &getTransformations() const;
 
 
            #ifndef TSON_TEST_ENABLED
        private:
            #endif
            inline void generateMissingTiles();
 
            int                           m_columns {};       
            int                           m_firstgid {};      
            fs::path                      m_image;            
            tson::Vector2i                m_imageSize;        
            int                           m_margin {};        
            std::string                   m_name;             
            int                           m_spacing {};       
            int                           m_tileCount {};     
            tson::Vector2i                m_tileSize;         
            tson::Colori                  m_transparentColor; 
            std::string                   m_type;             
            std::vector<tson::Tile>       m_tiles;            
            std::vector<tson::WangSet>    m_wangsets;         
            tson::PropertyCollection      m_properties;       
            std::vector<tson::Terrain>    m_terrains;         
            tson::Vector2i                m_tileOffset;       
            tson::Grid                    m_grid;             
            //v1.2.0-stuff
            tson::ObjectAlignment         m_objectAlignment{tson::ObjectAlignment::Unspecified};  
            tson::Map *                   m_map;              
            //v1.3.0-stuff
            fs::path                      m_source {};           
            fs::path                      m_path {};             
            Transformations               m_transformations {};  
            //v1.4.0-stuff
            TileRenderSize                m_tileRenderSize {};   
            FillMode                      m_fillMode {};         
            std::string                   m_classType {};              
            std::shared_ptr<tson::TiledClass> m_class {};
    };
 
    template<typename T>
    T tson::Tileset::get(const std::string &name)
    {
        return m_properties.getValue<T>(name);
    }
}
 
tson::Tileset::Tileset(IJson &json, tson::Map *map)
{
    parse(json, map);
}
 
bool tson::Tileset::parse(IJson &json, tson::Map *map)
{
    m_map = map;
    bool allFound = true;
 
    if(json.count("firstgid") > 0) m_firstgid = json["firstgid"].get<int>(); else allFound = false;
 
    //Tileset is stored in external file if 'source' exists
    if(json.count("source") > 0)
    {
        if(!allFound)
            return allFound;
 
        std::string sourceStr = json["source"].get<std::string>();
        m_source = fs::path(sourceStr);
        m_path = json.directory() / m_source;
 
        if(!json.parse(m_path))
            return false;
    }
 
 
    if(json.count("columns") > 0) m_columns = json["columns"].get<int>(); else allFound = false;
 
    if(json.count("image") > 0) m_image = fs::path(json["image"].get<std::string>()); else allFound = false;
 
    if(json.count("margin") > 0) m_margin = json["margin"].get<int>(); else allFound = false;
    if(json.count("name") > 0) m_name = json["name"].get<std::string>(); else allFound = false;
    if(json.count("spacing") > 0) m_spacing = json["spacing"].get<int>(); else allFound = false;
    if(json.count("tilecount") > 0) m_tileCount = json["tilecount"].get<int>(); else allFound = false;
    if(json.count("transparentcolor") > 0) m_transparentColor = tson::Colori(json["transparentcolor"].get<std::string>()); //Optional
    if(json.count("type") > 0) m_type = json["type"].get<std::string>();
    if(json.count("grid") > 0) m_grid = tson::Grid(json["grid"]);
    if(json.count("class") > 0) m_classType = json["class"].get<std::string>();                     //Optional
 
    if(json.count("imagewidth") > 0 && json.count("imageheight") > 0)
        m_imageSize = {json["imagewidth"].get<int>(), json["imageheight"].get<int>()}; else allFound = false;
    if(json.count("tilewidth") > 0 && json.count("tileheight") > 0)
        m_tileSize = {json["tilewidth"].get<int>(), json["tileheight"].get<int>()}; else allFound = false;
    if(json.count("tileoffset") > 0)
        m_tileOffset = {json["tileoffset"]["x"].get<int>(), json["tileoffset"]["y"].get<int>()};
 
    if(json.count("tilerendersize") > 0)
    {
        std::string tileRenderStr = json["tilerendersize"].get<std::string>();
        if(tileRenderStr == "tile") m_tileRenderSize = TileRenderSize::Tile;
        else if(tileRenderStr == "grid") m_tileRenderSize = TileRenderSize::Grid;
    }
 
    if(json.count("fillmode") > 0)
    {
        std::string fillmode = json["fillmode"].get<std::string>();
        if(fillmode == "stretch") m_fillMode = FillMode::Stretch;
        else if(fillmode == "preserve-aspect-fit") m_fillMode = FillMode::PreserveAspectFit;
    }
 
    //More advanced data
    if(json.count("wangsets") > 0 && json["wangsets"].isArray())
    {
        auto &wangsets = json.array("wangsets");
        std::for_each(wangsets.begin(), wangsets.end(), [&](std::unique_ptr<IJson> &item) { m_wangsets.emplace_back(*item, m_map); });
    }
    if(json.count("tiles") > 0 && json["tiles"].isArray())
    {
        auto &tiles = json.array("tiles");
        std::for_each(tiles.begin(), tiles.end(), [&](std::unique_ptr<IJson> &item) { m_tiles.emplace_back(*item, this, m_map); });
    }
    if(json.count("terrains") > 0 && json["terrains"].isArray())
    {
        auto &terrains = json.array("terrains");
        std::for_each(terrains.begin(), terrains.end(), [&](std::unique_ptr<IJson> &item) { m_terrains.emplace_back(*item); });
    }
 
    if(json.count("properties") > 0 && json["properties"].isArray())
    {
        auto &properties = json.array("properties");
        std::for_each(properties.begin(), properties.end(), [&](std::unique_ptr<IJson> &item) { m_properties.add(*item); });
    }
 
    if(json.count("objectalignment") > 0)
    {
        std::string alignment = json["objectalignment"].get<std::string>();
        m_objectAlignment = StringToAlignment(alignment);
    }
 
    if(json.count("transformations") > 0)
    {
        m_transformations.parse(json["transformations"]);
    }
 
    generateMissingTiles();
 
    return allFound;
}
 
int tson::Tileset::getColumns() const
{
    return m_columns;
}
 
int tson::Tileset::getFirstgid() const
{
    return m_firstgid;
}
 
const fs::path &tson::Tileset::getImagePath() const { return m_image; }
 
const tson::Vector2i &tson::Tileset::getImageSize() const
{
    return m_imageSize;
}
 
int tson::Tileset::getMargin() const
{
    return m_margin;
}
 
const std::string &tson::Tileset::getName() const
{
    return m_name;
}
 
int tson::Tileset::getSpacing() const
{
    return m_spacing;
}
 
int tson::Tileset::getTileCount() const
{
    return m_tileCount;
}
 
const tson::Vector2i &tson::Tileset::getTileSize() const
{
    return m_tileSize;
}
 
const tson::Colori &tson::Tileset::getTransparentColor() const
{
    return m_transparentColor;
}
 
const std::string &tson::Tileset::getType() const
{
    return m_type;
}
 
const fs::path &tson::Tileset::getImage() const { return m_image; }
 
std::vector<tson::Tile> &tson::Tileset::getTiles()
{
    return m_tiles;
}
 
const std::vector<tson::WangSet> &tson::Tileset::getWangsets() const
{
    return m_wangsets;
}
 
tson::PropertyCollection &tson::Tileset::getProperties()
{
    return m_properties;
}
 
const std::vector<tson::Terrain> &tson::Tileset::getTerrains() const
{
    return m_terrains;
}
 
const tson::Vector2i &tson::Tileset::getTileOffset() const
{
    return m_tileOffset;
}
 
const tson::Grid &tson::Tileset::getGrid() const
{
    return m_grid;
}
 
tson::Tile *tson::Tileset::getTile(uint32_t id)
{
    auto result = std::find_if(m_tiles.begin(), m_tiles.end(), [&](const tson::Tile & item) { return item.getId() == id;});
    if(result == m_tiles.end())
        return nullptr;
 
    return &result.operator*();
}
 
tson::Terrain *tson::Tileset::getTerrain(const std::string &name)
{
    auto result = std::find_if(m_terrains.begin(), m_terrains.end(), [&](const tson::Terrain & item) { return item.getName() == name;});
    if(result == m_terrains.end())
        return nullptr;
 
    return &result.operator*();
}
 
tson::Property *tson::Tileset::getProp(const std::string &name)
{
    if(m_properties.hasProperty(name))
        return m_properties.getProperty(name);
 
    return nullptr;
}
 
void tson::Tileset::generateMissingTiles()
{
    std::vector<uint32_t> tileIds;
    for(auto &tile : m_tiles)
        tileIds.push_back(tile.getId());
 
    for(uint32_t i = m_firstgid; i < m_firstgid + (uint32_t) m_tileCount; ++i)
    {
        if(std::count(tileIds.begin(), tileIds.end(), i) == 0)
        {
            m_tiles.emplace_back(Tile(i, this, m_map));
        }
    }
}
 
tson::Map *tson::Tileset::getMap() const
{
    return m_map;
}
 
tson::ObjectAlignment tson::Tileset::StringToAlignment(std::string_view str)
{
    if(str == "unspecified") return tson::ObjectAlignment::Unspecified;
    else if(str == "topleft") return tson::ObjectAlignment::TopLeft;
    else if(str == "top") return tson::ObjectAlignment::Top;
    else if(str == "topright") return tson::ObjectAlignment::TopRight;
    else if(str == "left") return tson::ObjectAlignment::Left;
    else if(str == "center") return tson::ObjectAlignment::Center;
    else if(str == "right") return tson::ObjectAlignment::Right;
    else if(str == "bottomleft") return tson::ObjectAlignment::BottomLeft;
    else if(str == "bottom") return tson::ObjectAlignment::Bottom;
    else if(str == "bottomright") return tson::ObjectAlignment::BottomRight;
    else
        return tson::ObjectAlignment::Unspecified;
}
 
tson::ObjectAlignment tson::Tileset::getObjectAlignment() const
{
    return m_objectAlignment;
}
 
tson::Vector2i tson::Tileset::getMarginSpacingOffset(const tson::Vector2i &posInTileUnits)
{
    if(m_margin == 0 && m_spacing == 0)
        return {0,0};
 
    tson::Vector2i offset {(posInTileUnits.x * m_spacing) + m_margin, (posInTileUnits.y * m_spacing) + m_margin};
    return offset;
}
 
tson::WangSet *tson::Tileset::getWangset(const std::string &name)
{
    auto wangset = std::find_if(m_wangsets.begin(), m_wangsets.end(), [&](const auto &w) { return w.getName() == name; });
 
    if(wangset != m_wangsets.end())
        return &wangset.operator*();
 
    return nullptr;
}
 
const tson::Transformations &tson::Tileset::getTransformations() const
{
    return m_transformations;
}
 
tson::TileRenderSize tson::Tileset::getTileRenderSize() const
{
    return m_tileRenderSize;
}
 
tson::FillMode tson::Tileset::getFillMode() const
{
    return m_fillMode;
}
 
const std::string &tson::Tileset::getClassType() const
{
    return m_classType;
}
 
 
#endif //TILESON_TILESET_HPP