Sorry your browser is not supported!

#include "DarkGDK.h"
#include <windows.h>

void DarkGDK(void)
{
 dbSyncOn();
 dbSyncRate(60);

 DWORD timer_a = GetTickCount();

 bool bGameLoop = true;

 while(bGameLoop == true) //while(LoopGDK())
 {
  //do stuff
  if(GetTickCount() > timer_a+2000)
  {
   dbCenterText(dbScreenWidth()/2,dbScreenHeight()/2,"2 Seconds (2000 miliseconds) have passed after last timer_a update.");
  }
  //do stuff
  dbSync();
  //other syncing methods
 }
return;
}

int Timers[10];
  for (int count=0;count<11;count++){
    Timers[count]=dbTimer();
  }

  if (dbTimer()-Timers[4]>1500){

      Timers[4]=dbTimer();
      if (iCrateCount<311){ // crates
        iCrateCount++;
        dbPhyMakeRigidBodyDynamicBox(iCrateCount);
        dbPhyAddRigidBodyForce(iCrateCount,0,200,0,1);
        dbPhySetRigidBodyMass(objid,1.0);
        dbShowObject(iCrateCount);
      } 
  }

If (something=true){
  Timers[1]=dbTimer();
}

if (dbTimer()-Timers[1]>2000){
  do some stuff;
  fade the text;
  load the next level;
}

//Example
 /* clock example: countdown */
#include <stdio.h>
#include <time.h>

void wait ( int seconds )
{
  clock_t endwait;
  endwait = clock () + seconds * CLOCKS_PER_SEC ;
  while (clock() < endwait) {}
}

int main ()
{
  int n;
  printf ("Starting countdown...\n");
  for (n=10; n>0; n--)
  {
    printf ("%d\n",n);
    wait (1);
  }
  printf ("FIRE!!!\n");
  return 0;
}

Starting countdown...
10
9
8
7
6
5
4
3
2
1
FIRE!!!

 

//
//TIMER.H
//
//header guards
#ifndef _HX_11_TIMERS_H_
#define _HX_11_TIMERS_H_

#define HX_TIMR_TYPE				float
#define HX_TIMER_SECONDS		1
#define HX_TIMER_MINUTES		(1.0f/60.0f)
#define HX_TIMER_HOURS			((1.0f/60.0f)/60.0f)
#define HX_TIMER_MILLISECONDS	1000
#define HX_TIMER_MICROSECONDS	1000000

/*********************************************************************
*********************************hxTimer*****************************
Timers class
*********************************************************************/
class hxTimerImpl;
class hxTimer
{
	friend class hxTimerImpl;

protected:
	hxTimerImpl* __Impl__;

public:
	hxTimer ( float fUnit = HX_TIMER_MILLISECONDS );
	~hxTimer ( void );
	
	void				Start					( void );
	void				Pause					( void );
	void				Reset					( void );
	
	HX_TIMR_TYPE	GetElapsedTime		( void ) const;
};


#endif //_HX_11_TIMERS_H_

//
//TIMER.cpp
//
#include "Timer.h"

float _SPC = 0;

class hxTimerImpl
{
	__int64 _startTime;
	__int64 _pauseStartTime;
	__int64 _totalPauseTime;
	float _unit;

	HX_TIMR_TYPE _GetCurrentTime ( void ) const
	{
		//calculate elapsed time
		__int64 currtime = 0;
		QueryPerformanceCounter ( (LARGE_INTEGER*)&currtime );
		return currtime;
	};
	HX_TIMR_TYPE GetPauseTime ( void ) const
	{
		if ( _pauseStartTime )
			return 0;

		return _GetCurrentTime ( ) - _pauseStartTime;
	};

public:
	hxTimerImpl ( float fUnit )
	{
		_unit = fUnit;

		//initialize accurate timing system
		if ( _SPC == 0 )
		{
			__int64 countsPerSec;
			QueryPerformanceFrequency ( (LARGE_INTEGER*)&countsPerSec );
			_SPC = 1.0f / (float)countsPerSec;
		}

		Reset ( );
	};
	~hxTimerImpl ( void )
	{
	};

	void Start ( void )
	{
		_totalPauseTime += GetPauseTime ( );
		_pauseStartTime = -1;
	};
	void Pause ( void )
	{
		_pauseStartTime = _GetCurrentTime ( );
	};
	void Reset ( void )
	{
		_startTime = _GetCurrentTime ( );
		_totalPauseTime = 0;
		Pause ( );
	};
	HX_TIMR_TYPE GetElapsedTime ( void ) const
	{
		HX_TIMR_TYPE totalElapsedTime = _GetCurrentTime ( ) - _startTime;
		return ((totalElapsedTime - (_totalPauseTime + GetPauseTime ( )))*_SPC)*_unit; //multiply to convert unit
	};
};

hxTimer::hxTimer ( float fUnit ) : __Impl__ ( new hxTimerImpl ( fUnit ) )
{
}
hxTimer::~hxTimer ( void )
{
	HX_SAFE_DELETE ( __Impl__ );
}
void hxTimer::Start ( void )
{
	__Impl__->Start ( );
}
void hxTimer::Pause ( void )
{
	__Impl__->Pause ( );
}
void hxTimer::Reset ( void )
{
	__Impl__->Reset ( );
}
HX_TIMR_TYPE hxTimer::GetElapsedTime ( void ) const
{
	return __Impl__->GetElapsedTime ( );
}

hxTimer tmr;
tmr.Start ( ); //starts the timer
tmr.Pause ( ); //pauses the timer
tmr.Reset ( ); //resets the timer and pauses it
tmr.GetElapsedTime ( ); //gets the time since the last start, pause time is calculated automatically

hxTimer tmr ( HX_TIMER_MINUTES );
tmr.Start ( );
//do some stuff here..
float fElapsedTimeInMinutes = tmr.GetElapsedTime ( );

#define HX_TIMR_TYPE				float

#define HX_TIMR_TYPE				__int64

	//begin accurate timing system
	timeBeginPeriod ( 1 );

	//end accurate timing system
	timeEndPeriod ( 1 );