Sorry your browser is not supported!

void GetAcceleration(){		
		if(bSpeed == true && fSpeed < 100.0f){	//acceleration
			fSpeed = fSpeed *1.05;
		}
		if(fSpeed > 100 && bSpeed == true){		//max speed
			fSpeed = 100.0f;
		}
		if(bSpeed == false){					//slowdown
			fSpeed = fSpeed * 0.97;
		}
		if(fSpeed < 2.0f && dbKeyState(17) == 0){
			fSpeed = 1.5f;

void GetUserInput(){
                  if(dbKeyState(17)== 1 && fSpeed > 2.0f)
		{											
			dbMoveObject(1,fSpeed);			
		}
		if(dbKeyState(17)== 0 && fSpeed > 2.0f)
		{
			dbMoveObject(1,fSpeed);			
		}

		if(dbKeyState(17) == 1){bSpeed = true;}
		if(dbKeyState(17) == 0){bSpeed = false;}
		}

Orin - First - I think this is important. Change your code to move not on arbitrary "values" that "look right" on your PC. Instead - learn how to user timer based movement. This way your game will run approximately the same "Speed" on various PC's.

Second - Animations work the same way with 3d Objects - in that you can drop the whole "loop" business - and Set the animation "Position" each loop - again based on timer logic. (Sounds harder than it is. Increment Animation frame by "Animation Increment Per Thousandth of a Sec * TimeElapsed".

Loop Object is very Rigid and is based on the Sync rate - and this may work - it is not a good practice to get into and rely on.

Note also - animations "frames" with 3d objects are actually floats - so you can have an animation frame be at 1.5 for example.

You may find smoother animation for example if your start frame is 2.34 and the end frame is 10.36. (Just made up values to get the point across)

Also - the whole idle - walking thing? A simple flag named something like IDLE: bool Idle; Should do ya. Set it to TRUE before you poll the user's keypresses. If any "Walking" keys are pressed - set this flag to FALSE (NOT IDLE)... Then change the object animation accordingly.

Hope this sparks some ideas. there are some good posts, threads, newletter articles and CODE BASE entries that discuss Timer Based Movement and Timer Based Animations.

To Summerize - dbTimer() is a function that returns Milliseconds since Midnight I think. The Whole FOUNDATION for TimerBased movement and animations is here:

jgc_clock.h
+ Code Snippet
#pragma once

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


jgc_clock.cpp
+ Code Snippet
#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
//============================================================================


Basically - this code has what ya need - but if you wish to use this class... At the top of your program make sure to 
+ Code Snippet
#include "jgc_clock.h"


then before your main loop - set up an instance of this class:
+ Code Snippet
  JGC_CLOCK *Clock = new JGC_CLOCK();


then in your main loop just call the update function at the top of your loop like this:
+ Code Snippet
  Clock->Update();


Now you can ALWAYS do timer based logic based on this value:

+ Code Snippet
  Clock->Time_Elapsed


Good Luck - hope this helps you out a bit.

/*============================================================================
|    _________ _______  _______  ______  _______    Jegas, LLC               |
|   /___  ___// _____/ / _____/ / __  / / _____/    JasonPSage@jegas.com     |
|      / /   / /__    / / ___  / /_/ / / /____                               |
|     / /   / ____/  / / /  / / __  / /____  /                               |
|____/ /   / /___   / /__/ / / / / / _____/ /                                |
/_____/   /______/ /______/ /_/ /_/ /______/                                 |
|                 Under the Hood                                             |
==============================================================================
           Copyright(c)2008 Jegas, LLC                      
============================================================================*/
#pragma once


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

/*============================================================================
|    _________ _______  _______  ______  _______    Jegas, LLC               |
|   /___  ___// _____/ / _____/ / __  / / _____/    JasonPSage@jegas.com     |
|      / /   / /__    / / ___  / /_/ / / /____                               |
|     / /   / ____/  / / /  / / __  / /____  /                               |
|____/ /   / /___   / /__/ / / / / / _____/ /                                |
/_____/   /______/ /______/ /_/ /_/ /______/                                 |
|                 Under the Hood                                             |
==============================================================================
           Copyright(c)2008 Jegas, LLC                      
============================================================================*/
#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. 
  this->Time_ElapsedFloat = (float)this->Time_Elapsed;
};
//----------------------------------------------------------------------------

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

//----------------------------------------------------------------------------
void JGC_CLOCK::Update(void){ 
//----------------------------------------------------------------------------
  int TempTime = dbTimer();
  this->Time_Old = this->Time_New;
  this->Time_New=TempTime;
  // PREVENT HUGE Time spans (1000=second)
  if((this->Time_Elapsed =  (this->Time_New - this->Time_Old))>1000){
    this->Time_Old=this->Time_New-1;
    this->Time_Elapsed=1;
  };
  this->Time_ElapsedFloat = (float)this->Time_Elapsed;
};
//----------------------------------------------------------------------------


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

#define ciCar_SpeedMult 0.01f

error C2065: 'Clock' : undeclared identifier
error C2227: left of '->Time_ElapsedFloat' must point to class/struct/union/generic type

JGC_CLOCK *Clock = new JGC_CLOCK();

MoveAmount = CarSpeed * Clock->Time_ElapsedFloat * MyThottleSpeedFloat;

JGC_CLOCK *Clock = new JGC_CLOCK();

#include "DarkGDK.h"
#include "jgc_clock.h"

float lavax,lavay,lavaz;
int timer,starttimer;
char fps [256] = "";

void DarkGDK ()
{

	// setup
	dbSetWindowPosition (0, 0);
	dbSetDisplayMode (1024, 768, 32);
	dbSetWindowOff ();
	dbHideMouse ();

	dbSyncOn ();
	dbSyncRate (60);

	dbSync();
	dbSync();

	dbColorBackdrop (0, 0);

	dbMakeObjectSphere (5, 100,30,30);
	lavax=140;
	lavay=80;
	lavaz=30;
	dbPositionObject (5,lavax,lavay,lavaz);

	dbPositionCamera (-60, 60, -170);

	JGC_CLOCK *Clock = new JGC_CLOCK();
	starttimer=dbTimer();

	while ( LoopGDK () )
	{

		Clock->Update(); 

		if (lavax>-150)
		{
			lavax=lavax-0.02*Clock->Time_ElapsedFloat;
			timer=dbTimer()-starttimer;
		}
		dbPositionObject (5,lavax,lavay,lavaz);

		sprintf ( fps, "timer: %d", timer);
		dbText ( dbScreenWidth ( ) - 20 - dbTextWidth ( fps ) , dbScreenHeight ( ) - 20 , fps );

		dbSync ();
	}

	// end
	return;
}	

/*============================================================================
|    _________ _______  _______  ______  _______    Jegas, LLC               |
|   /___  ___// _____/ / _____/ / __  / / _____/    JasonPSage@jegas.com     |
|      / /   / /__    / / ___  / /_/ / / /____                               |
|     / /   / ____/  / / /  / / __  / /____  /                               |
|____/ /   / /___   / /__/ / / / / / _____/ /                                |
/_____/   /______/ /______/ /_/ /_/ /______/                                 |
|                 Under the Hood                                             |
==============================================================================
           Copyright(c)2008 Jegas, LLC                      
============================================================================*/
#pragma once
#include "jfc_string.h"
//---------------------------------------------------------------------
// Create a Timer, which will immediately begin counting
// up from 0.0 seconds.
// You can call reset() to make it start over.
class JFC_CLOCK{
//---------------------------------------------------------------------
public:
  int Int_TimeNew;
  int Int_TimeOld;
  int Int_TimeElapsed;
  float Float_TimeNew;
  float Float_TimeOld;
  float Float_TimeElapsed;
  double Double_TimeNew;
  double Double_TimeOld;
  double Double_TimeElapsed;
  
  void Update(void);
  // Resets the Clock - However this only applies to the QueryPerformanceCounter Mode.
  void Reset(void);
  // seconds() returns the number of seconds (to very high resolution)
  // elapsed since the timer was last created or reset().
  double Seconds(void);
  // milli seconds() returns the number of milliseconds (to very high resolution)
  // elapsed since the timer was last created or reset().
  double Milliseconds(void);
  
  int Int_FPS(void);
  float Float_FPS(void);
  double Double_FPS(void);
  
  char *Date_Get(void);
  char *Time_Get(void);
  
  JFC_CLOCK(bool p_TickMode);
  ~JFC_CLOCK();

private:
  double pvt_QPCFrequency; 
  unsigned __int64 pvt_QPCBaseTime;
  unsigned __int64 pvt_QPCPerformanceFrequency;
  unsigned __int64 pvt_QPCValue;
  JFC_STRING *pvt_LastDateTimeResult;
  bool pvt_TickMode;
  DWORD pvt_TickStart;
  void pvt_FPSCalcPerRender(void);// Private function to be called per JDX_DADDY->Update() to calc FPS
  double pvt_FPS;// This will hold the number of frames per second in between seconds.
  double pvt_FPSCounter;// used internally to calc FPS
};
//---------------------------------------------------------------------


/*
//---------------------------------------------------------------------
#include <stdio.h>
// a simple test function 
int main() {
  JFC_CLOCK t;
  double a = t.seconds();
  Sleep( 1 );
  double b = t.seconds();
  t.reset();
  double c = t.seconds();
  printf( "%g %gn", b-a, c );
  return 0;
}
//---------------------------------------------------------------------
*/

/*============================================================================
|    _________ _______  _______  ______  _______    Jegas, LLC               |
|   /___  ___// _____/ / _____/ / __  / / _____/    JasonPSage@jegas.com     |
|      / /   / /__    / / ___  / /_/ / / /____                               |
|     / /   / ____/  / / /  / / __  / /____  /                               |
|____/ /   / /___   / /__/ / / / / / _____/ /                                |
/_____/   /______/ /______/ /_/ /_/ /______/                                 |
|                 Under the Hood                                             |
==============================================================================
           Copyright(c)2008 Jegas, LLC                      
============================================================================*/
#include <windows.h>
#include <time.h>
#include "jfc_clock.h"
#include "jfc_string.h"
//============================================================================
// Begin                       JFC_CLOCK
//============================================================================

//----------------------------------------------------------------------------
JFC_CLOCK::JFC_CLOCK(bool p_TickMode){
//----------------------------------------------------------------------------
  this->pvt_LastDateTimeResult=new JFC_STRING();
  this->pvt_TickMode=p_TickMode;
  this->Reset(); 
};
//----------------------------------------------------------------------------


//----------------------------------------------------------------------------
JFC_CLOCK::~JFC_CLOCK(){
//----------------------------------------------------------------------------
  delete this->pvt_LastDateTimeResult;
};
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
void JFC_CLOCK::Update(void){ 
//----------------------------------------------------------------------------
  if(this->pvt_TickMode){
    this->Int_TimeOld=this->Int_TimeNew;
    this->Int_TimeNew=GetTickCount();
    this->Int_TimeElapsed=this->Int_TimeNew-this->Int_TimeOld;
    this->Double_TimeNew=this->Int_TimeNew;  
    this->Double_TimeOld=this->Int_TimeOld;  
    this->Double_TimeElapsed=this->Int_TimeElapsed;  
  }else{
    double TempTime=this->Milliseconds();
    this->Double_TimeOld=this->Double_TimeNew;
    this->Double_TimeNew=TempTime;
    // PREVENT HUGE Time spans (1000=second)
    if((this->Double_TimeElapsed =  (this->Double_TimeNew - this->Double_TimeOld))>1000){
      this->Double_TimeOld=this->Double_TimeNew-1;
      this->Double_TimeElapsed=1;
    };
    this->Int_TimeNew=(int)this->Float_TimeNew;  
    this->Int_TimeOld=(int)this->Float_TimeOld;  
    this->Int_TimeElapsed=(int)this->Float_TimeElapsed;
  };

  this->Float_TimeNew=(float)this->Double_TimeNew;  
  this->Float_TimeOld=(float)this->Double_TimeOld;  
  this->Float_TimeElapsed=(float)this->Double_TimeElapsed;

  // BEGIN --------------------------------FPS Calculation
  // This will be used to check if a second has passed.
  double nextSecond = 0.0f;

  // This is the last second that occured.
  static double prevSecond = 0.0f;

  // Add to the frames per second every time this function is called.
  this->pvt_FPSCounter++;

  // Get the second in millisecond then multiply it by 0.001 to convert this to
  // seconds.
  nextSecond = this->Seconds();
  // If the time we have now substracted from the previous second is greater than
  // or equal to 1 (i.e. if a second has passed) then we display the FPS number.
  if(nextSecond - prevSecond > 1.0f){
    // Make the second we just got the previous second so we can used this the
    // next time the function is called.
    prevSecond = nextSecond;
    // Reset the FPS counter.
    this->pvt_FPS=this->pvt_FPSCounter;
    this->pvt_FPSCounter = 0;
  };
  // END --------------------------------FPS Calculation
};
//----------------------------------------------------------------------------




//----------------------------------------------------------------------------
int JFC_CLOCK::Int_FPS(void){
//----------------------------------------------------------------------------
  return this->pvt_FPS; 
};
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
float JFC_CLOCK::Float_FPS(void){
//----------------------------------------------------------------------------
  return this->pvt_FPS; 
};
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
double JFC_CLOCK::Double_FPS(void){
//----------------------------------------------------------------------------
  return this->pvt_FPS; 
};
//----------------------------------------------------------------------------


//----------------------------------------------------------------------------
// reset() makes the timer start over counting from 0.0 seconds.
void JFC_CLOCK::Reset(void){ 
//----------------------------------------------------------------------------
  pvt_FPS=0;// This will hold the number of frames per second in between seconds.
  pvt_FPSCounter=0;// used internally to calc FPS

  pvt_QPCFrequency=0.0f; 
  pvt_QPCBaseTime=0;
  pvt_QPCPerformanceFrequency=0;
  pvt_QPCValue=0;
  this->pvt_TickStart=GetTickCount(); 
  if(this->pvt_TickMode){
    this->Int_TimeNew=this->pvt_TickStart;
    this->Int_TimeOld=this->Int_TimeNew-1;
    this->Int_TimeElapsed=1;
    this->Float_TimeNew=this->Int_TimeNew;
    this->Float_TimeOld=this->Int_TimeOld;
    this->Float_TimeElapsed=this->Int_TimeElapsed;
    this->Double_TimeNew=this->Float_TimeNew;
    this->Double_TimeOld=this->Float_TimeOld; 
    this->Double_TimeElapsed=this->Float_TimeElapsed;     
  }else{ 
    QueryPerformanceFrequency( (LARGE_INTEGER *)&this->pvt_QPCPerformanceFrequency );
    pvt_QPCFrequency = 1.0 / (double)this->pvt_QPCPerformanceFrequency;
    QueryPerformanceCounter( (LARGE_INTEGER *)&pvt_QPCBaseTime );
    this->Double_TimeNew=this->Milliseconds();
    this->Double_TimeOld=this->Double_TimeNew-1; // force i millisec elapsed to start
    // Self documenting, not necessary - Not Harmful. 
    this->Double_TimeElapsed = this->Double_TimeNew - this->Double_TimeOld; 
    
    this->Float_TimeNew=(float)this->Double_TimeNew;  
    this->Float_TimeOld=(float)this->Double_TimeOld;  
    this->Float_TimeElapsed=(float)this->Double_TimeElapsed;
     
    this->Int_TimeNew=(int)this->Float_TimeNew;  
    this->Int_TimeOld=(int)this->Float_TimeOld;  
    this->Int_TimeElapsed=(int)this->Float_TimeElapsed;
  };
};
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
// seconds() returns the number of seconds (to very high resolution)
// elapsed since the timer was last created or reset().
double JFC_CLOCK::Seconds(void){
//----------------------------------------------------------------------------
  double Result=0;
  if(this->pvt_TickMode){
    Result=(GetTickCount()-this->pvt_TickStart) * (double)0.001; 
  }else{ 
    QueryPerformanceCounter( (LARGE_INTEGER *)&pvt_QPCValue );
    Result=(pvt_QPCValue - pvt_QPCBaseTime) * pvt_QPCFrequency;
  };  
  return Result;
}
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
// milli seconds() returns the number of milliseconds (to very high resolution)
// elapsed since the timer was last created or reset().
double JFC_CLOCK::Milliseconds(void) {
//----------------------------------------------------------------------------
  double Result;
  if(this->pvt_TickMode){
    Result=(GetTickCount()-this->pvt_TickStart); 
    return Result;
  }else{ 
    return this->Seconds() * 1000.0;
  };
};
//----------------------------------------------------------------------------


#ifndef _TM_DEFINED
struct tm {
        int tm_sec;     /* seconds after the minute - [0,59] */
        int tm_min;     /* minutes after the hour - [0,59] */
        int tm_hour;    /* hours since midnight - [0,23] */
        int tm_mday;    /* day of the month - [1,31] */
        int tm_mon;     /* months since January - [0,11] */
        int tm_year;    /* years since 1900 */
        int tm_wday;    /* days since Sunday - [0,6] */
        int tm_yday;    /* days since January 1 - [0,365] */
        int tm_isdst;   /* daylight savings time flag */
        };
#define _TM_DEFINED
#endif


//----------------------------------------------------------------------------
char *JFC_CLOCK::Date_Get(void){
//----------------------------------------------------------------------------
  char dateStr [9];
  _strdate_s(dateStr,sizeof(dateStr));
  this->pvt_LastDateTimeResult->Set(dateStr); 
  return this->pvt_LastDateTimeResult->s;
};
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
char *JFC_CLOCK::Time_Get(void){
//----------------------------------------------------------------------------
  char timeStr [9];
  _strtime_s( timeStr, sizeof(timeStr) );
  this->pvt_LastDateTimeResult->Set(timeStr); 
  return this->pvt_LastDateTimeResult->s;
};
//----------------------------------------------------------------------------

//============================================================================
// End                         JFC_CLOCK
//============================================================================

JFC_CLOCK *Clock = new JFC_CLOCK(true); // Tick Mode (use false to use Query Perf) 

Clock->Int_TimeNew  // Ints
Clock->Int_TimeOld 
Clock->Int_TimeElapsed 
Clock->Float_TimeNew // floats
Clock->Float_TimeOld;
Clock->Float_TimeElapsed;
Clock->Double_TimeNew; // Doubles
Clock->Double_TimeOld;
Clock->Double_TimeElapsed;

/*============================================================================
|    _________ _______  _______  ______  _______    Jegas, LLC               |
|   /___  ___// _____/ / _____/ / __  / / _____/    JasonPSage@jegas.com     |
|      / /   / /__    / / ___  / /_/ / / /____                               |
|     / /   / ____/  / / /  / / __  / /____  /                               |
|____/ /   / /___   / /__/ / / / / / _____/ /                                |
/_____/   /______/ /______/ /_/ /_/ /______/                                 |
|                 Under the Hood                                             |
==============================================================================
           Copyright(c)2008 Jegas, LLC                      
============================================================================*/
#pragma once
#include "jfc_string.h"
#include <windows.h>
//=============================================================================
class JFC_STRING{
//=============================================================================
  void pvt_Init(void);
public:  
  char *s;char chNull;
  LONGLONG uiLength;
  JFC_STRING();
  JFC_STRING(char *p_szDefaultValue);
  ~JFC_STRING();
  void Clear(void);
  void Clear(size_t p_NewLength);// allows making a buffer instantly.
  void ConCat(const char *p_char);
  void Set(const char *p_char);

  char *Get(void);
  size_t Length(void);
  bool EqualCS(char *p_szCompareThis); // Case Sensitive
  bool Equal(char *p_szCompareThis);
  void Left( char *p_szGrabFromThis, size_t p_HowMany);
  void Right( char *p_szGrabFromThis, size_t p_HowMany);
  void Mid(const char *p_szGrabFromThis, size_t p_Start, size_t p_HowMany);
  void Reverse(const char *p_szGrabFromThis);
  void Reverse(void);
  void Upper(const char *p_szGrabFromThis);
  void Upper(void);
  void Lower(const char *p_szGrabFromThis);
  void Lower(void);

  LONGLONG IndexOf(const char *p_szSearchFor, size_t p_StartHere, bool p_CaseSensitive=false);
  LONGLONG SNRChar(const char p_SearchFor, const char p_ReplaceWith, bool p_CaseSensitive=false);
  LONGLONG SNR(const char *p_SearchFor, const char *p_ReplaceWith, bool p_CaseSensitive=false);
  
  
};
//=============================================================================

/*============================================================================
|    _________ _______  _______  ______  _______    Jegas, LLC               |
|   /___  ___// _____/ / _____/ / __  / / _____/    JasonPSage@jegas.com     |
|      / /   / /__    / / ___  / /_/ / / /____                               |
|     / /   / ____/  / / /  / / __  / /____  /                               |
|____/ /   / /___   / /__/ / / / / / _____/ /                                |
/_____/   /______/ /______/ /_/ /_/ /______/                                 |
|                 Under the Hood                                             |
==============================================================================
           Copyright(c)2008 Jegas, LLC                      
============================================================================*/
#include "jfc_string.h"
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <windows.h>


//=============================================================================
JFC_STRING::JFC_STRING(){
//=============================================================================
  this->pvt_Init();
};
//=============================================================================

//=============================================================================
JFC_STRING::JFC_STRING(char *p_szDefaultValue){
//=============================================================================
  this->pvt_Init();
  this->Set(p_szDefaultValue); 
};
//=============================================================================


//=============================================================================
void JFC_STRING::pvt_Init(void){
//=============================================================================
  this->s=0;
  chNull='\0';
  this->Clear();
};
//=============================================================================



//=============================================================================
JFC_STRING::~JFC_STRING(){
//=============================================================================
  if(this->s!=0){    
    delete this->s;
  };
};
//=============================================================================

//=============================================================================
void JFC_STRING::Clear(void){
//=============================================================================
  if(this->s!=0){
    delete this->s;
  };
  this->uiLength=0;
  this->s=new char[(size_t)this->uiLength+1];
  this->s[this->uiLength]='\0';
};
//=============================================================================

//=============================================================================
void JFC_STRING::Clear(size_t p_NewLength){
//=============================================================================
  if(this->s!=0){
    delete this->s;
  };
  this->uiLength=p_NewLength;
  this->s=new char[(size_t)this->uiLength+1];
  this->s[this->uiLength]='\0';
  size_t i;
  for(i=0;i<this->uiLength;i++){
    this->s[i]='\0';
  };
};
//=============================================================================



//=============================================================================
void JFC_STRING::ConCat(const char *p_char){
//=============================================================================
  char *st;
  this->uiLength=strlen(p_char)+this->uiLength;
  size_t NewLen=(size_t)this->uiLength+1;
  st=new char[NewLen];
  st[0]=chNull;
  strcat_s(st,NewLen,this->s);
  strcat_s(st,NewLen,p_char);
  delete this->s;
  this->s=new char[NewLen];
  strcpy_s(this->s,NewLen,st);
  delete st;
  this->s[this->uiLength]='\0';
};
//=============================================================================

//=============================================================================
void JFC_STRING::Set(const char *p_char){
//=============================================================================
  this->Clear();
  this->ConCat(p_char);
};
//=============================================================================

//=============================================================================
char *JFC_STRING::Get(void){
//=============================================================================
  if(this->s!=0){
    return this->s;
  }else{
    return 0;
  };
};
//=============================================================================

//=============================================================================
size_t JFC_STRING::Length(void){
//=============================================================================
  return (size_t)this->uiLength;
};
//=============================================================================



//=============================================================================
bool JFC_STRING::EqualCS(char *p_szCompareThis){
//=============================================================================
  return (strcmp(this->s,p_szCompareThis)==0); 
};
//=============================================================================

//=============================================================================
bool JFC_STRING::Equal(char *p_szCompareThis){
//=============================================================================
  return (_strcmpi(this->s,p_szCompareThis)==0); 
};
//=============================================================================

//=============================================================================
void JFC_STRING::Left( char *p_szGrabFromThis, size_t p_HowMany){
//=============================================================================
// TODO: Optimize this - I needed functionality and just cranked out a 
// function to do it. 
  JFC_STRING *ts=new JFC_STRING();
  ts->Set(p_szGrabFromThis);
  this->Clear(); 
  if(p_HowMany>0){
    size_t i=0;
    char c[2];c[1]=0;
    while(i<ts->uiLength && i<p_HowMany){
     c[0]=ts->s[i];
     this->ConCat(c);
     i++;
    }
  }; 
  delete ts;
};
//=============================================================================

//=============================================================================
void JFC_STRING::Right( char *p_szGrabFromThis, size_t p_HowMany){
//=============================================================================
// TODO: Optimize this - I needed functionality and just cranked out a 
// function to do it. 
  JFC_STRING *ts=new JFC_STRING();
  ts->Set(p_szGrabFromThis);
  this->Clear(); 
  if(p_HowMany>0){
    LONGLONG i=ts->uiLength-(LONGLONG)p_HowMany;
    if(i<0){
      this->Set(ts->s);
    }else{
      char c[2];c[1]=0;
      while(i<ts->uiLength){
       c[0]=ts->s[i];
       this->ConCat(c);
       i++;
      }
    };
  }; 
  delete ts;
};
//=============================================================================

//=============================================================================
void JFC_STRING::Mid(const char *p_szGrabFromThis, size_t p_Start, size_t p_HowMany){
//=============================================================================
// TODO: Optimize this - I needed functionality and just cranked out a 
// function to do it. 
  JFC_STRING *ts=new JFC_STRING();
  ts->Set(p_szGrabFromThis);
  this->Clear(); 
  if(p_Start>=0){
    size_t i=p_Start;
    char c[2];c[1]=0;
    while(i<ts->uiLength && p_HowMany>0){
     c[0]=ts->s[i];
     this->ConCat(c);
     i++;
     p_HowMany--;
    }
  }; 
  delete ts;
};
//=============================================================================

//=============================================================================
void JFC_STRING::Reverse(const char *p_szGrabFromThis){
//=============================================================================
  JFC_STRING *ts=new JFC_STRING();
  ts->Set(p_szGrabFromThis);
  this->Set(_strrev(ts->s));
  delete ts;
};
//=============================================================================

//=============================================================================
void JFC_STRING::Reverse(void){
//=============================================================================
  JFC_STRING *ts=new JFC_STRING();
  ts->Set(_strrev(this->s));
  this->Set(ts->s);
  delete ts;
};
//=============================================================================


//=============================================================================
void JFC_STRING::Upper(const char *p_szGrabFromThis){
//=============================================================================
  this->Set(p_szGrabFromThis);
  this->Upper();
};
//=============================================================================

//=============================================================================
void JFC_STRING::Upper(void){
//=============================================================================
// TODO: Optimize this - I needed functionality and just cranked out a 
// function to do it. 
  for(size_t i=0;i<this->uiLength;i++){
    this->s[i]=(char)toupper(this->s[i]);
  };
};
//=============================================================================


//=============================================================================
void JFC_STRING::Lower(const char *p_szGrabFromThis){
//=============================================================================
  this->Set(p_szGrabFromThis);
  this->Lower();
};
//=============================================================================

//=============================================================================
void JFC_STRING::Lower(void){
//=============================================================================
// TODO: Optimize this - I needed functionality and just cranked out a 
// function to do it. 
  for(size_t i=0;i<this->uiLength;i++){
    this->s[i]=(char)tolower(this->s[i]);
  };
};
//=============================================================================



//=============================================================================
LONGLONG JFC_STRING::IndexOf(const char *p_szSearchFor, size_t p_StartHere, bool p_CaseSensitive){
//=============================================================================
// TODO: Optimize this - I needed functionality and just cranked out a 
// function to do it. 
  JFC_STRING *ts=new JFC_STRING();
  ts->Set(p_szSearchFor);
  bool bGotIt=false;
  LONGLONG Index=-1;
  if(p_StartHere>=0){
    for(Index=p_StartHere;Index<this->uiLength;Index++){
      bGotIt=true;
      LONGLONG i=0;LONGLONG p=0;
      for(i=Index;i<this->uiLength && p<ts->uiLength;i++){
        if(p_CaseSensitive){
          if(this->s[i]!=ts->s[p]){
            bGotIt=false;
            i=ts->uiLength;//force next outside loop iteration
            break;
          };
        }else{
          //char c1=tolower(this->s[i]);
          //char c2=tolower(ts->s[p]);
          //if(c1!=c2){
          if(tolower(this->s[i])!=tolower(ts->s[p])){
            bGotIt=false;
            i=ts->uiLength;//force next outside loop iteration
          };
        };
        p++;
      };
      if(bGotIt){
        delete ts;
        return Index;
      };
    };
  };
  delete ts;
  return -1;
};
//=============================================================================

//=============================================================================
LONGLONG JFC_STRING::SNRChar(const char p_SearchFor, const char p_ReplaceWith, bool p_CaseSensitive){
//=============================================================================
// TODO: Optimize this - I needed functionality and just cranked out a 
// function to do it. 
  LONGLONG Index=-1;
  LONGLONG LastIndex=-1;
  LONGLONG Changes=0;
  char c[2];c[0]=p_SearchFor;c[1]=0;
  do{
    if(Index>-1){
      this->s[Index]=p_ReplaceWith;
      Changes+=1;
    };
    LastIndex=Index;
    Index=this->IndexOf(c,0,p_CaseSensitive);
  }while(LastIndex!=Index);
  return Changes;
};
//=============================================================================

//=============================================================================
LONGLONG JFC_STRING::SNR(const char *p_SearchFor, const char *p_ReplaceWith, bool p_CaseSensitive){
//=============================================================================
// TODO: Optimize this - I needed functionality and just cranked out a 
// function to do it. 
  LONGLONG Index=-1;
  LONGLONG LastIndex=-1;
  JFC_STRING *ts=new JFC_STRING();
  JFC_STRING *so=new JFC_STRING(this->s);
  LONGLONG Changes=0;
  do{
    if(Index>-1){
      this->Mid(so->s,0,(size_t)Index);
      ts->Set(this->s);
      size_t Len=strlen(p_SearchFor);
      size_t cutend=(size_t)(Index+Len);
      this->Mid(so->s,cutend,(size_t)so->uiLength);
      ts->ConCat(p_ReplaceWith);
      ts->ConCat(this->s);
      so->Set(ts->s);
      Changes+=1;
    };
    LastIndex=Index;
    Index=so->IndexOf(p_SearchFor,0,p_CaseSensitive);
  }while(LastIndex!=Index);
  this->Set(so->s);
  delete so;
  delete ts;
  return Changes;
};
//=============================================================================

/*============================================================================
|    _________ _______  _______  ______  _______    Jegas, LLC               |
|   /___  ___// _____/ / _____/ / __  / / _____/    JasonPSage@jegas.com     |
|      / /   / /__    / / ___  / /_/ / / /____                               |
|     / /   / ____/  / / /  / / __  / /____  /                               |
|____/ /   / /___   / /__/ / / / / / _____/ /                                |
/_____/   /______/ /______/ /_/ /_/ /______/                                 |
|                 Under the Hood                                             |
==============================================================================
           Copyright(c)2008 Jegas, LLC                      
============================================================================*/
#pragma once
#include <windows.h>
#include "jfc_string.h"
//=============================================================================
class JFC_STRINGW{
//=============================================================================
  void pvt_Init(void);
public:  
  wchar_t *s;wchar_t chNull;
  LONGLONG uiLength;
  JFC_STRINGW();
  JFC_STRINGW(wchar_t *p_wszDefaultValue);
  ~JFC_STRINGW();
  void Clear(void);
  void Clear(size_t p_NewLength);// allows making a buffer instantly.
  void ConCat(const wchar_t *p_wchar);
  void ConCat(const char *p_char);
  void Set(const wchar_t *p_wchar);
  void Set(const char *p_char);
  wchar_t *Get(void);
  size_t Length(void);
  bool EqualCS(wchar_t *p_wszCompareThis); // Case Sensitive
  bool Equal(wchar_t *p_wszCompareThis);
  void Left( wchar_t *p_wszGrabFromThis, size_t p_HowMany);
  void Right( wchar_t *p_wszGrabFromThis, size_t p_HowMany);
  void Mid(const wchar_t *p_wszGrabFromThis, size_t p_Start, size_t p_HowMany);
  void Reverse(const wchar_t *p_wszGrabFromThis);
  void Reverse(void);
  void Upper(const wchar_t *p_wszGrabFromThis);
  void Upper(void);
  void Lower(const wchar_t *p_wszGrabFromThis);
  void Lower(void);

  // Not Implemented Yet
  LONGLONG IndexOf(const wchar_t *p_wszSearchFor, size_t p_StartHere, bool p_CaseSensitive=false);
  LONGLONG SNRChar(const wchar_t p_wszSearchFor, const wchar_t p_wszReplaceWith, bool p_CaseSensitive=false);
  LONGLONG SNR(const wchar_t *p_wszSearchFor, const wchar_t *p_wszReplaceWith, bool p_CaseSensitive=false);
};
//=============================================================================

/*============================================================================
|    _________ _______  _______  ______  _______    Jegas, LLC               |
|   /___  ___// _____/ / _____/ / __  / / _____/    JasonPSage@jegas.com     |
|      / /   / /__    / / ___  / /_/ / / /____                               |
|     / /   / ____/  / / /  / / __  / /____  /                               |
|____/ /   / /___   / /__/ / / / / / _____/ /                                |
/_____/   /______/ /______/ /_/ /_/ /______/                                 |
|                 Under the Hood                                             |
==============================================================================
           Copyright(c)2008 Jegas, LLC                      
============================================================================*/
#include "jfc_stringw.h"
#include "jfc_string.h"
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <locale.h>


//=============================================================================
JFC_STRINGW::JFC_STRINGW(){
//=============================================================================
  this->pvt_Init();
};
//=============================================================================

//=============================================================================
JFC_STRINGW::JFC_STRINGW(wchar_t *p_wszDefaultValue){
//=============================================================================
  this->pvt_Init();
  this->Set(p_wszDefaultValue); 
};
//=============================================================================


//=============================================================================
void JFC_STRINGW::pvt_Init(void){
//=============================================================================
  this->s=0;
  chNull='\0';
  this->Clear();
};
//=============================================================================



//=============================================================================
JFC_STRINGW::~JFC_STRINGW(){
//=============================================================================
  if(this->s!=0){    
    delete this->s;
  };
};
//=============================================================================

//=============================================================================
void JFC_STRINGW::Clear(void){
//=============================================================================
  if(this->s!=0){
    delete this->s;
  };
  this->uiLength=0;
  this->s=new wchar_t[(size_t)this->uiLength+1];
  this->s[this->uiLength]='\0';
};
//=============================================================================

//=============================================================================
void JFC_STRINGW::Clear(size_t p_NewLength){
//=============================================================================
  if(this->s!=0){
    delete this->s;
  };
  this->uiLength=p_NewLength;
  this->s=new wchar_t[(size_t)(this->uiLength+1)]; 
  this->s[this->uiLength]='\0';
  LONGLONG i;
  for(i=0;i<(LONGLONG)this->uiLength;i++){
    this->s[i]='\0';
  };
};
//=============================================================================

//=============================================================================
void JFC_STRINGW::ConCat(const char *p_char){
//=============================================================================
  JFC_STRING *s=new JFC_STRING();
  s->Set(p_char);
  if(s->uiLength>0){
    size_t wlen=(s->uiLength+1) * 2;// I kept getting error without the * 2
    wchar_t *w = new wchar_t[wlen];
    for(LONGLONG i=0;i<s->uiLength;i++){
      w[i]=s->s[i];
    };
    w[s->uiLength+1]=0;
    this->ConCat(w);
    delete w;
  };
  delete s;
};
//=============================================================================


//=============================================================================
void JFC_STRINGW::ConCat(const wchar_t *p_wchar){
//=============================================================================
  wchar_t *st;
  this->uiLength=(size_t)(wcslen(p_wchar)+this->uiLength);
  size_t NewLen=(size_t)(this->uiLength+1);
  st=new wchar_t[NewLen];
  st[0]=chNull;
  wcscat_s(st,NewLen,this->s);
  wcscat_s(st,NewLen,p_wchar);
  delete this->s;
  this->s=new wchar_t[NewLen];
  wcscpy_s(this->s,NewLen,st);
  delete st;
  this->s[this->uiLength]='\0';
};
//=============================================================================

//=============================================================================
void JFC_STRINGW::Set(const wchar_t *p_wchar){
//=============================================================================
  this->Clear();
  this->ConCat(p_wchar);
};
//=============================================================================

//=============================================================================
void JFC_STRINGW::Set(const char *p_char){
//=============================================================================
  this->Clear();
  this->ConCat(p_char);
};
//=============================================================================




//=============================================================================
wchar_t *JFC_STRINGW::Get(void){
//=============================================================================
  if(this->s!=NULL){
    return this->s;
  }else{
    return NULL;
  };
};
//=============================================================================

//=============================================================================
size_t JFC_STRINGW::Length(void){
//=============================================================================
  return (size_t)this->uiLength;
};
//=============================================================================



//=============================================================================
bool JFC_STRINGW::EqualCS(wchar_t *p_wszCompareThis){
//=============================================================================
  return (wcscmp(this->s,p_wszCompareThis)==NULL); 
};
//=============================================================================

//=============================================================================
bool JFC_STRINGW::Equal(wchar_t *p_wszCompareThis){
//=============================================================================
  return (_wcsicmp(this->s,p_wszCompareThis)==NULL); 
};
//=============================================================================

//=============================================================================
void JFC_STRINGW::Left( wchar_t *p_wszGrabFromThis, size_t p_HowMany){
//=============================================================================
// TODO: Optimize this - I needed functionality and just cranked out a 
// function to do it. 
  JFC_STRINGW *ts=new JFC_STRINGW();
  ts->Set(p_wszGrabFromThis);
  this->Clear(); 
  if(p_HowMany>0){
    size_t i=0;
    wchar_t c[2];c[1]=0;
    while(i<ts->uiLength && i<p_HowMany){
     c[0]=ts->s[i];
     this->ConCat(c);
     i++;
    }
  }; 
  delete ts;
};
//=============================================================================

//=============================================================================
void JFC_STRINGW::Right( wchar_t *p_wszGrabFromThis, size_t p_HowMany){
//=============================================================================
// TODO: Optimize this - I needed functionality and just cranked out a 
// function to do it. 
  JFC_STRINGW *ts=new JFC_STRINGW();
  ts->Set(p_wszGrabFromThis);
  this->Clear(); 
  if(p_HowMany>0){
    LONGLONG i=ts->uiLength-p_HowMany;
    if(i<0){
      this->Set(ts->s);
    }else{
      wchar_t c[2];c[1]=0;
      while(i<ts->uiLength){
       c[0]=ts->s[i];
       this->ConCat(c);
       i++;
      }
    };
  }; 
  delete ts;
};
//=============================================================================

//=============================================================================
void JFC_STRINGW::Mid(const wchar_t *p_wszGrabFromThis, size_t p_Start, size_t p_HowMany){
//=============================================================================
// TODO: Optimize this - I needed functionality and just cranked out a 
// function to do it. 
  JFC_STRINGW *ts=new JFC_STRINGW();
  ts->Set(p_wszGrabFromThis);
  this->Clear(); 
  if(p_Start>=0){
    size_t i=p_Start;
    wchar_t c[2];c[1]=0;
    while(i<ts->uiLength && p_HowMany>0){
     c[0]=ts->s[i];
     this->ConCat(c);
     i++;
     p_HowMany--;
    }
  }; 
  delete ts;
};
//=============================================================================

//=============================================================================
void JFC_STRINGW::Reverse(const wchar_t *p_wszGrabFromThis){
//=============================================================================
  JFC_STRINGW *ts=new JFC_STRINGW();
  ts->Set(p_wszGrabFromThis);
  this->Set(_wcsrev(ts->s));
  delete ts;
};
//=============================================================================

//=============================================================================
void JFC_STRINGW::Reverse(void){
//=============================================================================
  JFC_STRINGW *ts=new JFC_STRINGW();
  ts->Set(_wcsrev(this->s));
  this->Set(ts->s);
  delete ts;
};
//=============================================================================


//=============================================================================
void JFC_STRINGW::Upper(const wchar_t *p_wszGrabFromThis){
//=============================================================================
  this->Set(p_wszGrabFromThis);
  this->Upper();
};
//=============================================================================

//=============================================================================
void JFC_STRINGW::Upper(void){
//=============================================================================
// TODO: Optimize this - I needed functionality and just cranked out a 
// function to do it. 
  for(size_t i=0;i<this->uiLength;i++){
    this->s[i]=(wchar_t)toupper(this->s[i]);
  };
};
//=============================================================================


//=============================================================================
void JFC_STRINGW::Lower(const wchar_t *p_wszGrabFromThis){
//=============================================================================
  this->Set(p_wszGrabFromThis);
  this->Lower();
};
//=============================================================================

//=============================================================================
void JFC_STRINGW::Lower(void){
//=============================================================================
// TODO: Optimize this - I needed functionality and just cranked out a 
// function to do it. 
  for(size_t i=0;i<this->uiLength;i++){
    this->s[i]=(wchar_t)tolower(this->s[i]);
  };
};
//=============================================================================



//=============================================================================
LONGLONG JFC_STRINGW::IndexOf(const wchar_t *p_wszSearchFor, size_t p_StartHere, bool p_CaseSensitive){
//=============================================================================
// TODO: Optimize this - I needed functionality and just cranked out a 
// function to do it. 
  JFC_STRINGW *ts=new JFC_STRINGW();
  ts->Set(p_wszSearchFor);
  bool bGotIt=false;
  LONGLONG Index=-1;
  if(p_StartHere>=0){
    for(Index=p_StartHere;Index<this->uiLength;Index++){
      bGotIt=true;
      LONGLONG i=0;LONGLONG p=0;
      for(i=Index;i<this->uiLength && p<ts->uiLength;i++){
        if(p_CaseSensitive){
          if(this->s[i]!=ts->s[p]){
            bGotIt=false;
            i=ts->uiLength;//force next outside loop iteration
            break;
          };
        }else{
          //char c1=tolower(this->s[i]);
          //char c2=tolower(ts->s[p]);
          //if(c1!=c2){
          if(tolower(this->s[i])!=tolower(ts->s[p])){
            bGotIt=false;
            i=ts->uiLength;//force next outside loop iteration
          };
        };
        p++;
      };
      if(bGotIt){
        delete ts;
        return Index;
      };
    };
  };
  delete ts;
  return -1;
};
//=============================================================================

//=============================================================================
LONGLONG JFC_STRINGW::SNRChar(const wchar_t p_wszSearchFor, const wchar_t p_wszReplaceWith, bool p_CaseSensitive){
//=============================================================================
// TODO: Optimize this - I needed functionality and just cranked out a 
// function to do it. 
  LONGLONG Index=-1;
  LONGLONG LastIndex=-1;
  LONGLONG Changes=0;
  wchar_t c[2];c[0]=p_wszSearchFor;c[1]=0;
  do{ 
    if(Index>-1){
      this->s[Index]=p_wszReplaceWith;
      Changes+=1;
    };
    LastIndex=Index;
    Index=this->IndexOf(c,0,p_CaseSensitive);
  }while(LastIndex!=Index);
  return Changes;
};
//=============================================================================

//=============================================================================
LONGLONG JFC_STRINGW::SNR(const wchar_t *p_wszSearchFor, const wchar_t *p_wszReplaceWith, bool p_CaseSensitive){
//=============================================================================
// TODO: Optimize this - I needed functionality and just cranked out a 
// function to do it. 
  LONGLONG Index=-1;
  LONGLONG LastIndex=-1;
  JFC_STRINGW *ts=new JFC_STRINGW();
  JFC_STRINGW *so=new JFC_STRINGW(this->s);
  LONGLONG Changes=0;
  do{
    if(Index>-1){
      this->Mid(so->s,0,(size_t)Index);
      ts->Set(this->s);
      LONGLONG Len=wcslen(p_wszSearchFor);
      LONGLONG cutend=Index+Len;
      this->Mid(so->s,(size_t)cutend,(size_t)so->uiLength);
      ts->ConCat(p_wszReplaceWith);
      ts->ConCat(this->s);
      so->Set(ts->s);
      Changes+=1;
    };
    LastIndex=Index;
    Index=so->IndexOf(p_wszSearchFor,0,p_CaseSensitive);
  }while(LastIndex!=Index);
  this->Set(so->s);
  delete so;
  delete ts;
  return Changes;
};
//=============================================================================

void main()
{
        JGC_CLOCK *Clock = new JGC_CLOCK();
	while ( LoopGDK ( ) )
	{
           DummyMove(); //uses Time_ElapsedFloat from JGC_CLOCK
           Clock->Update();
           dbSync();
        }
}

DummyMove();
dbSync();
Clock->Update();

Clock->Update();
DummyMove();
dbSync();

dTimeFactor = (Clock->Double_TimeElapsed / 1000.0f)

//To move something i use
//dTimeToTravel is the time it gonna take to travel the dDistance
//measured in seconds
dAdvance = (dTimeFactor * dDistance) / dTimeToTravel;