Decision Statements: More "If / Else", and Tracking Missed Balls

References:

• Pre-requisite: it is assumed that you have read through the prior tutorials, and are familiar with the concepts covered in those tutorials.

Goals:

• Throughout this chapter, we will work towards a simple game, with each tutorial adding a little bit more to what we've already done.  In this tutorial, we're going to
  1. Add more nested/chained if/else...if statements
  2. When the ball hits the left (or right) edge of the screen, we will consider that to be a 'missed' ball.  The game will track the number of balls which have been missed by the player

1. Obtain the example code

• Here is the zip file to the source files and compiled executable of this example.
• Here is the keyboard mapping for the XBOX 360 controller.  
• Here is the main tutorial page for working with XNACS1Lib, and here is the complete documentation of the library: html-page or compiled html help file.

When the game starts, you'll see a screen that looks similar to this:

The game behaves in a manner that is identical to the what was described for the previous tutorial, with two changes:

1. The game now tracks (and displays) how many times the player missed the ball (and as a result, the ball bounced off the left or right side of the screen).

2. The program now makes use of nested conditional statements to detect whether the ball needs to be bounced off the edge of a screen. As part of this change, we will also play a sound when the ball bounces off an edge of the screen.

Let's examine the source code, change by change

Let's examine the C# source code that produces the behavior we see on-screen.  Since the code is nearly identical to the program that was presented in the previous tutorial, we'll leave out everything, except for code that has changed, or code that is new.  Further, we'll move through the changes feature by feature, staring with the feature that in this version of the game, the ball will now bounce off all the edges of the screen using a nested conditional statement. 

While functionally equivalent to what we had previous done, this version will be slightly more efficient, and will also make it easier for other programmers to understand what our intent was, when we wrote this code

• CheckWorldBound():

  /// <summary> /// Check the center position of the soccer ball, if it is outside /// of the world bound, flip the ball velocity accordingly /// </summary> private void CheckWorldBound() {     if (m_TheSoccer.CenterX > World.WorldMax.X)     {         m_TheSoccer.VelocityX = -m_TheSoccer.VelocityX;         PlayACue("Wall");         m_BallsMissed = m_BallsMissed + 1;     }     else if (m_TheSoccer.CenterX < World.WorldMin.X)     {         m_TheSoccer.VelocityX = -m_TheSoccer.VelocityX;         PlayACue("Wall");         m_BallsMissed = m_BallsMissed + 1;     }     if (m_TheSoccer.CenterY > World.WorldMax.Y)     {         m_TheSoccer.VelocityY = -m_TheSoccer.VelocityY;         PlayACue("Bounce4");     }     else if (m_TheSoccer.CenterY < World.WorldMin.Y)     {         m_TheSoccer.VelocityY = -m_TheSoccer.VelocityY;         PlayACue("Bounce4");     } }

  • The first thing you'll notice is that while there's a lot of new code in CheckWorldBound, the code logic remains the same: If the X value of the coordinates of the soccer's center point is greater than the X value of the right edge of the screen, then reverse the horizontal speed of the ball.  Similarly with the left edge, top edge, and bottom edge.
    • Note that bouncing off the top or bottom edge will play a different sound than bouncing off the left or right edge.
  • You'll notice that for all four edges, we now play a sound when the ball hits the edge.  This means that when the ball hits an edge, the code will now do two things - reverse the direction of the ball, AND play a sound.  Because there are two actions to execute when an  if statement is true, we now need to surround the actions in curly braces.
  • Since the ball can't be both beyond the right edge of the screen, and simultaneously beyond the left edge of the screen, we'll chain/nest the first two statements together.  Similarly, since the ball can't be both above the top of the screen, and simultaneously below the bottom, we'll chain/nest the last  two statements together.  Remember that this is equivalent to:
    
    

    private void CheckWorldBound() {     if (m_TheSoccer.CenterX > World.WorldMax.X)     {         m_TheSoccer.VelocityX = -m_TheSoccer.VelocityX;         PlayACue("Wall");         m_BallsMissed = m_BallsMissed + 1;     }     else     {         if (m_TheSoccer.CenterX < World.WorldMin.X)         {             m_TheSoccer.VelocityX = -m_TheSoccer.VelocityX;             PlayACue("Wall");             m_BallsMissed = m_BallsMissed + 1;         }     }     if (m_TheSoccer.CenterY > World.WorldMax.Y)     {         m_TheSoccer.VelocityY = -m_TheSoccer.VelocityY;         PlayACue("Bounce4");     }     else     {         if (m_TheSoccer.CenterY < World.WorldMin.Y)         {             m_TheSoccer.VelocityY = -m_TheSoccer.VelocityY;             PlayACue("Bounce4");         }     } }

  • The two identical lines that are grayed out, m_BallsMissed = m_BallsMissed + 1;, we will ignore for now, since they're part of the 'tracking missed balls' feature, which we will examine next.

3. Tracking (And Displaying) Missed Balls

Eventually, the game will be set up so that when a player fails to bounce the ball off the paddle, and the ball hits the left/right wall behind the paddle, the ball will be placed back at it's starting position with a new, random velocity, and the count of times that the player has missed a ball will be incremented.  For right now, though, we want to slowly, incrementally work towards this overall goal, by implementing just part of that.  Specifically, we will implement the part that keeps track of the number of times that the player has missed a ball, and display that number to the player.  Since the ball is not allowed to leave the screen, 'missing' the ball will mean that the ball has bounced off the left (or right) edge of the screen.  Overall, the approach we'll use to implement this feature is very similar to what we did to keep track of the number of bounces: we'll declare and initialize an instance variable to store the current number of misses, we'll increment that counter whenever the player misses a ball, and we'll display that number at the bottom of the screen.

