Object.hpp

Go to the documentation of this file.

//
// Created by robin on 22.03.2020.
//
 
#ifndef TILESON_OBJECT_HPP
#define TILESON_OBJECT_HPP
 
//#include "../external/json.hpp"
#include "../objects/Vector2.hpp"
#include "../objects/PropertyCollection.hpp"
#include "Text.hpp"
 
#include "../common/Enums.hpp"
#include <optional>
 
namespace tson
{
    class TiledClass;
    class Map;
    class Object
    {
        public:
            //enum class Type : uint8_t
            //{
            //        Undefined = 0,
            //        Object = 1,
            //        Ellipse = 2,
            //        Rectangle = 3,
            //        Point = 4,
            //        Polygon = 5,
            //        Polyline = 6,
            //        Text = 7,
            //        Template = 8
            //};
 
 
            inline Object() = default;
            inline explicit Object(IJson &json, tson::Map *map);
            inline bool parse(IJson &json, tson::Map *map);
 
            [[nodiscard]] inline ObjectType getObjectType() const;
            [[nodiscard]] inline bool isEllipse() const;
            [[nodiscard]] inline uint32_t getGid() const;
            [[nodiscard]] inline const Vector2i &getSize() const;
            [[nodiscard]] inline int getId() const;
            [[nodiscard]] inline const std::string &getName() const;
            [[nodiscard]] inline bool isPoint() const;
            [[nodiscard]] inline float getRotation() const;
            [[nodiscard]] inline const std::string &getTemplate() const;
            [[nodiscard]] inline const std::string &getType() const;
            [[nodiscard]] inline const std::string &getClassType() const;
            [[nodiscard]] inline tson::TiledClass *getClass(); 
            [[nodiscard]] inline bool isVisible() const;
            [[nodiscard]] inline const Vector2i &getPosition() const;
 
            [[nodiscard]] inline const std::vector<tson::Vector2i> &getPolygons() const;
            [[nodiscard]] inline const std::vector<tson::Vector2i> &getPolylines() const;
            [[nodiscard]] inline PropertyCollection &getProperties();
            [[nodiscard]] inline const Text &getText() const;
 
            template <typename T>
            inline T get(const std::string &name);
            inline tson::Property * getProp(const std::string &name);
 
            //v1.2.0-stuff
            [[nodiscard]] inline TileFlipFlags getFlipFlags() const;
            inline bool hasFlipFlags(TileFlipFlags flags);
 
 
        private:
            inline void setObjectTypeByJson(IJson &json, IJson* templ);
 
            ObjectType                        m_objectType = ObjectType::Undefined;    
            bool                              m_ellipse {};                            
            uint32_t                          m_gid {};                                
            tson::Vector2i                    m_size;                                  
            int                               m_id{};                                  
            std::string                       m_name;                                  
            bool                              m_point {};                              
            std::vector<tson::Vector2i>       m_polygon;                               
            std::vector<tson::Vector2i>       m_polyline;                              
            tson::PropertyCollection          m_properties;                            
            float                             m_rotation {};                           
            std::string                       m_template;                              
            tson::Text                        m_text;                                  
            std::string                       m_type;                                  
            bool                              m_visible {};                            
            tson::Vector2i                    m_position;                              
            //v1.2.0-stuff
            tson::TileFlipFlags               m_flipFlags = TileFlipFlags::None;       
            tson::Map *m_map {nullptr};
            std::shared_ptr<tson::TiledClass> m_class {};
    };
 
    template<typename T>
    T tson::Object::get(const std::string &name)
    {
        return m_properties.getValue<T>(name);
    }
 
    inline IJson* readField(const std::string& fieldName,  IJson& main, IJson* templ = nullptr);
 
 
   inline bool readField(Text& field, const std::string& fieldName,  IJson& main, IJson* templ = nullptr);
 
    inline bool readField(std::vector<Vector2i>& field, const std::string& fieldName, IJson& main, IJson* templ = nullptr);
 
    template <typename T> bool readField(T& field, const std::string& fieldName,  IJson& main, IJson* templ = nullptr) 
    {
        IJson* fieldJson = readField(fieldName, main, templ);
        if(fieldJson){
            field = fieldJson->get<T>();
            return true;
        }
        return false;
    }
 
    inline bool readVector(Vector2i& field, const std::string& fieldNameX, const std::string& fieldNameY, IJson& main, IJson* templ = nullptr);
 
    inline void readProperties(tson::PropertyCollection& properties, IJson& json, tson::Map* map);
 
    inline void readGid(uint32_t& gid, TileFlipFlags& flags, IJson& main, IJson* templ = nullptr);
}
 
tson::Object::Object(IJson &json, tson::Map *map)
{
    parse(json, map);
}
 
 
void tson::Object::setObjectTypeByJson(IJson &json, IJson* templ)
{
    m_objectType = ObjectType::Undefined;
    if(m_ellipse)
        m_objectType = ObjectType::Ellipse;
    else if(m_point)
        m_objectType = ObjectType::Point;
    else if(readField("polygon", json, templ))
        m_objectType = ObjectType::Polygon;
    else if(readField("polyline", json, templ))
        m_objectType = ObjectType::Polyline;
    else if(readField("text", json, templ))
        m_objectType = ObjectType::Text;
    else if(readField("gid", json, templ))
        m_objectType = ObjectType::Object;
    else if(json.count("template") > 0)
        m_objectType = ObjectType::Template;
    else
        m_objectType = ObjectType::Rectangle;
}
 
tson::ObjectType tson::Object::getObjectType() const
{
    return m_objectType;
}
 
bool tson::Object::isEllipse() const
{
    return m_ellipse;
}
 
uint32_t tson::Object::getGid() const
{
    return m_gid;
}
 
const tson::Vector2i &tson::Object::getSize() const
{
    return m_size;
}
 
int tson::Object::getId() const
{
    return m_id;
}
 
const std::string &tson::Object::getName() const
{
    return m_name;
}
 
bool tson::Object::isPoint() const
{
    return m_point;
}
 
float tson::Object::getRotation() const
{
    return m_rotation;
}
 
const std::string &tson::Object::getTemplate() const
{
    return m_template;
}
 
const std::string &tson::Object::getType() const
{
    return m_type;
}
 
const std::string &tson::Object::getClassType() const
{
    return m_type;
}
 
bool tson::Object::isVisible() const
{
    return m_visible;
}
 
const tson::Vector2i &tson::Object::getPosition() const
{
    return m_position;
}
 
const std::vector<tson::Vector2i> &tson::Object::getPolygons() const
{
    return m_polygon;
}
 
const std::vector<tson::Vector2i> &tson::Object::getPolylines() const
{
    return m_polyline;
}
 
tson::PropertyCollection &tson::Object::getProperties()
{
    return m_properties;
}
 
const tson::Text &tson::Object::getText() const
{
    return m_text;
}
 
tson::Property *tson::Object::getProp(const std::string &name)
{
    if(m_properties.hasProperty(name))
        return m_properties.getProperty(name);
    return nullptr;
}
 
tson::TileFlipFlags tson::Object::getFlipFlags() const
{
    return m_flipFlags;
}
 
bool tson::Object::hasFlipFlags(TileFlipFlags flags)
{
    return ((m_flipFlags & flags) == flags) ? true : false;
}
 
#endif //TILESON_OBJECT_HPP