Or you could simply timestamp the animation (using GetTickCount or similar) when it starts, then whenever you want to draw the sprite just get the delta time (GetTickCount()-StartTime), and determine which frame matches that delta.

For instance:
The sprite has 12 frames (frame 0 to 11) and should be animated at 10fps (the frame displayed should change every 100ms). If DeltaTime is 4000 (4 seconds have passed since the animation loop started) then
DisplayFrame = (DeltaTime div 100) mod 12;
so
DisplayFrame = (4000 div 100) mod 12;
DisplayFrame = 4

This prevents the inaccuracy in the timer from building up over time (the timer is likely +/-5ms the actual time)



Edited by - Michalson on February 21, 2002 2:17:21 PM

This is how you can do it. Lets say you want your sprite to move 10 pixels in 2 seconds (or 2000 miliseconds). Ill refer to the 10 pixels as "distance" and the 2 seconds as "end time".

Use a timer and get a time when your program first starts (outside of your main game loop). A good timer for this is GetTickCount()). Store that in a value (ie: int oldTime). Lets just say it returned 100,000 miliseconds since Windows has started.

Now in your main game loop get the time for each frame. Store this in a value as well (ie: int newTime). Lets say that returned 100,050 miliseconds.

Now you want to take newTime - oldTime to get the amount of miliseconds that has passed between the two frames. This would equal 50 miliseconds. Now we know the sprite will move every 50 miliseconds.

But how many times will it move before 2 seconds has passed (or the end time)?. We can represent this with the formula "x * 50 = end time". "x" is the number of times the sprite will move before the end time is reached. Using simple algebra you can make the formula "x = end time / 50" or "x = end time / (newTime - oldTime)". Remember we got 50 miliseconds from finding the amount of miliseconds between two frames. The answer should give you 40 times that the sprite will move.

So now we got the formula "end time/(oldTime - newTime)" which gives you the number of times the sprite will move (I''ll refer to this as the sprite''s "moves"). Now we got to figure out how many pixels it will go for each frame. We know that it will move a certain amount 40 times to reach the distance (which is 10 pixels).

So now we got the formula x * 40 = 10. Simple algebra makes the formula x = 10/40 or x = distance / moves. Make the calculations and you get 0.25 pixels the sprite has to move per frame to reach 10 pixels in 2 seconds.

I don''t know how your storing your variables, but lets say you have a struct with the varialbes x and y. Just make your x a float or a double (if your using C/C++) and do "x += distance / (end time/(oldTime - newTime)" for each frame.

Now you have a method that keeps your game moving the same speed on everyone''s computer. And the best part is it doesn''t lock the framerate . So someone with a 2.0ghz Pentium 4 will get 300fps while someone with a 233mhz Pentium 2 will get 30 fps. However, your sprite will still move 10 pixels in 2 seconds on both machines. It''s just that the faster one will be the smoother and the slower one will be choppier. It sure beats slowdown though . Now you know how the proffesionals do it.

If you have any more questions just reply to this thread becuase it''s good to have the information on the message board. That way if anybody else is having the same problem they can search the message board and find this thread.

Frame Rate Independent? Why not Time Independent? Blaah

Whoops. I just realized I didn''t answer your question. Your question is even easier.

Lets say you want to go to the next frame of your animation every 100 miliseconds. Just keep a counter with your sprite that adds up the amount of time that passes between each frame (use the value from "newTime - oldTime"). When the counter is over 100 miliseconds go to the next frame.

here''s how it could look. We''ll assume that sprite is a struct that countains all of it''s info including the counter.

  // declaring the spriteSPRITE sprite;// used to calcualte time between framesint oldTime = 0;// set the sprite to change every 100 milisecondssprite.counterMax = 100;void Animate(int change){   // add to the amount of miliseconds that has passed since the   // last update to the sprite   sprite.counter += change;   // if the time that has passed since the last update is past    // the total time before an update...   while(sprite.counter >= sprite.counterMax)   {      sprite.counter -= sprite.counterMax;      // move to the next frame      sprite.frame++;   }}void InitGame(){   oldTime = GetTickCount();}//--------You main game loop ------------//void MainGame(){   while(1)   {      int newTime = GetTickCount();         int change = newTime - oldTime;      oldTime = newTime;      Animate(change);      DrawSprite();   }}  

So lets say that when the while loop is hit the counter equals 134 miliseconds. First we subtract 100 from the counter which gives us 34 miliseconds. Remeber that we want to update every 100 miliseconds and not every 134 miliseconds. Now we move to the next frame.

The reason why I used a while loop is simple. Lets say that a user has a really slow computer. You want to update every 100 miliseconds. His computer has 215 miliseconds each frame. If it was an if statement, the block of code would run once and then it would exit the function. It would subtract 100 from 215 leaving the counter at 115.

The counter is still above 100 miliseconds which means that the sprite should have moved updated twice between frames. Since it''s a while loop it will see that the counter is still greater than 100 and will update the sprite again.

I hope that wasn''t too confusing. If you don''t understand something just ask me to explain it better.