timer.cpp

网络游戏通用架构, 这是基于boost和libevent写的一个程序

#include "timer.h"


TimePointInterface::TimePointInterface( const ptime& __alarm_time, const time_duration& __step_time, const int __repeat )
: _alarm_time(__alarm_time), _step_time(__step_time), _repeat(__repeat)
{
}


TimePointInterface::~TimePointInterface()
{
}


bool TimePointInterface::operator <= ( const ptime& __time )
{
    return _alarm_time <= __time;
}


bool TimePointInterface::step(void)//return true to be delete
{
    if( _repeat > 0 ){
        _alarm_time += _step_time;
        --_repeat;
        return false;
    }else{
        return true;
    }
}


bool operator < ( const shared_ptr<TimePointInterface>& __timepoint1, const shared_ptr<TimePointInterface>& __timepoint2 )
{
    return __timepoint1->_alarm_time < __timepoint2->_alarm_time;
}


Timer::Timer( float __speed )
: _speed(__speed)
{
    _last_time_normal= microsec_clock::universal_time();
    _last_time_shift= microsec_clock::universal_time();
}


Timer::~Timer()
{
}


void Timer::breathe(void)
{
    _times.sort();
    ptime now;
    getTimeNow( now );
    for( std::list< shared_ptr<TimePointInterface> >::iterator itor= _times.begin(); itor!=_times.end(); ){
        TimePointInterface& point= *(*itor);
        if( point <= now ){
            point.alarm();
            if( point.step() ){//need to be removed
                itor= _times.erase( itor );
            }else{
                ++itor;
            }
        }else{
            break;
        }
    }
}


void Timer::setAlarm( shared_ptr<TimePointInterface>& __timepoint )
{
    _times.push_back( __timepoint );
}


void Timer::getTimeNow( ptime& __time )
{
    ptime now_normal;
    now_normal= microsec_clock::universal_time();
    time_duration dtime= now_normal - _last_time_normal;
    try{
        dtime = dtime * static_cast<int>( _speed ) + dtime / static_cast<int>( 1 / ( _speed - static_cast<int>( _speed ) ) );//dtime *= _speed;
    }catch(...){
    }
    __time= _last_time_shift + dtime;
}


void Timer::setSpeed( float __speed )
{
    updateLastTime();
    _speed= __speed;
}


float Timer::getSpeed(void) const
{
    return _speed;
}


void Timer::updateLastTime(void)
{
    ptime now_normal;
    now_normal= microsec_clock::universal_time();
    time_duration dtime= now_normal - _last_time_normal;
    try{
        dtime = dtime * static_cast<int>( _speed ) + dtime / static_cast<int>( 1 / ( _speed - static_cast<int>( _speed ) ) );//dtime *= _speed;
    }catch(...){
    }
    _last_time_normal= now_normal;
    _last_time_shift += dtime;
}