492 lines
14 KiB
C++
492 lines
14 KiB
C++
// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
|
|
// Copyright (C) 2010 Winch Gate Property Limited
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Affero General Public License as
|
|
// published by the Free Software Foundation, either version 3 of the
|
|
// License, or (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Affero General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Affero General Public License
|
|
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
/*
|
|
Intro:
|
|
------
|
|
This file contains a complete timer system.
|
|
It is robust and can be used widely.
|
|
The user creates classes derived from CTimerEvent to represent their event handlers.
|
|
When the classes' set() or setRemaining() methods are called an entry is added to the event system provoking
|
|
a callback of the user's timerCallback() method at the given time.
|
|
If a CTimer object is destroyed its callback is automatically canceled.
|
|
A single timer may only have a single time set for it. Setting the time more than once will cancel
|
|
the previous time.
|
|
NOTE: The only requirement for the system is that the CTimerManager::tickUpdate() method is called every tick
|
|
|
|
|
|
Example 1: - a class containing a timer
|
|
----------
|
|
class CMyClass
|
|
{
|
|
public:
|
|
void startTimer()
|
|
{
|
|
// set the timer to trigger in 50 ticks
|
|
_Timer.setRemaining(50);
|
|
}
|
|
void update()
|
|
{
|
|
if (_Timer.isActive())
|
|
{
|
|
nlinfo("time remaining: ",_Timer.getTimeRemaining());
|
|
}
|
|
else
|
|
{
|
|
// set the timer to trigger in 20 ticks
|
|
_Timer.setRemaining(20);
|
|
}
|
|
}
|
|
private:
|
|
CTimer _Timer;
|
|
};
|
|
|
|
|
|
Example 2: - a class using a timer and a custom event handler to trigger regular actions
|
|
----------
|
|
class CMyClass;
|
|
class CMyTimerEvent;
|
|
|
|
class CMyTimerEvent: public CTimerEvent
|
|
{
|
|
public:
|
|
CMyTimerEvent(CMyClass* parent);
|
|
void timerCallback(CTimer* owner);
|
|
private:
|
|
CMyClass* _Parent;
|
|
}
|
|
|
|
class CMyClass
|
|
{
|
|
public:
|
|
void startTimer()
|
|
{
|
|
// set the timer to trigger in 50 ticks
|
|
_Timer.setRemaining(50,new CMyTimerEvent(this));
|
|
}
|
|
void doSomething(CTimerEvent* event)
|
|
{
|
|
nlinfo("hello world");
|
|
// set the timer to trigger in 20 ticks with the same event handler
|
|
_Timer.setRemaining(20,event);
|
|
}
|
|
private:
|
|
CMyTimer _Timer;
|
|
};
|
|
|
|
void CMyTimerEvent::CMyTimerEvent(CMyClass* parent)
|
|
{
|
|
_Parent=parent;
|
|
}
|
|
void CMyTimerEvent::timerCallback(CTimer* owner)
|
|
{
|
|
_Parent->doSomething(this);
|
|
}
|
|
*/
|
|
|
|
#ifndef TIMER_H
|
|
#define TIMER_H
|
|
|
|
//-------------------------------------------------------------------------------------------------
|
|
// includes
|
|
//-------------------------------------------------------------------------------------------------
|
|
|
|
// stl
|
|
#include <vector>
|
|
// misc
|
|
#include "nel/misc/types_nl.h"
|
|
#include "nel/misc/time_nl.h"
|
|
#include "nel/misc/common.h"
|
|
#include "nel/misc/smart_ptr.h"
|
|
// game share
|
|
#include "utils.h"
|
|
#include "tick_event_handler.h"
|
|
#include "singleton_registry.h"
|
|
|
|
|
|
//-------------------------------------------------------------------------------------------------
|
|
// forward class declarations
|
|
//-------------------------------------------------------------------------------------------------
|
|
|
|
class CTimer;
|
|
class CTimerEvent;
|
|
class CTimerManager;
|
|
|
|
|
|
//-------------------------------------------------------------------------------------------------
|
|
// class CTimer
|
|
//-------------------------------------------------------------------------------------------------
|
|
// generic timer class
|
|
|
|
class CTimer
|
|
{
|
|
public:
|
|
// ctor and dtor
|
|
CTimer();
|
|
virtual ~CTimer();
|
|
|
|
// set the timer for a given target time & clear the custom event object
|
|
void set(NLMISC::TGameCycle time);
|
|
|
|
// set the timer for somewhere between (time) and (time + variation)
|
|
// also clear the custom event object
|
|
void set(NLMISC::TGameCycle time,uint32 variation);
|
|
|
|
// set the timer for a given target time with given custom event handler object
|
|
void set(NLMISC::TGameCycle time,CTimerEvent* eventObject);
|
|
|
|
// set the timer for somewhere between (time) and (time + variation)
|
|
// also set given custom event handler object
|
|
void set(NLMISC::TGameCycle time,CTimerEvent* eventObject,uint32 variation);
|
|
|
|
// set the timer for (current time + time) & clear the custom event object
|
|
void setRemaining(NLMISC::TGameCycle time);
|
|
|
|
// set the timer for somewhere between (current time + time) and (current time + time + variation)
|
|
// also clear the custom event object
|
|
void setRemaining(NLMISC::TGameCycle time,uint32 variation);
|
|
|
|
// set the timer for (current time + time) with given custom event handler object
|
|
void setRemaining(NLMISC::TGameCycle time,CTimerEvent* eventObject);
|
|
|
|
// set the timer for somewhere between (current time + time) and (current time + time + variation)
|
|
// also set given custom event handler object
|
|
void setRemaining(NLMISC::TGameCycle time,CTimerEvent* eventObject,uint32 variation);
|
|
|
|
// test whether timer is running
|
|
bool isActive() const;
|
|
|
|
// reset the timer and clear the custom timer event
|
|
void reset();
|
|
|
|
// get the target time for the timer - return 0 if the event is not active
|
|
NLMISC::TGameCycle getTime() const;
|
|
|
|
// get the time remaining before the target time for the timer - return 0 if the event is not active
|
|
NLMISC::TGameCycle getTimeRemaining() const;
|
|
|
|
// get a pointer to the current custom event object
|
|
CTimerEvent* getEvent();
|
|
|
|
private:
|
|
// prohibit copy
|
|
CTimer(const CTimer&);
|
|
|
|
CTimer& operator=(const CTimer&);
|
|
|
|
// a smart pointer to the timer event - the event is reffed by a second smart ptr from the event system
|
|
NLMISC::CSmartPtr<CTimerEvent> _Event;
|
|
};
|
|
|
|
|
|
//-------------------------------------------------------------------------------------------------
|
|
// class CTimerEvent
|
|
//-------------------------------------------------------------------------------------------------
|
|
// specialisable timer event class
|
|
|
|
class CTimerEvent: public NLMISC::CRefCount
|
|
{
|
|
NL_INSTANCE_COUNTER_DECL(CTimerEvent);
|
|
public:
|
|
// callback to be specialised
|
|
virtual void timerCallback(CTimer* owner) {}
|
|
|
|
public:
|
|
// ctor
|
|
CTimerEvent();
|
|
|
|
// dtor
|
|
virtual ~CTimerEvent();
|
|
|
|
// read accessors
|
|
NLMISC::TGameCycle getTime() const;
|
|
|
|
// get hold of the object that created the event (or NULL if the object has been deleted)
|
|
CTimer* getOwner() const;
|
|
|
|
// return true if the event is active otherwise false
|
|
bool isActive() const;
|
|
|
|
private:
|
|
// the following interface is reserved for use by the CTimer class
|
|
friend class CTimer;
|
|
|
|
// setup the event
|
|
void set(CTimer* owner,NLMISC::TGameCycle time);
|
|
|
|
// setup the event, selecting a time between 'time' and 'time'+'variation'
|
|
void set(CTimer* owner,NLMISC::TGameCycle time,uint32 variation);
|
|
|
|
// clear the event - mark it for deletion
|
|
void clear();
|
|
|
|
private:
|
|
// the following interface is reserved for use by the CTimerManager class
|
|
friend class CTimerManager;
|
|
|
|
// method used by the event system to call the timer callback and kill off the event
|
|
void processEvent();
|
|
|
|
private:
|
|
// the correct time for executing the event
|
|
NLMISC::TGameCycle _Time;
|
|
|
|
// a pointer to the owner object - is NULL if owner object has been deleted or this event has been invalidated
|
|
CTimer* _Owner;
|
|
};
|
|
|
|
|
|
//-------------------------------------------------------------------------------------------------
|
|
// class CTimerManager
|
|
//-------------------------------------------------------------------------------------------------
|
|
// singleton timer manager
|
|
|
|
class CTimerManager: public IServiceSingleton
|
|
{
|
|
public:
|
|
// update called each tick in service update
|
|
// updates events and cleans out event vectors
|
|
virtual void tickUpdate();
|
|
|
|
// get the singleton instance...
|
|
static CTimerManager* getInstance();
|
|
|
|
// callback called when the tick service connects - used to ajust time values of event objects
|
|
void syncTick();
|
|
|
|
private:
|
|
// this is a singleton so prohibit construction
|
|
CTimerManager();
|
|
|
|
// the type of the event vector for a given time hash
|
|
typedef std::vector<NLMISC::CSmartPtr<CTimerEvent> > TEventVector;
|
|
|
|
// the event vector is filled directly by CTimerEvent objects
|
|
friend class CTimerEvent;
|
|
|
|
// singleton encapsulation of event vector set
|
|
TEventVector& getEventVector(NLMISC::TGameCycle time);
|
|
|
|
// data
|
|
NLMISC::TGameCycle _LastTick;
|
|
TEventVector _EventVectors[256];
|
|
};
|
|
|
|
|
|
//-------------------------------------------------------------------------------------------------
|
|
// class CTimer
|
|
//-------------------------------------------------------------------------------------------------
|
|
|
|
inline CTimer::CTimer()
|
|
{
|
|
}
|
|
|
|
inline CTimer::~CTimer()
|
|
{
|
|
reset();
|
|
}
|
|
|
|
inline void CTimer::set(NLMISC::TGameCycle time)
|
|
{
|
|
set(time,new CTimerEvent);
|
|
}
|
|
|
|
inline void CTimer::set(NLMISC::TGameCycle time,uint32 variation)
|
|
{
|
|
set(time,new CTimerEvent,variation);
|
|
}
|
|
|
|
inline void CTimer::set(NLMISC::TGameCycle time,CTimerEvent* eventObject)
|
|
{
|
|
if (_Event!=NULL)
|
|
_Event->clear();
|
|
_Event= eventObject;
|
|
eventObject->set(this,time);
|
|
}
|
|
|
|
inline void CTimer::set(NLMISC::TGameCycle time,CTimerEvent* eventObject,uint32 variation)
|
|
{
|
|
if (_Event!=NULL)
|
|
_Event->clear();
|
|
_Event= eventObject;
|
|
eventObject->set(this,time,variation);
|
|
}
|
|
|
|
inline void CTimer::setRemaining(NLMISC::TGameCycle time)
|
|
{
|
|
set(CTickEventHandler::getGameCycle()+time);
|
|
}
|
|
|
|
inline void CTimer::setRemaining(NLMISC::TGameCycle time,uint32 variation)
|
|
{
|
|
set(CTickEventHandler::getGameCycle()+time,variation);
|
|
}
|
|
|
|
inline void CTimer::setRemaining(NLMISC::TGameCycle time,CTimerEvent* eventObject)
|
|
{
|
|
set(CTickEventHandler::getGameCycle()+time,eventObject);
|
|
}
|
|
|
|
inline void CTimer::setRemaining(NLMISC::TGameCycle time,CTimerEvent* eventObject,uint32 variation)
|
|
{
|
|
set(CTickEventHandler::getGameCycle()+time,eventObject,variation);
|
|
}
|
|
|
|
inline void CTimer::reset()
|
|
{
|
|
if (_Event==NULL)
|
|
return;
|
|
_Event->clear();
|
|
_Event=NULL;
|
|
}
|
|
|
|
inline bool CTimer::isActive() const
|
|
{
|
|
return (_Event!=NULL) && _Event->isActive();
|
|
}
|
|
|
|
inline NLMISC::TGameCycle CTimer::getTime() const
|
|
{
|
|
if (!isActive())
|
|
return 0;
|
|
return _Event->getTime();
|
|
}
|
|
|
|
inline NLMISC::TGameCycle CTimer::getTimeRemaining() const
|
|
{
|
|
if (!isActive())
|
|
return 0;
|
|
return getTime()-CTickEventHandler::getGameCycle();
|
|
}
|
|
|
|
inline CTimerEvent* CTimer::getEvent()
|
|
{
|
|
return _Event;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------------
|
|
// inlines CTimerEvent
|
|
//-------------------------------------------------------------------------------------------------
|
|
|
|
inline CTimerEvent::CTimerEvent()
|
|
{
|
|
_Owner = NULL;
|
|
_Time = 0;
|
|
}
|
|
|
|
inline CTimerEvent::~CTimerEvent()
|
|
{
|
|
}
|
|
|
|
inline void CTimerEvent::set(CTimer* owner,NLMISC::TGameCycle time)
|
|
{
|
|
BOMB_IF(owner==NULL,"Impossible to set a timer with a NULL owner",return);
|
|
BOMB_IF(_Owner!=NULL && _Owner!=owner,"Attempt to change owner of an active event",return);
|
|
_Owner = owner;
|
|
_Time = time;
|
|
CTimerManager::getInstance()->getEventVector(time).push_back(this);
|
|
}
|
|
|
|
inline void CTimerEvent::set(CTimer* owner,NLMISC::TGameCycle time,uint32 variation)
|
|
{
|
|
BOMB_IF(variation==0,"shouldn't call this method with variation value of 0", set(owner,time));
|
|
BOMB_IF(variation>256,"shouldn't call this method with variation value of >256", variation=256);
|
|
|
|
BOMB_IF(owner==NULL,"Impossible to set a timer with a NULL owner", return);
|
|
BOMB_IF(_Owner!=NULL && _Owner!=owner,"Attempt to change owner of an active event", return);
|
|
_Owner = owner;
|
|
|
|
CTimerManager* mgr=CTimerManager::getInstance();
|
|
CTimerManager::TEventVector *best=NULL;
|
|
uint32 bestLength=~0u;
|
|
|
|
for (uint32 i=0;i<variation;++i)
|
|
{
|
|
CTimerManager::TEventVector& vect= mgr->getEventVector(time+i);
|
|
uint32 length=(uint32)vect.size();
|
|
if (length<=bestLength)
|
|
{
|
|
bestLength= length;
|
|
best=&vect;
|
|
_Time = time + i;
|
|
}
|
|
}
|
|
BOMB_IF(best==NULL,"BUG: This can never happen!",return)
|
|
best->push_back(this);
|
|
}
|
|
|
|
inline NLMISC::TGameCycle CTimerEvent::getTime() const
|
|
{
|
|
return _Time;
|
|
}
|
|
|
|
inline CTimer* CTimerEvent::getOwner() const
|
|
{
|
|
return _Owner;
|
|
}
|
|
|
|
inline bool CTimerEvent::isActive() const
|
|
{
|
|
return _Owner!=NULL;
|
|
}
|
|
|
|
inline void CTimerEvent::clear()
|
|
{
|
|
_Owner=NULL;
|
|
}
|
|
|
|
|
|
inline void CTimerEvent::processEvent()
|
|
{
|
|
CTimer* owner=_Owner;
|
|
BOMB_IF(owner==NULL,"Attempt to process an event that no longer has a valid owner",return)
|
|
|
|
// mark the event as expired - the state may be chnaged during the timer callback...
|
|
// NOTE: This operation results in '_Owner' being set to NULL
|
|
_Owner->reset();
|
|
|
|
// call the virtual callback
|
|
timerCallback(owner);
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------------------------------
|
|
// inlines CTimerManager
|
|
//-------------------------------------------------------------------------------------------------
|
|
|
|
inline CTimerManager::CTimerManager()
|
|
{
|
|
_LastTick= CTickEventHandler::getGameCycle();
|
|
}
|
|
|
|
inline CTimerManager* CTimerManager::getInstance()
|
|
{
|
|
static CTimerManager* instance= NULL;
|
|
if (instance==NULL)
|
|
{
|
|
instance=new CTimerManager;
|
|
}
|
|
return instance;
|
|
}
|
|
|
|
inline CTimerManager::TEventVector& CTimerManager::getEventVector(NLMISC::TGameCycle time)
|
|
{
|
|
return _EventVectors[uint8(time&0xff)];
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------------------------------
|
|
#endif
|