eTimer Class Reference

#include <eTimer.h>

Inheritance diagram for eTimer:

[legend]

Collaboration diagram for eTimer:

[legend]

List of all members.

Public Member Functions
	eTimer ()
	eTimer (nMessage &m)
virtual	~eTimer ()
virtual void	WriteSync (nMessage &m)
virtual void	ReadSync (nMessage &m)
virtual nDescriptor &	CreatorDescriptor () const
REAL	Time ()
REAL	TimeNoSync ()
void	pause (bool p)
void	SyncTime ()
void	Reset (REAL t=0)
REAL	AverageFPS ()
REAL	AverageFrameTime ()
REAL	FrameTime ()
bool	IsSynced () const
	returns whether the timer is synced sufficiently well to allow rendering
Public Attributes
REAL	speed
Private Attributes
double	creationSystemTime_
	the rough system time this timer was created at
double	smoothedSystemTime_
	the smoothed system time
double	startTime_
	when was the last game started?
nAverager	startTimeOffset_
	the smoothed average of this averager is added to the start time on the client
REAL	startTimeSmoothedOffset_
	the smoothed average of startTimeOffset_
nAverager	qualityTester_
	averager that tells us about the quality of the sync messages
REAL	spf_
	last frame time
nAverager	averageSpf_
	averager over seconds per frame
double	lastTime_
	the smoothed system time of the last update
double	nextSync_
	system time of the next sync to the clients

---

Detailed Description

Definition at line 35 of file eTimer.h.

---

Constructor & Destructor Documentation

eTimer::eTimer

(

)

Definition at line 42 of file eTimer.cpp.

References nAverager::Add(), averageSpf_, creationSystemTime_, nSERVER, nNetObject::RequestSync(), nAverager::Reset(), Reset(), sn_GetNetState(), speed, and tSysTimeFloat().

              :nNetObject(), startTimeSmoothedOffset_(0){
    //con << "Creating own eTimer.\n";

    speed = 1.0;

    Reset(0);

    if (se_mainGameTimer)
        delete se_mainGameTimer;
    se_mainGameTimer=this;
    if (sn_GetNetState()==nSERVER)
        RequestSync();

    averageSpf_.Reset();
    averageSpf_.Add(1/60.0,5);

    creationSystemTime_ = tSysTimeFloat();
}

Here is the call graph for this function:

eTimer::eTimer

(

nMessage &

m

)

Definition at line 61 of file eTimer.cpp.

References nAverager::Add(), averageSpf_, creationSystemTime_, nAverager::Reset(), Reset(), speed, and tSysTimeFloat().

                         :nNetObject(m), startTimeSmoothedOffset_(0){
    //con << "Creating remote eTimer.\n";

    speed = 1.0;

    Reset(0);

    if (se_mainGameTimer)
        delete se_mainGameTimer;
    se_mainGameTimer=this;

    averageSpf_.Reset();
    averageSpf_.Add(1/60.0,5);

    creationSystemTime_ = tSysTimeFloat();
}

Here is the call graph for this function:

eTimer::~eTimer

(

)

[virtual]

Definition at line 78 of file eTimer.cpp.

References NULL.

               {
    //con << "Deleting eTimer.\n";
    se_mainGameTimer=NULL;
}

---

Member Function Documentation

void eTimer::WriteSync

(

nMessage &

m

)

[virtual]

Reimplemented from nNetObject.

Definition at line 90 of file eTimer.cpp.

References nextSync_, REAL, se_clientLagCompensation, se_lagOffsetLegacy, smoothedSystemTime_, speed, nVersionFeature::Supported(), nNetObject::SyncedUser(), Time(), and nNetObject::WriteSync().

                                 {
    nNetObject::WriteSync(m);
    REAL time = Time();

    if ( SyncedUser() > 0 && !se_clientLagCompensation.Supported( SyncedUser() ) )
        time += se_lagOffsetLegacy;

    m << time;
    m << speed;
    //std::cerr << "syncing:" << currentTime << ":" << speed << '\n';

    // plan next sync
    const REAL stopFast = 3;
    const REAL maxFast  = 3;
    if ( time < stopFast )
    {
        nextSync_ = smoothedSystemTime_ + maxFast/(stopFast+maxFast-time);
    }
    else
    {
        nextSync_ = smoothedSystemTime_ + 1;
    }
}

Here is the call graph for this function:

void eTimer::ReadSync

(

nMessage &

m

)

[virtual]

Reimplemented from nNetObject.

Definition at line 119 of file eTimer.cpp.

