WangColor.hpp

Go to the documentation of this file.

//
// Created by robin on 22.03.2020.
//
 
#ifndef TILESON_WANGCOLOR_HPP
#define TILESON_WANGCOLOR_HPP
 
//#include "../external/json.hpp"
#include "../objects/Color.hpp"
 
namespace tson
{
    class WangColor
    {
        public:
            inline WangColor() = default;
            inline explicit WangColor(IJson &json, tson::Map *map);
            inline bool parse(IJson &json, tson::Map *map);
 
            [[nodiscard]] inline const Colori &getColor() const;
            [[nodiscard]] inline const std::string &getName() const;
            [[nodiscard]] inline float getProbability() const;
            [[nodiscard]] inline int getTile() const;
 
            inline PropertyCollection &getProperties();
            template <typename T>
            inline T get(const std::string &name);
            inline tson::Property * getProp(const std::string &name);
 
            [[nodiscard]] inline const std::string &getClassType() const;
            [[nodiscard]] inline tson::TiledClass *getClass(); 
        private:
            tson::Colori      m_color;              
            std::string       m_name;               
            float             m_probability{};      
            int               m_tile{};             
            //New in Tiled v1.5
            tson::PropertyCollection     m_properties;    
            tson::Map *                  m_map;
            std::string                  m_classType {};              
            std::shared_ptr<tson::TiledClass> m_class {};
 
    };
}
 
tson::WangColor::WangColor(IJson &json, tson::Map *map)
{
    parse(json, map);
}
 
bool tson::WangColor::parse(IJson &json, tson::Map *map)
{
    m_map = map;
    bool allFound = true;
 
    if(json.count("color") > 0) m_color = tson::Colori(json["color"].get<std::string>()); else allFound = false;
    if(json.count("name") > 0) m_name = json["name"].get<std::string>(); else allFound = false;
    if(json.count("probability") > 0) m_probability = json["probability"].get<float>(); else allFound = false;
    if(json.count("tile") > 0) m_tile = json["tile"].get<int>(); else allFound = false;
    if(json.count("class") > 0) m_classType = json["class"].get<std::string>();                     //Optional
 
    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); });
    }
 
 
    return allFound;
}
 
const tson::Colori &tson::WangColor::getColor() const
{
    return m_color;
}
 
const std::string &tson::WangColor::getName() const
{
    return m_name;
}
 
float tson::WangColor::getProbability() const
{
    return m_probability;
}
 
int tson::WangColor::getTile() const
{
    return m_tile;
}
 
tson::PropertyCollection &tson::WangColor::getProperties()
{
    return m_properties;
}
 
template<typename T>
T tson::WangColor::get(const std::string &name)
{
    return m_properties.getValue<T>(name);
}
 
tson::Property *tson::WangColor::getProp(const std::string &name)
{
    if(m_properties.hasProperty(name))
        return m_properties.getProperty(name);
 
    return nullptr;
}
 
const std::string &tson::WangColor::getClassType() const
{
    return m_classType;
}
 
#endif //TILESON_WANGCOLOR_HPP