LayerSet.hpp

Go to the documentation of this file.

#ifndef CORE_MAPS_LAYERSET_HPP
#define CORE_MAPS_LAYERSET_HPP
 
#include <Core/Maps/Collision.hpp>
#include <Core/Maps/Layer.hpp>
#include <Core/Maps/Tile.hpp>
 
namespace core
{
namespace map
{
using CollisionLayer = Layer<Collision>;
 
using CatchLayer = Layer<std::uint8_t>;
 
using TileLayer = Layer<Tile>;
 
using HeightTransitionLayer = Layer<std::uint8_t>;
 
class LayerSet {
public:
    LayerSet() = default;
 
    void init(unsigned int width, unsigned int height, unsigned int bottomLayerCount,
              unsigned int ysortLayerCount, unsigned int topLayercount);
 
    CollisionLayer& collisionLayer();
 
    const CollisionLayer& collisionLayer() const;
 
    CatchLayer& catchLayer();
 
    const CatchLayer& catchLayer() const;
 
    std::vector<TileLayer>& bottomLayers();
 
    std::vector<TileLayer>& ysortLayers();
 
    std::vector<TileLayer>& topLayers();
 
    const std::vector<TileLayer>& bottomLayers() const;
 
    const std::vector<TileLayer>& ysortLayers() const;
 
    const std::vector<TileLayer>& topLayers() const;
 
    unsigned int layerCount() const;
 
    TileLayer& getLayer(unsigned int layer);
 
private:
    CollisionLayer collisions;
    CatchLayer catches;
    std::vector<TileLayer> bottom;
    std::vector<TileLayer> ysort;
    std::vector<TileLayer> top;
 
    friend struct bl::serial::SerializableObject<LayerSet>;
};
 
} // namespace map
} // namespace core
 
namespace bl
{
namespace serial
{
template<>
struct SerializableObject<core::map::LayerSet> : public SerializableObjectBase {
    SerializableField<1, core::map::LayerSet, core::map::CollisionLayer> collisions;
    SerializableField<2, core::map::LayerSet, core::map::CatchLayer> catches;
    SerializableField<3, core::map::LayerSet, std::vector<core::map::TileLayer>> bottom;
    SerializableField<4, core::map::LayerSet, std::vector<core::map::TileLayer>> ysort;
    SerializableField<5, core::map::LayerSet, std::vector<core::map::TileLayer>> top;
 
    SerializableObject()
    : SerializableObjectBase("LayerSet")
    , collisions("cols", *this, &core::map::LayerSet::collisions, SerializableFieldBase::Required{})
    , catches("catches", *this, &core::map::LayerSet::catches, SerializableFieldBase::Required{})
    , bottom("bottom", *this, &core::map::LayerSet::bottom, SerializableFieldBase::Required{})
    , ysort("ysort", *this, &core::map::LayerSet::ysort, SerializableFieldBase::Required{})
    , top("top", *this, &core::map::LayerSet::top, SerializableFieldBase::Required{}) {}
};
 
} // namespace serial
} // namespace bl
 
#endif