References nAverager::Add(), EPS, nAverager::GetAverageVariance(), nPingAverager::GetFastAverager(), nPingAverager::GetPing(), nConnectionInfo::ping, qualityTester_, nNetObject::ReadSync(), REAL, nAverager::Reset(), se_timerStartFudge, se_timerStartFudgeStop, nMessage::SenderID(), smoothedSystemTime_, sn_Connections, sn_pingCharityServer, speed, startTime_, startTimeOffset_, and nAverager::Timestep().

                                {
    nNetObject::ReadSync(m);

    //std::cerr << "Got sync:" << remote_currentTime << ":" << speed << '\n';

    // determine the best estimate of the start time offset that reproduces the sent remote
    // time and its expected quality.
    REAL remoteStartTimeOffset = 0;
    REAL remoteTimeNonQuality = 0;
    {
        //REAL oldTime=currentTime;
        REAL remote_currentTime, remoteSpeed;
        m >> remote_currentTime; // read in the remote time
        m >> remoteSpeed;

        // forget about earlier syncs if the speed changed
        if ( fabs( speed - remoteSpeed ) > 10 * EPS )
        {
            qualityTester_.Timestep( 100 );
            startTimeOffset_.Reset();
        }

        speed = remoteSpeed;

        // determine ping
        nPingAverager & averager = sn_Connections[m.SenderID()].ping;
        // pingAverager_.Add( rawAverager.GetPing(), remote_currentTime > .01 ? remote_currentTime : .01 );
        REAL ping = averager.GetPing();

        // add half our ping (see Einsteins SRT on clock syncronisation)
        REAL real_remoteTime=remote_currentTime+ping*speed*.5;

        // and the normal time including ping charity
        REAL min_remoteTime=remote_currentTime+ping*speed-
                            sn_pingCharityServer*.001;

        if (real_remoteTime<min_remoteTime)
            remote_currentTime=min_remoteTime;
        else
            remote_currentTime=real_remoteTime;

        // HACK: warp time into the future at the beginning of the round.
        // I can't explain why this is required; without it, the timer is late.
        if ( remote_currentTime < se_timerStartFudgeStop )
        {
            remote_currentTime += ping * ( se_timerStartFudgeStop - remote_currentTime ) * se_timerStartFudge;
        }

        // determine quality from ping variance
        remoteTimeNonQuality = averager.GetFastAverager().GetAverageVariance();

        // determine start time
        remoteStartTimeOffset = smoothedSystemTime_ - startTime_ - remote_currentTime;

        // let the averagers decay faster at the beginning
        if ( remote_currentTime < 0 )
        {
            qualityTester_.Timestep( .2 );
            startTimeOffset_.Timestep( .2 );
        }
    }

    // try to get independend quality measure: get the variance of the received start times
    qualityTester_.Add( remoteStartTimeOffset );

    // add the variance to the non-quality, along with an offset to avoid division by zero
    remoteTimeNonQuality += 0.00001 + 4 * qualityTester_.GetAverageVariance();

    // add the offset to the statistics, weighted by the quality
    startTimeOffset_.Add( remoteStartTimeOffset, 1/remoteTimeNonQuality );
}

Here is the call graph for this function:

nDescriptor & eTimer::CreatorDescriptor

(

void

)

const [virtual]

Implements nNetObject.

Definition at line 193 of file eTimer.cpp.

References eTimer_init.

                                            {
    return eTimer_init;
}

REAL eTimer::Time

(

)

Definition at line 215 of file eTimer.cpp.

References eLag::Current(), smoothedSystemTime_, startTime_, and startTimeSmoothedOffset_.

Referenced by gCycle::Act(), gWallRim::RenderReal(), se_GameTime(), SyncTime(), TimeNoSync(), and WriteSync().

{
    return ( smoothedSystemTime_ - startTime_ ) - startTimeSmoothedOffset_ + eLag::Current();
}

Here is the call graph for this function:

Here is the caller graph for this function:

REAL eTimer::TimeNoSync

(

)

[inline]

Definition at line 47 of file eTimer.h.

References lastTime_, REAL, speed, Time(), and tSysTimeFloat().

Referenced by se_GameTimeNoSync().

{return REAL(Time()+(tSysTimeFloat()-lastTime_)*speed);}

Here is the call graph for this function:

Here is the caller graph for this function:

void eTimer::pause

(

bool

p

)

Definition at line 362 of file eTimer.cpp.

References nSERVER, nNetObject::RequestSync(), sn_GetNetState(), and speed.

