Retro Gaming Hacks, Part 3: Add a Ball and Score to Pong

Before genSlope() can generate any random numbers, it must seed the random number generator. If it does not, the first call to rand() will automatically seed the random number generator with 1, which seems OK, except for the fact that you will get the same sequence of "random" numbers every time you start the game. It does not take much thinking about this to see why that would defeat the entire purpose behind randomly generating the slope in the first place. So seed the random number generator we must, and what better to seed it with than the current timestamp? (To answer that question, a few bytes from /dev/random would be better to seed it with, but we will refrain in the interest of portability, as /dev/random does not exist on all systems.) The time() function helpfully returns the current Unix epoch time (which is the number of seconds that have elapsed since January 1, 1970), so you can just feed it directly into the gaping maw of the srand() function, as shown in this excerpt from genSlope():

  // Seed the random number generator with the current Unix timestamp

  srand( time( NULL ) );

Now that the diabolical hunger of the random number generator is sated, you can use it to generate the change-in-y portion of the slope:

  // Generate the change-in-y component of the slope randomly

  slope->dy = 1 + (game->slope_max_dy * rand() / (RAND_MAX + 1.0));

This is a lot more complicated than it should be, as rand() likes to generate numbers between 0 and the C-library-defined macro RAND_MAX, which is typically a large number like 32,767. What you really want is an integer between 1 and the maximum allowable value for dy, so you must divide the value returned by rand() by RAND_MAX plus 1 to get a floating point number between 0 and 1, then multiply that by the aforementioned slope_max_dy, and finally, add 1 to the whole bloody thing. Luckily, computing the change-in-x part of the slope is much easier:

  // The change-in-x component of the slope is

  // whatever is left in the "budget"

  slope->dx = game->ball_speed - slope->dy;

Things should start to become clear now: we want the ball to move six pixels a turn, and we will generate the number of pixels it moves in the y direction randomly, and use the rest for x-centric movement (pun intended, sorry about that). And finally, to make sure the ball does not always move down and to the right from the start, have genSlope() randomly flip the sign on one or both components of the slope:

  // Flip a coin for x and y directions

  if ((int)(2.0 * rand() / (RAND_MAX + 1.0)))

    slope->dx *= -1;

  if ((int)(2.0 * rand() / (RAND_MAX + 1.0)))

    slope->dy *= -1;

(At this point, it becomes obvious that the "slope" is not truly a slope, because in the realm of SDL Pong, a slope of -1/-1 is not the same as a slope of 1/1; that's OK, however.)

Now all you have to do is make sure the genSlope() function gets called at some point. Right after the call to resetSprites(), but before we enter the black hole that is the main loop, would seem a logical choice:

  // Initialise our sprite locations

  resetSprites( &game, 0 );

  

  // Randomly generate the starting slope

  genSlope( &game );



  // Main loop

  while (1) {

At this point, however, you have nothing to show for all of your hard work on slope-related issues, as the ball still does not move.

Adding a call to the moveBall() function right before the delay and the end of the main loop should do the trick:

    // Move the ball

    moveBall( &game );



    // Give the CPU a break

    SDL_Delay( GAME_SPEED );

    

  } // while (main loop)

That is, it should do the trick once you add a function definition to the top of the file:

// Function definitions

int  cleanUp( int err );

void genSlope( GameData *game );

void moveBall( GameData *game );

void movePaddle( GameData *game, int player, int dir );

void resetSprites( GameData *game, int erase );

Prev  [1] [2] [3] [4] [5] [6] Next