DWORD next_game_tick = GetTickCount();
int loops;
float interpolation;

bool game_is_running = true;
while( game_is_running ) {

loops = 0;
while( GetTickCount() > next_game_tick && loops < MAX_FRAMESKIP) {
update_game();

next_game_tick += SKIP_TICKS;
loops++;
}

interpolation = float( GetTickCount() + SKIP_TICKS – next_game_tick )
/ float( SKIP_TICKS );
display_game( interpolation );
}

Nice!

Its going to take me all week to get my head around this properly!

while (_run)
{
c = null;
next_tick=System.currentTimeMillis(); //fpss

try {
c = _surfaceHolder.lockCanvas(null);

synchronized (_surfaceHolder)
{
_panel.updatePhysics(sleep_time,fps);
_panel.onDraw(c);

if(fps_overall_flg)
{
skip_ticks = 1000/fps; //fpss
next_tick += skip_ticks;
sleep_time = (int) (next_tick – System.currentTimeMillis());

if(sleep_time>0 || sleep_time 0 )
{

sleep( sleep_time );
if(sleep_time>0 && fps_chg == true)
fps+=1;
}

else if(sleep_time 0 && sleep_time <10)
{ fps_chg = false; fps_overall_flg = false;}

Log.d("HEEELEOELEOE"," "+fps_overall_flg);
}

else
{sleep(sleep_time);Log.d("is sleepin for"," "+sleep_time);}

}

and i think its working fine….if any one find any problem in this code do tell me. Ill be thankful and will appreciate your corrections.

You’re right in that when GetTickCount() rolls over to 0, the while loop will evaluate to false and that iteration will be skipped. This is correct behavior, though, because the difference in time between GetTickCount() and nextGameTick at that particular moment will always be less than SKIP_TICKS and so the logic loop shouldn’t run. In other words, at that particular moment, not enough time has passed to need a logic update.

Where you’re a little off is thinking it’ll still take another ~49 days to run. By casting the result of (GetTickCount() – nextGameTick) to an unsigned int, you’re taking advantage of the wrap around behavior caused by integer overflow, ensuring that the result will always be a positive number. Initially (when GetTickCount rolls over to 0 and nextGameTick is stuck at, say, 4,294,967,295) the result of (unsigned int)(GetTickCount() – nextGameTick) will be 0. But as GetTickCount() is incremented, this result grows from 0 to 1, 2, 3 and so on until it will eventually (in a matter of milliseconds) surpass SKIP_TICKS, at which point the logic loop will run.

It’s tricky but the easiest way of understanding it is probably to see it in action. The simplest way is to code a little example for yourself. In C++ (or whatever language you’re comfortable with that has unsigned ints), set a uint variable to 4,294,967,295. Then increment this variable by some random amount (say, 10) and print the result. And for a more relevant example, set two uints (one called CurrentTickCount and one called NextGameTick) to 5 and 4,294,967,295. Then print the result of (unsigned int)(CurrentTickCount – NextGameTick).

You might be surprised. :]

while ( (unsigned long) (GetTickCount() – nextGameTick) > SKIP_TICKS && numloops < MAX_FRAME_SKIP )

but I first put 0 instead of SKIP_TICKS which gave me some headaches and some white hairs… so stupid am I…

I just wanted to add a little thing for some beginners too:

Suppose you wanted to rotate something at 90°/sec. You know that your game is refreshing the position of an object at X Hz or X times per second (25 here) so you need to recalculate the game logic speed. Here it is:

float real_speed = 90.0; //
float speed = real_speed / TICKS_PER_SECOND;

in you game logic:
angle = angle * speed;

in the drawing:
viewed_angle = angle + speed * interpolation;

It may seem trivial but this is just what I said earlier about letting others doing things for you!

while(unsigned int(0 – 4294967295) > 40 …)

will be while( 0 > 40 ),
and it also will never go into the loop to increase next_game_tick.
We still have to wait for 49 days.

The “0 – 4294967295″ would return -4294967295 except it’s then casted to an unsigned int (which can’t represent negative numbers) so instead it returns: 0.

is update_game() also an ansynchronous function?