Behavior.hpp

Go to the documentation of this file.

#ifndef CORE_FILES_BEHAVIOR_HPP
#define CORE_FILES_BEHAVIOR_HPP
 
#include <BLIB/Serialization.hpp>
#include <BLIB/Tilemap/Direction.hpp>
#include <cstdint>
#include <variant>
 
namespace core
{
namespace file
{
class Behavior {
public:
    enum Type : std::uint8_t {
        StandStill = 0,
 
        SpinInPlace = 1,
 
        FollowingPath = 2,
 
        Wandering = 3
    };
 
    struct Standing {
        bl::tmap::Direction facedir;
 
        Standing(bl::tmap::Direction d);
 
        Standing();
    };
 
    struct Spinning {
        enum Direction : std::uint8_t {
            Clockwise = 0,
 
            Counterclockwise = 1,
 
            Random = 2
        } spinDir;
 
        Spinning(Direction dir);
 
        Spinning();
    };
 
    struct Path {
        struct Pace {
            bl::tmap::Direction direction;
 
            std::uint16_t steps;
 
            Pace(bl::tmap::Direction dir, std::uint16_t steps);
 
            Pace();
        };
 
        std::vector<Pace> paces;
 
        bool reverse;
 
        Path();
    };
 
    struct Wander {
        std::uint32_t radius;
 
        Wander(std::uint32_t r);
 
        Wander();
    };
 
    Behavior();
 
    bool legacyLoad(bl::serial::binary::InputStream& input);
 
    Type type() const;
 
    void setType(Type type);
 
    Standing& standing();
 
    Spinning& spinning();
 
    Path& path();
 
    Wander& wander();
 
    const Standing& standing() const;
 
    const Spinning& spinning() const;
 
    const Path& path() const;
 
    const Wander& wander() const;
 
private:
    Type _type;
    std::variant<Standing, Spinning, Path, Wander> data;
 
    friend struct bl::serial::binary::Serializer<Behavior>;
    friend struct bl::serial::SerializableObject<Behavior>;
};
 
} // namespace file
} // namespace core
 
namespace bl
{
namespace serial
{
template<>
struct SerializableObject<core::file::Behavior::Path::Pace> : public SerializableObjectBase {
    using P = core::file::Behavior::Path::Pace;
 
    SerializableField<1, P, bl::tmap::Direction> direction;
    SerializableField<2, P, std::uint16_t> steps;
 
    SerializableObject()
    : SerializableObjectBase("BehaviorPathPace")
    , direction("direction", *this, &P::direction, SerializableFieldBase::Required{})
    , steps("steps", *this, &P::steps, SerializableFieldBase::Required{}) {}
};
 
template<>
struct SerializableObject<core::file::Behavior::Path> : public SerializableObjectBase {
    using P = core::file::Behavior::Path;
 
    SerializableField<1, P, std::vector<P::Pace>> paces;
    SerializableField<2, P, bool> reverse;
 
    SerializableObject()
    : SerializableObjectBase("BehaviorPath")
    , paces("paces", *this, &P::paces, SerializableFieldBase::Required{})
    , reverse("reverse", *this, &P::reverse, SerializableFieldBase::Required{}) {}
};
 
template<>
struct SerializableObject<core::file::Behavior::Standing> : public SerializableObjectBase {
    using S = core::file::Behavior::Standing;
 
    SerializableField<1, S, bl::tmap::Direction> direction;
 
    SerializableObject()
    : SerializableObjectBase("BehaviorStanding")
    , direction("direction", *this, &S::facedir, SerializableFieldBase::Required{}) {}
};
 
template<>
struct SerializableObject<core::file::Behavior::Spinning> : public SerializableObjectBase {
    using S = core::file::Behavior::Spinning;
 
    SerializableField<1, S, S::Direction> direction;
 
    SerializableObject()
    : SerializableObjectBase("BehaviorSpinning")
    , direction("direction", *this, &S::spinDir, SerializableFieldBase::Required{}) {}
};
 
template<>
struct SerializableObject<core::file::Behavior::Wander> : public SerializableObjectBase {
    using W = core::file::Behavior::Wander;
 
    SerializableField<1, W, std::uint32_t> radius;
 
    SerializableObject()
    : SerializableObjectBase("BehaviorWander")
    , radius("radius", *this, &W::radius, SerializableFieldBase::Required{}) {}
};
 
template<>
struct SerializableObject<core::file::Behavior> : public SerializableObjectBase {
    using B = core::file::Behavior;
 
    SerializableField<1, B, B::Type> type;
    SerializableField<2, B, decltype(B::data)> data;
 
    SerializableObject()
    : SerializableObjectBase("Behavior")
    , type("type", *this, &B::_type, SerializableFieldBase::Required{})
    , data("data", *this, &B::data, SerializableFieldBase::Required{}) {}
};
} // namespace serial
} // namespace bl
 
#endif