Game clock service. Implement two timers one real time timer and other game time timer. More...

#include <GameClock.hxx>

Inheritance diagram for GameClock:

Collaboration diagram for GameClock:

Classes
struct	ClockTask
	Template structure provide base for different clock tasks. More...

Public Types
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

Public Member Functions
void	tick (void)
	This function provides the tick for both clocks. More...

template<typename DelayType , typename PeriodType = TimePoint>
GameClock::ClockTaskHndl	addRealTimeClockTask (ClockCbk cbk, DelayType delay, PeriodType period=TimePointZero)
	Add new real time clock task. More...

GameClock::ClockTaskHndl	addGameTimeClockTask (ClockCbk cbk, GameClockTime delay, GameClockTime period=0U)
	Add new game time clock task. More...

void	setGameClockSpeed (float speedFactor)
	Set game clock speed. More...

float	getGameClockSpeed () const

void	clear (void)
	Remove all real time and game time clocks. More...

bool	removeClockTask (ClockTaskHndl hndl)
	Remove real/game time clock. After it is removed successfully it is guaranteed it will not trigger callback. More...

Static Public Attributes
static constexpr GameClockTime	GameMinute = 1
	Represent 1 minute of game time. More...

static constexpr GameClockTime	GameHour = 60 * GameMinute
	Represent 1 hour of game time. More...

static constexpr GameClockTime	GameDay = 24 * GameHour
	Represent 1 day of game time. More...

Private Types
using	Clock = std::chrono::high_resolution_clock

using	RealTimeClockTask = ClockTask< TimePoint, TimeDuration >

using	GameTimeClockTask = ClockTask< GameClockTime, GameClockDuration >

Private Member Functions
template<typename Task , typename Cmp , typename Now >
void	tickTask (PriorityQueue< Task, Cmp > &queue, Now now)
	Tick clock for given task type. More...

Private Attributes
PriorityQueue< RealTimeClockTask, std::greater< RealTimeClockTask > >	m_realTimeTasks

PriorityQueue< GameTimeClockTask, std::greater< GameTimeClockTask > >	m_gameTimeTasks

std::mutex	m_lock

ClockTaskHndl	m_unique_handle = 0U

GameClockTime	m_gameTicks = 0U
	Current number of the game ticks. More...

TimePoint	m_lastGameTickTime = Clock::now()
	Last time of the game tick. More...

float	m_speedFactor = 1.f
	The current game tick duration on milliseconds. More...

Clock::duration	m_gameTickDuration = std::chrono::milliseconds(DefaultGameTickDuration)

Static Private Attributes
static constexpr unsigned int	DefaultGameTickDuration = 2000
	Duration of default game timer tick in ms. More...

static constexpr TimePoint	TimePointZero = TimePoint{0s}

static constexpr ClockTaskHndl	ClockTaskHndlInvalid = ClockTaskHndl{0}
	Invalid task handler. In case that clock is not added. More...

Friends
template<typename T , typename Comparator >
class	PriorityQueue

Additional Inherited Members
Static Public Member Functions inherited from Singleton< GameClock >
static GameClock &	instance (void)
	Get an instance of the singleton. More...

Protected Member Functions inherited from Singleton< GameClock >
	Singleton () noexcept=default

	~Singleton () noexcept=default

Detailed Description

Game clock service. Implement two timers one real time timer and other game time timer.

Both timers provide possibility to add task which will be triggered after delay time run out. Game timer represent timer running in game time. The game time can be scaled providing possibility to speed up or slow down game.

Definition at line 18 of file GameClock.hxx.

Member Typedef Documentation

◆ Clock

using GameClock::Clock = std::chrono::high_resolution_clock

private

Definition at line 21 of file GameClock.hxx.

◆ ClockCbk

using GameClock::ClockCbk = std::function<bool(void)>

Definition at line 27 of file GameClock.hxx.

◆ ClockTaskHndl

using GameClock::ClockTaskHndl = unsigned long

Definition at line 28 of file GameClock.hxx.

◆ GameClockDuration

using GameClock::GameClockDuration = unsigned long

Definition at line 30 of file GameClock.hxx.

◆ GameClockTime

using GameClock::GameClockTime = unsigned long

Definition at line 29 of file GameClock.hxx.

◆ GameTimeClockTask

using GameClock::GameTimeClockTask = ClockTask<GameClockTime, GameClockDuration>

private

Definition at line 129 of file GameClock.hxx.

◆ RealTimeClockTask

using GameClock::RealTimeClockTask = ClockTask<TimePoint, TimeDuration>

private

Definition at line 128 of file GameClock.hxx.

◆ TimeDuration

using GameClock::TimeDuration = Clock::duration

Definition at line 26 of file GameClock.hxx.

◆ TimePoint

using GameClock::TimePoint = std::chrono::time_point<Clock>

Definition at line 25 of file GameClock.hxx.

Member Function Documentation

◆ addGameTimeClockTask()

GameClock::ClockTaskHndl GameClock::addGameTimeClockTask	(	ClockCbk	cbk,
		GameClockTime	delay,
		GameClockTime	period = `0U`
	)

