Quote:Original post by Shadowwoelf
1. You need a framestart variable to basically set the program to 0. Since the internal clock starts as soon as the computer does.

If you want to measure time relative to something (such as the start of a frame, or the start of the program itself), then yes, this is important.
Store the time value (e.g. in a variable called framestart) when the program/frame/whatever starts.
framestart = timeGetTime();
Then when you need to get the current time later in your program, you can subtract framestart from it, which will give you the elapsed, or relative time since that event:
elapsedTimeSinceFrameStart = timeGetTime() - framestart;

Quote:Also I was wondering what is the difference between frame time and Fps?

frame time is the length of time elapsed since the last frame. FPS is how many frames can fit into 1 second.
Basically, FPS = 1/frame_time

So if your frame time is ~0.03s then your FPS is ~33

You can, of course, create an empty loop, but that would be inefficient and ugly (correct me if wrong). Instead use sleep().

That's because the GameUpdate and Render that rely on elapsed time (at least in my implementation) are called before next loop iteration, so your calculation for elapsed time would be off if you didn't re-set elapsed time to desired. If you follow the logic you'll see that these functions will always received the elapsed time equal to desired or greater, whereas if we didn't have that statement in if, occasionally they would get elapsed time smaller than desired followed by one greater than desired. In the end the difference wouldn't be too noticable, but this keeps the elapsed time values passed into update more unform instead of oscilating between big and small.

Also, all times are in miliseconds, not seconds. Sleep will be called whenever your elapsed time is smaller than desired time (less than 33 miliseconds), which is impossible to predict when, as it depends on how long your update and render functions take. May be every single loop, may be never.

... no, DWORD is Microsoft type that stands for "double word" which is a 32 bit unsigned integer. There is no data type specicially for miliseconds as miliseconds are just numbers. It's entirely up to you and the rest of your code how you interpret these numbers.

timeGetTime() returns a DWORD value that represents the amount of miliseconds that passed since Windows booted.

read more at: http://msdn.microsoft.com/en-us/library/ms713418.aspx

also, in windows programming (which timeGetTime() is a part of), Microsoft defined custom data types for all the base types (CHAR for char, INT for int, DWORD for a 32 bit unsigned int etc.). This is done because C++ does not guarantee data type sizes, only their minimum (that is, a char is guaranteed to be at least 8 bits, but it may be more on different platforms! ). Hence, custom types are defined to ensure that they are always the same size, regardless of the platform (example: int may be 32bits on one system, but 64 on another, whereas INT will always be 32)

here's a list of all win32 data types: http://msdn.microsoft.com/en-us/library/aa383751(VS.85).aspx


And as for elapsed time - it's just that, elapsed time. It can be used to make your program run at a given speed regardless of frame rate. You can use it to move your untis (unit.position += unit.speed * elapsed_time), you can use it to animate spries (sprite.frame += frames_per_milisecond * elapsed_time), you get the idea.

A lot of people make FPS bound games and measure the game time via FPS (i.e. move a unit 3 pixels every frame or change animation to next frame ever 3 frames). However, I greatily advise to use actual time itself. It's more accurate, it's more flexible, and your in-game time will not slow down if your FPS goes down. That, and you can still put a limit on your FPS using time, so you aren't losing any functionality.