Referenced by se_PauseGameTimer().

                        {
    if (p){
        if(speed!=0){
            speed=0;
            if (sn_GetNetState()==nSERVER)
                RequestSync();
        }
    }
    else{
        if (speed!=1){
            speed=1;
            //Reset(currentTime_);

            if (sn_GetNetState()==nSERVER)
                RequestSync();
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void eTimer::SyncTime

(

)

Definition at line 220 of file eTimer.cpp.

References nAverager::Add(), averageSpf_, nAverager::GetAverage(), nAverager::GetAverageVariance(), tRecorderBase::IsRunning(), lastTime_, nextSync_, nSERVER, nSTANDALONE, qualityTester_, REAL, nNetObject::RequestSync(), se_SmoothTime(), smoothedSystemTime_, sn_GetNetState(), speed, spf_, st_Breakpoint(), startTime_, startTimeOffset_, startTimeSmoothedOffset_, Time(), nAverager::Timestep(), eLag::Timestep(), tSysTimeFloat(), and tTimerIsAccurate().

Referenced by se_SyncGameTimer().

                     {
    // get current system time
    {
        double newTime=tSysTimeFloat();

        static bool smooth = se_SmoothTime();

        // recheck if no recording/playback is running
        if ( !tRecorder::IsRunning() )
        {
            smooth = !tTimerIsAccurate();
        }

        if ( !smooth )
        {
            // take it
            smoothedSystemTime_ = newTime;
        }
        else
        {
            // smooth it
            REAL smoothDecay = .2f;
            smoothedSystemTime_ = ( smoothedSystemTime_ + smoothDecay * newTime )/( 1 + smoothDecay );
        }
    }

    // update timers
    REAL timeStep=smoothedSystemTime_ - lastTime_;
    lastTime_ = smoothedSystemTime_;

#ifdef DEBUG
#ifndef DEDICATED
    // maximum effective timestep in SP debug mode: .1s
    if (timeStep > .1f && sn_GetNetState() == nSTANDALONE && !tRecorder::IsRunning() )
    {
        startTime_ += timeStep - .1f;
        timeStep = .1f;
    }
#endif
#endif

    // update lag compensation
    eLag::Timestep( timeStep );

    // store and average frame times
    spf_ = timeStep;
    if ( timeStep > 0 && speed > 0 )
    {
        averageSpf_.Add( timeStep );
        averageSpf_.Timestep( timeStep );
    }

    // let averagers decay
    startTimeOffset_.Timestep( timeStep * .1 );
    qualityTester_  .Timestep( timeStep * .3 );
    // pingAverager_   .Timestep( timeStep * .05);

    // if we're not running at default speed, update the virtual start time
    startTime_ += ( 1.0 - speed ) * timeStep;

    // smooth time offset
    {
        REAL startTimeOffset = startTimeOffset_.GetAverage();

        // correct huge deviations (compared to variance) faster
        REAL deviation = startTimeSmoothedOffset_ - startTimeOffset;
        REAL extraSmooth = deviation * deviation / ( startTimeOffset_.GetAverageVariance() + .0001 );

        // allow for faster smoothing at the beginning of the round
        REAL time = Time();
        if ( time < 0 )
            extraSmooth -= 4 * time;

        REAL smooth = timeStep * ( .5 + extraSmooth );
        startTimeSmoothedOffset_ = ( startTimeSmoothedOffset_ + startTimeOffset * smooth )/(1 + smooth);

        if ( !finite( startTimeSmoothedOffset_ ) )
        {
            // emergency, smoothing the timer produced infinite results
            st_Breakpoint();
            startTimeSmoothedOffset_ = startTimeOffset;
        }
    }

    // request syncs
    if (sn_GetNetState()==nSERVER && smoothedSystemTime_ >= nextSync_ )
    {
#ifdef nSIMULATE_PING
        RequestSync(); // ack.
#else
        RequestSync(false); // NO ack.
#endif
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void eTimer::Reset

(

REAL

t = 0

)

Definition at line 315 of file eTimer.cpp.

References nAverager::Add(), EPS, nAverager::GetAverage(), lastTime_, nCLIENT, nextSync_, qualityTester_, REAL, nAverager::Reset(), smoothedSystemTime_, sn_GetNetState(), speed, sqrt(), startTime_, startTimeOffset_, startTimeSmoothedOffset_, and tSysTimeFloat().

Referenced by eTimer(), and se_ResetGameTimer().

                        {
    if (sn_GetNetState()!=nCLIENT)
        speed=1;

    // reset start time
    smoothedSystemTime_ = tSysTimeFloat();
    startTime_ = smoothedSystemTime_ - t;

    // reset averagers
    startTimeOffset_.Reset();
    startTimeOffset_.Add(100,EPS);
    startTimeOffset_.Add(-100,EPS);

    qualityTester_.Reset();
    static const REAL qual = sqrt(1/EPS);
    qualityTester_.Add(qual,EPS);
    qualityTester_.Add(-qual,EPS);

    // reset times of actions
    lastTime_ = nextSync_ = smoothedSystemTime_;
    startTimeSmoothedOffset_ = startTimeOffset_.GetAverage();
}

Here is the call graph for this function:

Here is the caller graph for this function:

REAL eTimer::AverageFPS

(

)

[inline]

Definition at line 54 of file eTimer.h.

References averageSpf_, EPS, and nAverager::GetAverage().

Referenced by se_AverageFPS().

{return 1/(averageSpf_.GetAverage()+EPS);}

Here is the call graph for this function:

Here is the caller graph for this function:

REAL eTimer::AverageFrameTime

(

)

[inline]

Definition at line 55 of file eTimer.h.

References averageSpf_, and nAverager::GetAverage().

{return averageSpf_.GetAverage();}

Here is the call graph for this function:

REAL eTimer::FrameTime

(

)

[inline]

Definition at line 56 of file eTimer.h.

References spf_.

{return spf_;}

bool eTimer::IsSynced

(

)

const

returns whether the timer is synced sufficiently well to allow rendering

Definition at line 338 of file eTimer.cpp.

References creationSystemTime_, nAverager::GetAverage(), nAverager::GetAverageVariance(), tRecorderBase::IsPlayingBack(), nCLIENT, tRecorder::Playback(), tRecorder::Record(), section, smoothedSystemTime_, sn_GetNetState(), startTimeOffset_, and startTimeSmoothedOffset_.

Referenced by display_cockpit_lucifer(), and gGame::GameLoop().

{
    // allow non-synced status only during the first ten seconds of a connection
    if ( smoothedSystemTime_ - creationSystemTime_ > 10 || sn_GetNetState() != nCLIENT )
        return true;

    // the quality of the start time offset needs to be good enough (to .1 s, variance is the square of the expected)
    bool synced = startTimeOffset_.GetAverageVariance() < .01 &&
                  fabs( startTimeOffset_.GetAverage() - startTimeSmoothedOffset_ ) < .01;

    static char const * section = "TIMER_SYNCED";

    if ( tRecorder::IsPlayingBack() ? tRecorder::Playback( section ) : synced )
    {
        tRecorder::Record( section );

        // and make sure the next calls also return true.
        creationSystemTime_ = smoothedSystemTime_ - 11;
        return true;
    }

    return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

Member Data Documentation

REAL eTimer::speed

Definition at line 37 of file eTimer.h.

Referenced by gCycle::Act(), gGame::Analysis(), display_cockpit_lucifer(), eTimer(), pause(), ReadSync(), Reset(), sg_FullscreenMessage(), SyncTime(), TimeNoSync(), and WriteSync().

double eTimer::creationSystemTime_ [mutable, private]

the rough system time this timer was created at

Definition at line 61 of file eTimer.h.

Referenced by eTimer(), and IsSynced().

double eTimer::smoothedSystemTime_ [private]

the smoothed system time

Definition at line 62 of file eTimer.h.

Referenced by IsSynced(), ReadSync(), Reset(), SyncTime(), Time(), and WriteSync().

double eTimer::startTime_ [private]

when was the last game started?

Definition at line 63 of file eTimer.h.

Referenced by ReadSync(), Reset(), SyncTime(), and Time().

nAverager eTimer::startTimeOffset_ [private]

the smoothed average of this averager is added to the start time on the client

Definition at line 64 of file eTimer.h.

Referenced by IsSynced(), ReadSync(), Reset(), and SyncTime().

REAL eTimer::startTimeSmoothedOffset_ [private]

the smoothed average of startTimeOffset_

Definition at line 65 of file eTimer.h.

Referenced by IsSynced(), Reset(), SyncTime(), and Time().

nAverager eTimer::qualityTester_ [private]

averager that tells us about the quality of the sync messages

Definition at line 66 of file eTimer.h.

Referenced by ReadSync(), Reset(), and SyncTime().

REAL eTimer::spf_ [private]

last frame time

Definition at line 70 of file eTimer.h.

Referenced by FrameTime(), and SyncTime().

nAverager eTimer::averageSpf_ [private]

averager over seconds per frame

Definition at line 71 of file eTimer.h.

Referenced by AverageFPS(), AverageFrameTime(), eTimer(), and SyncTime().

double eTimer::lastTime_ [private]

the smoothed system time of the last update

Definition at line 73 of file eTimer.h.

Referenced by Reset(), SyncTime(), and TimeNoSync().

double eTimer::nextSync_ [private]

system time of the next sync to the clients

Definition at line 74 of file eTimer.h.

Referenced by Reset(), SyncTime(), and WriteSync().

---

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

• src/engine/eTimer.h
• src/engine/eTimer.cpp

---