Game is freezing and not working properly

[Jsn]

Hi!

I’ve made a first little java applet game (not my first game ever though). It’s an simple “Monty on the run”-styled plattform game. The player is supposed to collect discs and avoiding angry monsters. The game has no level scrolling and every level is one screen only.

Logically the game is working just fine, but the game has got some irritating performance issues. The game is running a bit jerky and on computers with Windows Vista the speed is not constant (sometimes it’s running faster and sometimes slower).

The game is also freezing for short periods now and then. The game started freezing for even longer periods when I included sound in the game, which I feel is a bit strange since all sound is handled by java.applet.AudioClip. I do not instantiate new audioclips every time they are played. All audioclips used in the game are loaded when the game is starting and stored in a special object.

I am using double buffering and active rendering for my animation. My main loop is looking like this:

long lastSleep = System.nanoTime();
		long sleepTime;
		
		while (true) {
			
			if (state == State.RUNNING) {
				sven.move(); // Moving the player sprite
				checkControls(); // Check keyboard controls
				collisions(); // Checking if the player is colliding the enemies
	
				levelElementCollision(); // Checking if the player is colliding with level elements such as walls.
			}		
		
			if (state == State.RUNNING || state == State.GAMEOVER) {	
				animateDiscs(); // Animate all the discs the player should collect
				handleEnemies(); // Performing enemy "AI" and moving enemies
			}
			
			paintScreen(); // Painting active to the screen
			
			sleepTime = 16000000 - (System.nanoTime() - lastSleep);		
			lastSleep = System.nanoTime();
			
			if (sleepTime > 0) {		
				try {
					Thread.sleep(sleepTime/1000000L);
				} catch (InterruptedException ex) {}
			}
		}

I really do not know what I am doing wrong ???. I’m not instantiating any objects at all during a level and is doing a “System.gc()”-call after each level. I’ve checked the applet with Eclipses profiler and saw that my game was instantiating a LOT of char[] and int[]. I am not instantiating a single one however, so this must be some sort of system operation? Is this normal, or is it a result of me doing something terribly wrong? ???

I am having around 8-10 sprites on screen at once. All level graphics (walls, floor etc.) are drawn to the background at the start of a new level.

I know that some things in the game are not perfectly optimized, for example the collision detection and the paint method (including a lot of list iterations). However, even if I bybass the collision, or most of the paint-method, the game is still running jerky and freezy at the same level as before. :-\

I really want my game to work, but do not know what to do. What could cause these problems? You are my only hope!

[skyuzo]

Not sure, but maybe it’s the Thread.sleep() and division problems…

[Jsn]

Yes, maybe… But how can I get rid off rounding errors? Or is there a way I can handle this without division?

Using System.NanoTime() is my only choice since System.getTimeMillis() is VERY inaccurate and makes the game run 10 times worse.

[fletchergames]

It sounds like you’re oversleeping some of the time. Try changing Thread.sleep to Thread.yield. Then add code something like the following:

if(currentPhaseTime - lastPhaseTime >= timePerPhase) {
   //do the moving, animating, etc.
   ....

   lastPhaseTime = currentPhaseTime;
}

I expect that the following will happen:

1. Your game won’t be anywhere near as jerky.
2. Your game will consume all available CPU cycles.

If this is what happens, you’re oversleeping.

Here is an excerpt from my own main loop code:

//verify that the loop will continue
	shouldContinueLoop = true;
	
	//This variable is used to only skip yielding a certain number of times in a row.
	byte numDelays = 0;
	
	//This variable stores how much time the loop overslept by in the last cycle.
	//Negative values probably won't occur because Thread.sleep shouldn't undersleep.
	long overSleepTime = 0L;
	
	//This variable is used for computing the length of an update phase.
	long lastUpdatePhase = Time.currentTimeMillis();

	while(shouldContinueLoop) {
		//if the application isn't visible, sleep for half a second
		if(!isApplicationActive()) {
			try {
				Thread.sleep(500);
			} catch(InterruptedException exception) {}
				
			continue;
		} //end if the frame isn't visible
		
		//figure out the start of the current phase
		long currentCycle = Time.currentTimeMillis();
		long updatePhaseLength = currentCycle - lastUpdatePhase;
		if(updatePhaseLength > period)
			updatePhaseLength = period;
		
		//update the current model
		doUpdatePhase(updatePhaseLength);
		lastUpdatePhase = Time.currentTimeMillis();
	
		//render the game
		render();
	
		//figure out how long the cycle took
		long timeAfterCycle = Time.currentTimeMillis();
		long cycleLength = timeAfterCycle - currentCycle;
		long sleepTime = period - cycleLength - overSleepTime;
		
		//if some time is left in this cycle
		if(sleepTime > 0) {
			//sleep
			try {
				Thread.sleep(sleepTime);
			} catch(InterruptedException exception) {}
				
			overSleepTime = Time.currentTimeMillis() - timeAfterCycle - sleepTime;
		} //end if some time is left in this cycle
		//else no time is left in this cycle
		else {
			overSleepTime = 0L;

			//don't sleep, but yield if absolutely necessary
			numDelays++;
			if(numDelays >= maximumDelaysPerYield) {
				//yield to let other threads execute
				Thread.yield();
				numDelays = 0;
			} //end if there have been too many delays
		} //end else no time is left in this cycle
	} //end while forever

This code is practically copied out of Killer Game Programming in Java. Mine is a little different, and there’s some stuff I left out because it isn’t relevant.

You need to watch for sleeping too long. I think it’s clear how this is done from the code. That should fix your problem, but you should change it so that rendering and updating are independent of eachother.

My doUpdatePhase method does all the animation and so forth. This method uses something like the if statement I told you to add earlier. The only difference is that I accumulate the elapsed time rather than comparing the current time to the old time. I do this way in case the game is minimized and then returned to. This prevents having an extra phase happen right away.

My render method isn’t limited in that way. The screen is rendered as often as possible except for the sleep time that allows other Threads and Processes to run.

The idea is to do the following:

1. Update animations, movement, etc. a set number of times per second
2. Sleep a fair amount of the time so that other Threads and Processes can run
3. Render as often as possible without screwing up 1 or 2

Also, I always use milliseconds instead of nanoseconds because the nanosecond timer isn’t particularly reliable on computers with power saving settings (which is practically all of them) as well as some older dual core AMD CPUS.

The millisecond timer has bad granularity on Windows, but it seems like it’s good enough.

[Jsn]

Thanks for your help fletchergames! ;D

I implemented your ideas in my code and the game is now running much more constant (no speed roller coaster like before). The performance is not perfect however, so I guess I have so optimize some parts of the game. However, thanks for your help!

[Jesja]

fletchergames, wouldnt it be a good idea to encapsulate the timing things in some sort of timer class. As it is now a lot of local variables are floating around and its not very obious what they are doing, espacially if you what to do more things in the mail loop. And a timer class would be easier to reuse too.