Tile.hpp

Go to the documentation of this file.

#ifndef CORE_MAPS_TILE_HPP
#define CORE_MAPS_TILE_HPP
 
#include <BLIB/Graphics.hpp>
#include <BLIB/Serialization.hpp>
#include <SFML/Graphics.hpp>
#include <functional>
#include <variant>
 
namespace editor
{
namespace component
{
class EditMap;
}
} // namespace editor
 
namespace core
{
namespace map
{
class Tileset;
 
class Tile {
public:
    // The type of tile ids in Tileset
    using IdType = std::uint16_t;
 
    static constexpr IdType Blank = 0;
 
    Tile();
 
    Tile(const Tile& copy) = default;
 
    Tile& operator=(const Tile& copy) = default;
 
    Tile(IdType id, bool isAnim = false);
 
    bool isAnimation() const;
 
    IdType id() const;
 
    void set(IdType id, bool anim);
 
    void step();
 
private:
    bool isAnim;
    IdType tid;
 
    std::variant<std::monostate, bl::gfx::BatchSpriteSimple, bl::gfx::BatchSlideshowSimple,
                 std::shared_ptr<bl::gfx::Animation2D>>
        renderObject;
 
    friend class Map;
    friend class editor::component::EditMap;
    friend struct bl::serial::SerializableObject<Tile>;
};
 
} // namespace map
} // namespace core
 
namespace bl
{
namespace serial
{
namespace binary
{
template<>
struct Serializer<core::map::Tile, false> {
    static bool serialize(OutputStream& output, const core::map::Tile& tile) {
        if (!Serializer<core::map::Tile::IdType>::serialize(output, tile.id())) return false;
        return Serializer<bool>::serialize(output, tile.isAnimation());
    }
 
    static bool deserialize(InputStream& input, core::map::Tile& result) {
        core::map::Tile::IdType id;
        bool isAnim;
        if (!Serializer<core::map::Tile::IdType>::deserialize(input, id)) return false;
        if (!Serializer<bool>::deserialize(input, isAnim)) return false;
        result.set(id, isAnim);
        return true;
    }
 
    static std::uint32_t size(const core::map::Tile&) {
        return Serializer<core::map::Tile::IdType>::size(core::map::Tile::Blank) +
               Serializer<bool>::size(false);
    }
};
} // namespace binary
 
template<>
struct SerializableObject<core::map::Tile> : public SerializableObjectBase {
    SerializableField<1, core::map::Tile, bool> anim;
    SerializableField<2, core::map::Tile, core::map::Tile::IdType> id;
 
    SerializableObject()
    : SerializableObjectBase("Tile")
    , anim("anim", *this, &core::map::Tile::isAnim, SerializableFieldBase::Required{})
    , id("id", *this, &core::map::Tile::tid, SerializableFieldBase::Required{}) {}
};
 
} // namespace serial
} // namespace bl
 
#endif