• Declaring the instance variables

  <code above this point omitted for clarity>     private XNACS1Rectangle m_LeftPaddle;     private XNACS1Rectangle m_RightPaddle;     // collect statistics     private int m_BallsMissed;     private int m_NumBounces;     private string m_SkillLevel; <code below this point omitted for clarity>

  • We will create an integer instance variable named m_BallsMissed, which will keep track of the number of balls that the player missed.  The player is trying to bounce the balls off the paddles, and so 'missing' a ball means that the ball did not hit the paddle, but instead hit the left or right edge of the screen.
• InitializeWorld():

  protected override void InitializeWorld() {     World.SetWorldCoordinate(new Vector2(0,0), 100.0f);     // initilaize the soccer ball     InitializeSoccer();     // initialize the left and right paddles     m_LeftPaddle = InitializeRectangle(LEFT_PADDLE_X, PADDLE_INIT_Y, PADDLE_WIDTH, PADDLE_HEIGHT);     m_RightPaddle = InitializeRectangle(RIGHT_PADDLE_X, PADDLE_INIT_Y, PADDLE_WIDTH, PADDLE_HEIGHT);     // initialize statistics     m_NumBounces = 0;     m_SkillLevel = "Novice";     m_BallsMissed = 0; }

  • When the game starts, the player has missed zero balls, so we initialize this field appropriately.
    • Just like with the m_NumBounces instance variable, we could have left out the initialization of the m_BallsMissed instance variable & everything would have worked out ok.  However, it's still good practice to initialize the field, in order to be clear about what the starting value should be.
  • As a quick note - while the three separate lines for initializing various statistics aren't huge, it's worth noting that this part of InitializeWorld is starting to get bigger.  One thing to consider is whether we want to move these three lines into a separate function, so that the InitializeWorld can be clearly broken down into "Initialize the soccer ball, initialize the left and right paddles, and initialize the statistics that we keep"
• CheckWorldBound():

  private void CheckWorldBound() {     if (m_TheSoccer.CenterX > World.WorldMax.X)     {         m_TheSoccer.VelocityX = -m_TheSoccer.VelocityX;         PlayACue("Wall");         m_BallsMissed = m_BallsMissed + 1;     }     else if (m_TheSoccer.CenterX < World.WorldMin.X)     {         m_TheSoccer.VelocityX = -m_TheSoccer.VelocityX;         PlayACue("Wall");         m_BallsMissed = m_BallsMissed + 1;     }     if (m_TheSoccer.CenterY > World.WorldMax.Y)     {         m_TheSoccer.VelocityY = -m_TheSoccer.VelocityY;         PlayACue("Bounce4");     }     else if (m_TheSoccer.CenterY < World.WorldMin.Y)     {         m_TheSoccer.VelocityY = -m_TheSoccer.VelocityY;         PlayACue("Bounce4");     } }

  • We need to increment the number of misses whenever a ball hits the left (or right) edge of the screen.  Since the CheckWorldBound is responsible for figuring out if the ball has hit an edge of the screen, we'll add the logic for incrementing m_BallsMissed to it.
    • Notice that we only increment m_BallsMissed if the ball hits the left or right edge of the screen. 
• UpdateWorld():

  <code above this point omitted for clarity>     if (m_NumBounces > EXPERT_LEVEL_BOUNCES)     {         // String equality test         if (m_SkillLevel == "Novice")         {             PlayACue("Victory");             m_TheSoccer.VelocityX = m_TheSoccer.VelocityX + Math.Sign(m_TheSoccer.VelocityX) * BALL_VELOCITY_EXPERT_BOOST_X;             m_TheSoccer.VelocityY = m_TheSoccer.VelocityY + Math.Sign(m_TheSoccer.VelocityY) * BALL_VELOCITY_EXPERT_BOOST_Y;         }         m_SkillLevel = "Expert";     }     EchoToBottomStatus("[" + m_SkillLevel + "]: bounces=" + m_NumBounces + " Balls Missed:" + m_BallsMissed); } // end of UpdateWorld

  • UpdateWorld is almost exactly the same as in the previous tutorial.  The only difference is that we want to tell the user how many times they've missed bouncing the ball off a paddle, which we'll do by adding + " Balls Missed:" + m_BallsMissed to the EchoToBottomStatus command.

FURTHER EXERCISES:: 

1. Start from a blank starter project (1000.201, if you need it), and re-do the code from memory as much as possible.  On your first try, do what you can, and keep the above code open so that when you get stuck, you can quickly look up what you forgot (and that after you finish a line, so that you can compare your line to the 'correct' line).  On the next try, do the same thing, but try to use the finished code less.  Repeat this until you can type everything, without refering the tutorial's code.
   • Repeat this exercise daily for several days, so that you really get the hang of this.  As you go on, periodically review this by re-doing this exercise.
2. Nested Conditional Statements

   For this exercise, you should use the same project that was explained in the above tutorial.
   See if you can change the program so that when the player has bounced the ball off of the paddles 10 times, the message at the top of the screen is changed to "You've Won!".  Next, see if you can set things up (using a nested if statement), so that you only display that message if the ball has bounced at least 10 times, and the number of times the ball was missed is LESS than 5 times.

	This work is supported in part by a grant from Microsoft Research under the Computer Gaming Curriculum in Computer Science RFP, Award Number 15871 and 16531.
2/8/2010