views:

211

answers:

4

In our school, it is common to build games as class projects in implementing the different concepts we learn from our computer science classes. Now we developed our games in our machine and everything seems to work fine, game speed is normal and so on. Now, when we try testing our games in our school's computer, or when our professor test our games in his own computer, let's say his computer is much powerful compare to the unit where we developed our games, the speed of the game changes dramatically... in most cases the game animation would happen so fast than expected. So my question, how do you prevent this kind of problem in game applications? And yeah, we use Java. We usually use passive rendering as the rendering technique in most applications that we built. tnx in advance!

A: 

The best way to achieve portability would be to issue some Thread.sleep() commands with the same delay between drawing of each frame. Then the results would be consistent accross every system. Since you are using passive rendering, i.e. drawing your animation directly in paint, calling Thread.sleep() from there may not be the best idea...

Maybe you could just update ceratin variables your animation depends on every couple of milliseconds?

pajton
+6  A: 

You shouldn't rely on the speed of rendering for your game logic. Instead, keep track of the time spent since the last logical step in the game to the current one. Then if the time spent has exceeded a certain amount, you execute a game step (in rare cases, where the computer is so slow that two steps should have happened, you may want to come up with a smart solution for making sure the game doesn't lag behind).

This way, game logic is separate from rendering logic, and you don't have to worry about the game changing speeds depending on whether vertical sync is on or off, or if the computer is slower or faster than yours.

Some pseudo-code:

// now() would be whatever function you use to get the current time (in
// microseconds or milliseconds).
int lastStep = now();
// This would be your main loop.
while (true) {
    int curTime = now();

    // Calculate the time spent since last step.
    int timeSinceLast = curTime - lastStep;

    // Skip logic if no game step is to occur.
    if (timeSinceLast < TIME_PER_STEP) continue;

    // We can't assume that the loop always hits the exact moment when the step
    // should occur. Most likely, it has spent slightly more time, and here we
    // correct that so that the game doesn't shift out of sync.
    // NOTE: You may want to make sure that + is the correct operator here.
    //       I tend to get it wrong when writing from the top of my head :)
    lastStep = curTime + timeSinceLast % TIME_PER_STEP;

    // Move your game forward one step.

}
Blixt
ok, so i have to actively/manually render the next game state after some fixed amount of time. ok tnx...
ultrajohn
No, not necessarily. You update after a fixed amount of time, but you render whenever you need to. See also the link in my answer.
Kylotan
yeah, that's what i mean... i just used the wrong words... sorry, so render game graphics and so on, but updating game graphics based on the current game state should be done after a fixed amount of time.. ok tnx guys!
ultrajohn
A: 

You can also use javax.swing.Timer to govern the animation rate. There's a trivial example in this answer.

trashgod
+2  A: 

You may find this article interesting: Fix Your Timestep.

Kylotan