Clock.hpp

Go to the documentation of this file.

#ifndef CORE_SYSTEMS_CLOCK_HPP
#define CORE_SYSTEMS_CLOCK_HPP
 
#include <BLIB/Engine/System.hpp>
#include <BLIB/Serialization.hpp>
#include <BLIB/Util/NonCopyable.hpp>
#include <Core/Events/GameSave.hpp>
#include <iomanip>
#include <ostream>
 
namespace core
{
namespace system
{
class Systems;
 
class Clock
: private bl::util::NonCopyable
, public bl::engine::System
, public bl::event::Listener<event::GameSaveInitializing, event::GameSaveLoaded> {
public:
    struct Time {
        unsigned int day;
 
        unsigned int hour;
 
        unsigned int minute;
 
        Time();
 
        Time(unsigned int hour, unsigned int minute, unsigned int day = 0);
 
        void addMinutes(unsigned int minutes);
 
        void addHours(unsigned int hours);
 
        bool operator==(const Time& right) const;
 
        bool operator<(const Time& right) const;
 
        bool operator>(const Time& right) const;
 
        friend std::ostream& operator<<(std::ostream& stream, const Time& time) {
            stream << std::setfill('0') << std::setw(2) << time.hour << ":" << std::setfill('0')
                   << std::setw(2) << time.minute;
            return stream;
        }
    };
 
    Clock(Systems& owner);
 
    virtual ~Clock() = default;
 
    const Time& now() const;
 
    void set(const Time& time);
 
    virtual void observe(const event::GameSaveInitializing& save) override;
 
    virtual void observe(const event::GameSaveLoaded& load) override;
 
private:
    Systems& owner;
    Time currentTime;
    float residual;
 
    virtual void init(bl::engine::Engine&) override;
    virtual void update(std::mutex&, float dt, float, float, float) override;
};
 
} // namespace system
} // namespace core
 
namespace bl
{
namespace serial
{
template<>
struct SerializableObject<core::system::Clock::Time> : public SerializableObjectBase {
    using T = core::system::Clock::Time;
 
    SerializableField<1, T, unsigned int> day;
    SerializableField<2, T, unsigned int> hour;
    SerializableField<3, T, unsigned int> minute;
 
    SerializableObject()
    : SerializableObjectBase("ClockTime")
    , day("day", *this, &T::day, SerializableFieldBase::Required{})
    , hour("hour", *this, &T::hour, SerializableFieldBase::Required{})
    , minute("minute", *this, &T::minute, SerializableFieldBase::Required{}) {}
};
 
} // namespace serial
} // namespace bl
 
#endif