Sorry your browser is not supported!

// Dark GDK - The Game Creators - www.thegamecreators.com

// the wizard has created a very simple project that uses Dark GDK
// it contains the basic code for a GDK application

// whenever using Dark GDK you must ensure you include the header file
#include "DarkGDK.h"

int Floor = 100;
int Ball =  101;

int I = 0 ;
int Box;
int MaxBoxes = 5;
int BoxTimer[MaxBoxes];

void MoveBall(int Ball);
float Distance (int Obj1,int Obj2);

// the main entry point for the application is this function
void DarkGDK ( void )
{
	// turn on sync rate and set maximum rate to 60 fps
	dbSyncOn   ( );
	dbSyncRate ( 60 );
	dbRandomize(dbTimer());



	// randomly place 5 boxes
	for ( Box=1; Box <= MaxBoxes;Box++){
		dbMakeObjectBox(Box, 2,2,2);
		dbPositionObject(Box, dbRnd(50)-25, 1,dbRnd(50)-25);
	}
	// create ball
	dbMakeObjectSphere(Ball,2);
	dbPositionObject(Ball,0,2,0);

	dbPositionCamera(0,25,25,-20);
	dbPointCamera(0,0,0,0);
	// our main loop
	while ( LoopGDK ( ) ){
		MoveBall(Ball);
		for ( Box=1; Box <= MaxBoxes;Box++){
			if (Distance(Ball,Box)< 10.0){
				BoxTimer[Box] = 0;
				dbColorObject(Box,dbRGB(0,0,0));
			}
			else {
				BoxTimer[Box]++;
				dbColorObject(Box,dbRGB(255,0,0));
			}

		}
		// update the screen

		for ( Box=1; Box <= MaxBoxes;Box++){
			dbText(10,20*Box,"Box Timer");dbText(100,20*Box, dbStr(Box));dbText(130,20*Box,dbStr(BoxTimer[Box]));
		}
		dbSync ( );
	}

	// return back to windows
	return;
}

void MoveBall(int Ball){
	 
float newX = dbObjectPositionX(Ball);
float newZ = dbObjectPositionZ(Ball);

newX = newX + (dbRnd(10)-5.0)/10.0;
newZ = newZ + (dbRnd(10)-5.0)/10.0;

dbPositionObject(Ball,newX,1.0,newZ);
}

float Distance (int Obj1, int Obj2){


float x1 = dbObjectPositionX(Obj1);
float y1 = dbObjectPositionY(Obj1);
float z1 = dbObjectPositionZ(Obj1);
float x2 = dbObjectPositionX(Obj2);
float y2 = dbObjectPositionY(Obj2);
float z2 = dbObjectPositionZ(Obj2);

	dbMakeVector3(1);
	dbSetVector3 ( 1, x1 - x2, y1 - y2, z1 - z2 );
    float length_vector = dbAbs(dbLengthVector3( 1 ));
    dbDeleteVector3 ( 1 );
return length_vector;
}

for ( int g=0; g<4; g++ ) // Check all objects to see which are within range
				{
				
				int labelx = dbObjectScreenX(g+6);
				int labely = dbObjectScreenY(g+6);
				if ( Dist[g] < 200 )	
										{ // Start timing proximity for those within range
										
										starttime = ( ( clock()/CLOCKS_PER_SEC ) - LastUpdate[g] ) ;
										dbText( labelx, labely+10, dbStr(starttime)); // Display counter next to object
										
										}
				else					{ // note last time object was not in range 
										LastUpdate[g] = clock()/CLOCKS_PER_SEC ;
										}
				}

#pragma once

//---------------------------------------------------------------------
class JGC_CLOCK{
//---------------------------------------------------------------------
public:
  int Time_New;
  int Time_Old;
  int Time_Elapsed;
  void Update(void);
  JGC_CLOCK();
  ~JGC_CLOCK();
};
//---------------------------------------------------------------------

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

//============================================================================
// Begin                       JGC_CLOCK
//============================================================================

//----------------------------------------------------------------------------
JGC_CLOCK::JGC_CLOCK(){
//----------------------------------------------------------------------------
  this->Time_New=dbTimer();
  this->Time_Old=this->Time_New-1; // force i millisec elapsed to start
  this->Time_Elapsed = this->Time_New - this->Time_Old; // Self documenting
  // not necessary - Not Harmful. 
};
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
JGC_CLOCK::~JGC_CLOCK(){
//----------------------------------------------------------------------------
};
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
void JGC_CLOCK::Update(void){ 
//----------------------------------------------------------------------------
  int TempTime = dbTimer();
  if(TempTime!=this->Time_New){
    this->Time_Old = this->Time_New;
    this->Time_New=TempTime;
    this->Time_Elapsed =  this->Time_New - this->Time_Old;
  };  
};
//----------------------------------------------------------------------------


//============================================================================
// End                         JGC_CLOCK
//============================================================================

#pragma once

//============================================================================
class JGC_TIMER{
//============================================================================
  public:
    int DelayInMSec;// How Long a Duration
    int TimesUp;// WHEN This Timer Goes Off Next
    bool DelayPassed(int p_iTimer);
    JGC_TIMER();
    ~JGC_TIMER();
    void Set(int p_iDelayInMSec);
};
//============================================================================

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

//============================================================================
// begin                                 JGC_TIMER
//============================================================================
//----------------------------------------------------------------------------
JGC_TIMER::JGC_TIMER(){
//----------------------------------------------------------------------------
  this->DelayInMSec=0;
  this->TimesUp=0;
};
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
JGC_TIMER::~JGC_TIMER(){
//----------------------------------------------------------------------------
};
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
void JGC_TIMER::Set(int p_iDelayInMSec){
//----------------------------------------------------------------------------
  this->DelayInMSec=p_iDelayInMSec;
  this->TimesUp=dbTimer()+this->DelayInMSec;
};
//----------------------------------------------------------------------------



//----------------------------------------------------------------------------
bool JGC_TIMER::DelayPassed(int p_iTimer){
//----------------------------------------------------------------------------
  bool bResult;
  if(bResult=(p_iTimer>=this->TimesUp)){
    // Reset THIS DELAY For Next Go Round
    this->TimesUp=p_iTimer+this->DelayInMSec;
  };
  return bResult;
};
//----------------------------------------------------------------------------

//============================================================================
// end                                 JGC_TIMER
//============================================================================

  // Before main loop for example....
  JGC_TIMER *MyTimer = new JGC_TIMER();
  Mytimer->Set(1000); // One Second
  
...
  // in main loop
  Clock->Update(); // Global Clock solution
  if(MyTimer->DelayPassed(Clock->Time_New)){
    // do Something here - Note the timer is already "reset"
    // for you! :)
  };

  JGC_TIMER *MyTimer;

JGC_TIMER MyTimer = new JGC_TIMER();

  JGC_TIMER(); // Constructor Declaration

  MyTimer->DelayPassed(dbTimer());