GameClock.hxx

Go to the documentation of this file.

#ifndef GAME_CLOCK_HXX_
#define GAME_CLOCK_HXX_
 
#include <chrono>
#include <mutex>
#include <functional>
#include "../util/PriorityQueue.hxx"
#include "../util/Singleton.hxx"
 
using namespace std::chrono_literals;
 
class GameClock : public Singleton<GameClock>
{
private:
  using Clock = std::chrono::high_resolution_clock;
  template <typename T, typename Comparator> friend class PriorityQueue;
 
public:
  using TimePoint = std::chrono::time_point<Clock>;
  using TimeDuration = Clock::duration;
  using ClockCbk = std::function<bool(void)>;
  using ClockTaskHndl = unsigned long;
  using GameClockTime = unsigned long;
  using GameClockDuration = unsigned long;
 
  static constexpr GameClockTime GameMinute = 1;
 
  static constexpr GameClockTime GameHour = 60 * GameMinute;
 
  static constexpr GameClockTime GameDay = 24 * GameHour;
 
  void tick(void);
 
  template <typename DelayType, typename PeriodType = TimePoint>
  GameClock::ClockTaskHndl addRealTimeClockTask(ClockCbk cbk, DelayType delay, PeriodType period = TimePointZero);
 
  GameClock::ClockTaskHndl addGameTimeClockTask(ClockCbk cbk, GameClockTime delay, GameClockTime period = 0U);
 
  void setGameClockSpeed(float speedFactor);
 
  float getGameClockSpeed() const { return m_speedFactor; }
 
  void clear(void);
 
  bool removeClockTask(ClockTaskHndl hndl);
 
private:
  static constexpr unsigned int DefaultGameTickDuration = 2000;
  static constexpr TimePoint TimePointZero = TimePoint{0s};
  static constexpr ClockTaskHndl ClockTaskHndlInvalid = ClockTaskHndl{0};
 
  template <typename Time, typename Duration> struct ClockTask
  {
    ClockCbk callback;
    Time m_waketime;
    Duration m_period;
    ClockTaskHndl hndl;
 
    explicit ClockTask(ClockCbk cbk, Time delay, Duration period, ClockTaskHndl hndl)
        : callback{cbk}, m_waketime{delay}, m_period{period}, hndl{hndl}
    {
    }
 
    bool operator==(const ClockTask &task2) const { return hndl == task2.hndl; };
    bool operator>(const ClockTask &task2) const { return m_waketime > task2.m_waketime; }
  };
 
  using RealTimeClockTask = ClockTask<TimePoint, TimeDuration>;
  using GameTimeClockTask = ClockTask<GameClockTime, GameClockDuration>;
 
  PriorityQueue<RealTimeClockTask, std::greater<RealTimeClockTask>> m_realTimeTasks;
  PriorityQueue<GameTimeClockTask, std::greater<GameTimeClockTask>> m_gameTimeTasks;
  std::mutex m_lock;
  // Provide way to return unique handle for each task.
  ClockTaskHndl m_unique_handle = 0U;
  GameClockTime m_gameTicks = 0U;
  TimePoint m_lastGameTickTime = Clock::now();
 
  float m_speedFactor = 1.f;
  Clock::duration m_gameTickDuration = std::chrono::milliseconds(DefaultGameTickDuration);
 
  template <typename Task, typename Cmp, typename Now> void tickTask(PriorityQueue<Task, Cmp> &queue, Now now);
};
 
#include "GameClock.inl.hxx"
 
#endif // GAME_CLOCK_HXX_