Timing a game, and game design

Time spent planning your game will save you huge amounts time and effort with the programming. Before starting ANY programming plan out your game. Think about what data elements you will need to track, how the user will control the game. What functions and systems will be required to draw the game, and calculate all the game logic. Often you will want to write tools to speed up development of your game, e.g. level editors.

One thing that will greatly simplify game design, and making additions to the game, is to separate the drawing of the screen from the game's logic. By logic I mean any code that moves things, calculates things, times things, or otherwise controls the game.

Testing is an important aspect of any programming project. The best way to test a new function is to plug it into a SMALL test program before adding it to the main program code. Always make test code as simple as possible so that you are testing the new code, not the test stub.

Another concern is to time things so that the game runs at the same speed on computers of different speeds. This is done by using a timer on the PC that runs at the same speed on all PC's. One easy to use timer for DOS games is the BIOS TICK. This is an unsigned long integer that increases by one 18.6 time per second.

// PC bios data area pointer to incrementing unsigned long int
#define TICKS	    (*(volatile unsigned long far *)(0x0040006CL))

In practice this timer is a bit on the slow side to provide smooth animation. The PC also provides a timer that can generate an int8 at programmable intervals. We can then hook an ISR to this interrupt and use it to time all the game events. Many PC music and sound packages also use this interrupt and provide some sort of timing function. Do not change the int8 timer if using a music package that is also using the int8 service.

NOTE: the int8 timer is used to time many DOS and BIOS functions. The old timer interrupt should be called at approximately its original rate of 18.6 times per second.

Installing an int8 timer, and programming it to run at 60Hz

volatile unsigned long fast_tick, slow_tick;
static void interrupt (far *oldtimer)(void);   /* BIOS timer handler */

void deinit_timer(void);


/*

   You don't have to call the old timer, but if you don't
   you have to write some code to cleanup in de-init that
   fixes DOS's internal clock.

   Its also considered 'good form' to call the old int.
   If everyone does, then everything that other TSR's etc...
   may have installed will also work.

   If you skip the little chunk of ASM code- the out 20-
   you WILL LOCKUP all interrupts, and your computer

   Anyways, this test replacement just increments a couple of
   long ints. 
*/
/* ---------------------- new_timer() ------------------- August 23,1994 */
static void interrupt new_timer(void)
{
   asm cli
   fast_tick++;

   if ( !(fast_tick & 3) ) // call old timer ever 4th new tick
      {
      oldtimer();  // not the best way to chain
      slow_tick++;
      }
   else
      {
      // reset PIC
      asm {
          mov al, 20h
          out 20h, al
          } 
      }

   asm sti
}


/* see that 1st line of inline asm?

   to set whatever clock speed you want load
   bx with 1193180/x where x is the clock speed you want in Hz.

*/
/* ---------------------- init_timer() ------------------ August 23,1994 */
void init_timer(void)
{

   slow_tick=fast_tick=0l;
   oldtimer=getvect(8); // save old timer

   asm cli

   // speed up clock
   asm {
      	mov     bx,  19886     //  set the clock speed to 60Hz (1193180/60)
      	mov     al,  00110110b
    	out     43h, al
      	mov     al,  bl
	out     40h, al
    	mov     al,  bh
      	out     40h, al
      }

   setvect(8, new_timer);

   asm sti
}


/* ---------------------- deinit_timer() ---------------- August 23,1994 */
void deinit_timer(void)
{
   asm cli

   // slow down clock   1193180 / 65536 = 18.2, but we use zero

   asm {
      	xor bx,  bx          // min rate 18.2 Hz when set to zero
    	mov al,  00110110b
      	out 43h, al
	mov al,  bl
    	out 40h, al
      	mov al,  bh
	out 40h, al
      }

   setvect(8, oldtimer);  // restore oldtimer

   asm sti

}

Now that we have a timer how is it used to time things? For each element in the game that must be timed we store a number that indicates the NEXT time it should move. This number is set by getting the current time, and adding to it.

Example of timing the movement of a pixel

int x,y;  // pixel location
int dx, dy;  // speed of pixel
unsigned long next_time;
int done=0;
int loop;

x=100;
y=100;

dx=1;
dy=1;

next_time=fast_tick + 3;  // fast tick is incremented by the int8 ISR

while ( !done )
	{
	// if the computer is quick, we may draw the pixel many times without moving.
	if ( fast_tick >= next_time )
		{
		// if the computer is slow, we may have to move the pixel more than once
		// for it to be were it belongs
		loop=fast_tick - next_time;
		
		while ( loop-- )
			{
			x+=dx;
			y+=dy;
			}

		next_time=fast_tick + 3;
		}
	
	put_pixel(x,y, 5);
	update_buffer();
	}

This timing technique causes slow computers to keep up by `skipping' frames (also referred to as `dropping' frames). The animation will not be smooth, but things will move at the correct speed. Usually you should try to aim at your game running at about 60 frames per second on whatever computer is current without skipping frames. 30 frames per second is the minimum for smooth animation.