Add new game time clock task.

Parameters

cbk	Callback function to be called after delay time is passed.
delay	Delay in game timer ticks. Use provided values GameDay, GameHour, GameMinute and scale it as necessary. Callback function will be called after delay timer is passed.
period	Repeat period in game timer ticks. Use provided values GameDay, GameHour, GameMinute and scale it as necessary. The timer will be reset again with new delay ticks in amount of period ticks.

Returns: Game time clock task handle. Can be used to remove clock and verify whether it is started correctly. In case of failure ClockTaskHndlInvalid will be return.

Definition at line 53 of file GameClock.cxx.

 {
   assert(cbk != nullptr);
  
   std::lock_guard<std::mutex> lock(m_lock);
  
   // If no delay required call callback immediately
   if (delay == 0)
   {
     const bool isCanceled = cbk();
  
     if (isCanceled || (period == 0))
     {
       return ClockTaskHndlInvalid;
     }
  
     delay = period;
   }
  
   // Add +1 tick just to be sure timer is not fire before its timeout.
   m_gameTimeTasks.push(GameTimeClockTask(cbk, delay + m_gameTicks + 1U, period, ++m_unique_handle));
   return m_unique_handle;
 }

◆ addRealTimeClockTask()

template<typename DelayType , typename PeriodType >

GameClock::ClockTaskHndl GameClock::addRealTimeClockTask	(	ClockCbk	cbk,
		DelayType	delay,
		PeriodType	period = `TimePointZero`
	)

inline

Add new real time clock task.

Parameters

cbk	Callback function to be called after delay time is passed.
delay	Delay in chrono literals (e.g. 1h, 2min, 3s ...), callback function will be called after delay timer is passed.
period	Repeat period in chrono literals (e.g. 1h, 2min, 3s ...) the timer will be reset again with new delay time in amount of period time.

Returns: Real time clock task handle. Can be used to remove clock and verify whether it is started correctly. In case of failure ClockTaskHndlInvalid will be return.

Definition at line 5 of file GameClock.inl.hxx.

 {
   assert((cbk != nullptr) && (TimePoint(delay) >= TimePointZero) && (TimePoint(period) >= TimePointZero));
  
   std::lock_guard<std::mutex> lock(m_lock);
   TimePoint delayConverted = (TimePoint)delay;
  
   // If no delay required call callback immediately
   if (delayConverted == TimePointZero)
   {
     const bool isCanceled = cbk();
  
     if (isCanceled || ((TimePoint)period == TimePointZero))
     {
       return ClockTaskHndlInvalid;
     }
  
     delayConverted = (TimePoint)period;
   }
  
   m_realTimeTasks.push(RealTimeClockTask(cbk, Clock::now() + (delayConverted - TimePointZero), (TimePoint)period - TimePointZero,
                                          ++m_unique_handle));
   return m_unique_handle;
 }

Here is the caller graph for this function:

◆ clear()

void GameClock::clear ( void )

Remove all real time and game time clocks.

Definition at line 84 of file GameClock.cxx.

 {
   std::lock_guard<std::mutex> lock(m_lock);
   m_gameTimeTasks.clear();
   m_realTimeTasks.clear();
 }

◆ getGameClockSpeed()

float GameClock::getGameClockSpeed ( ) const

inline

Definition at line 83 of file GameClock.hxx.

83 { return m_speedFactor; }

Here is the caller graph for this function:

◆ removeClockTask()

bool GameClock::removeClockTask ( ClockTaskHndl hndl )

Remove real/game time clock. After it is removed successfully it is guaranteed it will not trigger callback.

Parameters

hndl	Handle of clock which should be removed.

Returns: true in case clock is successfully removed, otherwise false.

Definition at line 41 of file GameClock.cxx.

 {
   std::lock_guard<std::mutex> lock(m_lock);
  
   if (!removeTaskFromQueue(hndl, m_realTimeTasks))
   {
     return removeTaskFromQueue(hndl, m_gameTimeTasks);
   }
  
   return true;
 }

Here is the call graph for this function:

◆ setGameClockSpeed()

void GameClock::setGameClockSpeed ( float speedFactor )

Set game clock speed.

Parameters

speedFactor Game clock scale factor. E.g. to run game clock 4 time faster provide 4.0f.

Definition at line 77 of file GameClock.cxx.

 {
   std::lock_guard<std::mutex> lock(m_lock);
   m_speedFactor = speedFactor;
   m_gameTickDuration = std::chrono::milliseconds((unsigned int)(GameClock::DefaultGameTickDuration / speedFactor));
 }

Here is the caller graph for this function:

◆ tick()

void GameClock::tick ( void )

This function provides the tick for both clocks.

It must be called frequently. Call frequency determines clock precision.

Definition at line 19 of file GameClock.cxx.

 {
   std::lock_guard<std::mutex> lock(m_lock);
  
   const auto now = Clock::now();
  
   tickTask(m_realTimeTasks, now);
  
   if ((now - m_lastGameTickTime) >= m_gameTickDuration)
   {
     m_lastGameTickTime = now;
     m_gameTicks++;
  
     tickTask(m_gameTimeTasks, m_gameTicks);
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ tickTask()

template<typename Task , typename Cmp , typename Now >

void GameClock::tickTask	(	PriorityQueue< Task, Cmp > &	queue,
		Now	now
	)

private

Tick clock for given task type.

Parameters

queue	Priority queue of tasks.
now	The time point when tick occurred.

Definition at line 4 of file GameClock.cxx.

 {
   while (!queue.empty() && (now >= queue.top().m_waketime))
   {
     const auto task = queue.top();
     queue.pop();
     const bool isCanceled = task.callback();
  
     if (!isCanceled && (task.m_period != decltype(task.m_period){0}))
     {
       queue.push(Task(task.callback, now + task.m_period, task.m_period, task.hndl));
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Function Documentation

◆ PriorityQueue

template<typename T , typename Comparator >

friend class PriorityQueue

friend

Definition at line 22 of file GameClock.hxx.

Member Data Documentation

◆ ClockTaskHndlInvalid

constexpr ClockTaskHndl GameClock::ClockTaskHndlInvalid = ClockTaskHndl{0}

staticconstexprprivate

Invalid task handler. In case that clock is not added.

Definition at line 107 of file GameClock.hxx.

◆ DefaultGameTickDuration

constexpr unsigned int GameClock::DefaultGameTickDuration = 2000

staticconstexprprivate

Duration of default game timer tick in ms.

Definition at line 102 of file GameClock.hxx.

◆ GameDay

constexpr GameClockTime GameClock::GameDay = 24 * GameHour

staticconstexpr

Represent 1 day of game time.

Definition at line 45 of file GameClock.hxx.

◆ GameHour

constexpr GameClockTime GameClock::GameHour = 60 * GameMinute

staticconstexpr

Represent 1 hour of game time.

Definition at line 40 of file GameClock.hxx.

◆ GameMinute

constexpr GameClockTime GameClock::GameMinute = 1

staticconstexpr

Represent 1 minute of game time.

Definition at line 35 of file GameClock.hxx.

◆ m_gameTickDuration

Clock::duration GameClock::m_gameTickDuration = std::chrono::milliseconds(DefaultGameTickDuration)

private

Definition at line 143 of file GameClock.hxx.

◆ m_gameTicks

GameClockTime GameClock::m_gameTicks = 0U

private

Current number of the game ticks.

Definition at line 137 of file GameClock.hxx.

◆ m_gameTimeTasks

PriorityQueue<GameTimeClockTask, std::greater<GameTimeClockTask> > GameClock::m_gameTimeTasks

private

Definition at line 132 of file GameClock.hxx.

◆ m_lastGameTickTime

TimePoint GameClock::m_lastGameTickTime = Clock::now()

private

Last time of the game tick.

Definition at line 139 of file GameClock.hxx.

◆ m_lock

std::mutex GameClock::m_lock

private

Definition at line 133 of file GameClock.hxx.

◆ m_realTimeTasks

PriorityQueue<RealTimeClockTask, std::greater<RealTimeClockTask> > GameClock::m_realTimeTasks

private

Definition at line 131 of file GameClock.hxx.

◆ m_speedFactor

float GameClock::m_speedFactor = 1.f

private

The current game tick duration on milliseconds.

Definition at line 142 of file GameClock.hxx.

◆ m_unique_handle

ClockTaskHndl GameClock::m_unique_handle = 0U

private

Definition at line 135 of file GameClock.hxx.

◆ TimePointZero

constexpr TimePoint GameClock::TimePointZero = TimePoint{0s}

staticconstexprprivate

Definition at line 103 of file GameClock.hxx.

The documentation for this class was generated from the following files:

src/services/GameClock.hxx
src/services/GameClock.cxx
src/services/GameClock.inl.hxx

Classes

Public Types

Public Member Functions

Static Public Attributes

Private Types

Private Member Functions

Private Attributes

Static Private Attributes

Friends

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ Clock

◆ ClockCbk

◆ ClockTaskHndl

◆ GameClockDuration

◆ GameClockTime

◆ GameTimeClockTask

◆ RealTimeClockTask

◆ TimeDuration

◆ TimePoint

Member Function Documentation

◆ addGameTimeClockTask()

◆ addRealTimeClockTask()

◆ clear()

◆ getGameClockSpeed()

◆ removeClockTask()

◆ setGameClockSpeed()

◆ tick()

◆ tickTask()

Friends And Related Function Documentation

◆ PriorityQueue

Member Data Documentation

◆ ClockTaskHndlInvalid

◆ DefaultGameTickDuration

◆ GameDay

◆ GameHour

◆ GameMinute

◆ m_gameTickDuration

◆ m_gameTicks

◆ m_gameTimeTasks

◆ m_lastGameTickTime

◆ m_lock

◆ m_realTimeTasks

◆ m_speedFactor

◆ m_unique_handle

◆ TimePointZero