Decision Statements: Nested If Statements

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. Examine the very important nested if construct, which allows a program to make a more complicated decision.
  2. Make the game play a sound, and increase the speed of the ball, when the player advances from the Novice to the advanced version of the game

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 almost identical to the what was described for the previous tutorial, with one new feature:

1. When the game goes from goes from Novice mode to Expert mode, the game will play a sound, and increase the speed of the ball.

2. Internally (i.e., in a way that the player won't notice), the game will change how it keeps track of whether it's in Novice or Expert mode using an instance variable.

Let's examine the source code, feature by feature.

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. 

Starting with this tutorial (and increasing, as we move onwards), our program will need to know what mode the game is currently in.  So instead of repeatedly asking if (m_NumBounces > EXPERT_LEVEL_BOUNCES), we would instead like to calculate this just once in each UpdateWorld, and store that result into a variable.  That way, we can quickly check that variable, and not have to worry about accidentally miscalculating on subsequent times (for example, accidentally typing if (m_NumBounces < EXPERT_LEVEL_BOUNCES), which compiles, but doesn't do what we want.).

For this tutorial, we will store the mode into an instance variable that is a string.  In computer programming, string is the term used to indicate text.  In a nutshell, we will store the string "Novice" into the variable if the game is in Novice mode (which is how the game starts), and then store the string "Expert" into that variable once the player has bounced the ball enough.

• Declaring the instance variables

  <code above this point omitted for clarity>     // collect statistics     private int m_NumBounces;     private String m_SkillLevel; <code below this point omitted for clarity>

  • We will create a string instance variable, named m_SkillLevel, in which to store the word that describes the current mode of the game. 
    • Instead of declaring the variable to be an int, or a float, we declare it to be a String, meaning that we're going to store text into this variable.
    • Note that in C#, there is a separate, lower-case keyword that we could use instead:
          private string m_SkillLevel;
      As it turns out, the lowercase string is actually an 'alias' for the uppercase String.  Which means that you can use the upper or lower case version of string, and you'll get the exact same results.  This is one of the few times in C# where this happens!
• 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"; }

  • When the game starts, the skill level is "Novice", so we assign the string (the text) "Novice" to the m_SkillLevel variable. 
    • Notice that since the default value of an int (like m_NumBounces) is zero, so therefore we didn't technically have to initialize m_NumBounces  here.  However, we MUST initialize the m_SkillLevel variable to hold the (non-default) value of "Novice".
• UpdateWorld(), Version #1:

  <code above this point omitted for clarity>     // paddle colliding with the soccer     BounceOffPaddles();     if (m_NumBounces > EXPERT_LEVEL_BOUNCES)     {         // String equality test         if (m_SkillLevel == "Novice")             PlayACue("Victory");         m_SkillLevel = "Expert";     }     EchoToBottomStatus("[" + m_SkillLevel + "]: bounces=" + m_NumBounces); } // end of UpdateWorld

  • Comparing this version to the previous tutorial's version, we notice that the if/else has been replaced by the if statement above.  The basic strategy will be to set the m_SkillLevel variable to either "Novice" or "Expert", and then to concatenate that variable to other strings, in order to generate the final message that we echo to the bottom status bar.
  • You'll notice that the first line remains the same
        if (m_NumBounces > EXPERT_LEVEL_BOUNCES)

    Since m_SkillLevel variable is initialized to "Novice", we only need to change it if the player has gotten enough bounces to advance to Expert mode.  This if statement will ensure that we skip all the code  inside the curly braces if the player has bounced the ball (off the paddles) less than EXPERT_LEVEL_BOUNCES times.

    • If this conditional statement evaluates to false (maybe the player has just started, so m_NumBounces  is 0), then the program skips the next block (everything between { and } ), and then goes straight to the EchoToBottomStatus line, where it glues "[" to "Novice" to "]: bounces=" to (say) 0, and then prints out "[Novice]: bounces=0" (for example)
  • If the number of bounces is greater than EXPERT_LEVEL_BOUNCES, then following code will be run:
        {

            // String equality test

            if (m_SkillLevel == "Novice")

                PlayACue("Victory");

            m_SkillLevel = "Expert";

        }

    • Notice that the first thing inside the if statement is another if statement.  This inner "if" is said to be nested inside the outer if statement.  Continuing the pattern of composing new, more complex programs out of stuff we already know how to do, we will execute the if statement in the exact same way that we always do.
              if (m_SkillLevel == "Novice")

                  PlayACue("Victory");

      We do this by asking 'Is the value referred to by the m_SkillLevel variable the same as the string "Novice"?', and if so, then we play the sound named "Victory".  If the value referred to by the m_SkillLevel variable NOT the same, then we'll skip playing the sound.

    • How does this actually play out when the program is running?  They key is the next line:
          m_SkillLevel = "Expert";
      This will replace the current value of m_SkillLevel with a reference to the string "Expert".  Notice that since the nested if statement isn't followed by curly braces, the only thing that is 'guarded' by the if statement is the PlayACue command.  As a result, the m_SkillLevel = "Expert"; line will ALWAYS be executed (when

      (m_NumBounces > EXPERT_LEVEL_BOUNCES)

       ) , and as such, each and every time that UpdateWorld is called, if the player has bounced the ball more than EXPERT_LEVEL_BOUNCES bounces, then "Expert" will be assigned to m_SkillLevel.

  • Let's see how this code is intended to function by tracing the program briefly.  Let's say that the user has bounced the ball exactly 5 times so far, and therefore the game is still in "Novice" mode.
    
    1. When we first step through this snippet of code, the following variables have the following values:
       

       Variable	Value
       m_NumBounces	5
       m_SkillLevel	"Novice"

       
       When the program gets to the line
          if (m_NumBounces > EXPERT_LEVEL_BOUNCES)
       we see that m_NumBounces has the value of 5, which is exactly equal to, but not greater than EXPERT_LEVEL_BOUNCES. Thus, the if statement evaluates to false, everything inside the curly braces are skipped, and the program next prints out the message "[Novice]: bounces=5" to the bottom status bar.

    2. Let's say that in the next UpdateWorld, the ball collides with a paddle (as a result, the program increments the m_NumBounces variable).  Thus, the following variables have the following values:
       

       Variable	Value
       m_NumBounces	6
       m_SkillLevel	"Novice"

       
       When the program gets to the line
          if (m_NumBounces > EXPERT_LEVEL_BOUNCES)
       we see that m_NumBounces has the value of 6, which is greater than EXPERT_LEVEL_BOUNCES. Thus, the if statement evaluates to true, everything inside the curly braces is executed, starting with:
           if (m_SkillLevel == "Novice")

       As we can see, m_SkillLevel does have the value "Novice", so this also evaluates to true.  As a result, the program proceeds to execute the next line down:
                   PlayACue("Victory");

       This line starts the 'Victory' sound playing, for 1 second.

       Next, the program goes on to execute the line
               m_SkillLevel = "Expert";

       which changes the variables to be:
       

       Variable	Value
       m_NumBounces	6
       m_SkillLevel	"Expert"

       
       having done everything inside the curly braces, the program next prints out the message "[Expert]: bounces=6" to the bottom status bar.

    3. Let's examine what will happen with the very next call to UpdateWorld, which happens (let's say) .05 seconds after the previous one finished.
       First, none of the variables have changed, so their values are still:
       

       Variable	Value
       m_NumBounces	6
       m_SkillLevel	"Expert"

       
       When the program gets to the line
          if (m_NumBounces > EXPERT_LEVEL_BOUNCES)
       we see that m_NumBounces still has the value of 6, which is greater than EXPERT_LEVEL_BOUNCES. Thus, the if statement evaluates to true, everything inside the curly braces is executed, starting with:
           if (m_SkillLevel == "Novice")

       What's different this time around is that m_SkillLevel does NOT have the value "Novice" - it has the value "Novice" -so this evaluates to false.  As a result, the program proceeds to SKIP the next line down, and does NOT play another sound.  This is good, since we told XNA to play the sound for 1 second the last time we were in the UpdateWorld method, and this current call to UpdateWorld is happening only .05 seconds after that previous one. 
       

       Next, the program goes on to execute the line
               m_SkillLevel = "Expert";

       which does do the assignment, even though it doesn't actually change the value stored in the m_SkillLevel variable.

    4. As you can see, the nested if serves to play a sound, but only once - only when the player first switches from Novice to Expert mode.

3. Increasing The Speed Of The Ball In Expert Mode

When the player advances to Expert mode, we want the game to change.  Since the player has done well at the Novice level, we'd like to increase the difficulty of the game, in order to make sure that the game remains challenging and engaging to the player.  We will do this by speeding up the ball when the game switches from Novice to Expert mode.  We will do this by adjusting the starting speed of the ball to be slightly slower, and define a couple of new constants to define how much we will boost the ball's speed by.

• Declaring the named constants

  <code above this point omitted for clarity>     // Ball size, position, and velocity     private const float BALL_INIT_X = 50.0f; // initial ball X and Y positions     private const float BALL_INIT_Y = 25.0f;     private const float BALL_RADIUS = 2.5f;     private const float BALL_VELOCITY_MIN_X = 0.5f;     private const float BALL_VELOCITY_MAX_X = 1.1f;     private const float BALL_VELOCITY_MIN_Y = BALL_VELOCITY_MIN_X / 3.0f;     private const float BALL_VELOCITY_MAX_Y = BALL_VELOCITY_MAX_X / 3.0f;     private const float BALL_VELOCITY_EXPERT_BOOST_X = 0.1f;     private const float BALL_VELOCITY_EXPERT_BOOST_Y = BALL_VELOCITY_EXPERT_BOOST_Y / 3.0f;     // Bounces for Expert level     private const int EXPERT_LEVEL_BOUNCES = 5; <code below this point omitted for clarity>

  • Firstly, note that the minimum and maximum speed (in the X direction) for the soccer ball has been changed slightly, to range between 0.5f  and 1.1f.
    • Since the minimum and maximum speed in the Y direction is calculated based on the value of the constants for the X direction, we don't have to change the formula for the Y direction.
  • We create two new constants: one to define how much to boost the speed in the X direction, and another to define how much to increase the speed in the Y direction:
    

        private const float BALL_VELOCITY_EXPERT_BOOST_X = 0.1f;

        private const float BALL_VELOCITY_EXPERT_BOOST_Y = BALL_VELOCITY_EXPERT_BOOST_Y / 3.0f;

     

• UpdateWorld(), Version #2:
  Now that we've got code that

  <code above this point omitted for clarity>  // paddle colliding with the soccer  BounceOffPaddles();  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); } // end of UpdateWorld

  • Comparing this version to the version, you'll notice that when we're switching from the Novice mode to the Expert mode, we now do several things, and as a result, we need to add in the curly braces:
        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;

       }

  • Next, you'll notice that we adjust the X speed and Y speed (but only once, when we first switch to Expert mode).  Looking at the X speed, we see that the line that does this is
        m_TheSoccer.VelocityX = m_TheSoccer.VelocityX + Math.Sign(m_TheSoccer.VelocityX) * BALL_VELOCITY_EXPERT_BOOST_X;
    Except for the call to the Math.Sign function, you should be able to understand everything else that's here.  So what does the Math.Sign function do?
    By reading the documentation (available at http://msdn.microsoft.com/en-us/library/ywb0xks3.aspx), we can see that we give the Math.Sign function a number, and it will return one of three possible values: 
    • If the value given to it is negative, Math.Sign will give you back the number -1
    • If the value given to it is positive, Math.Sign will give you back the number +1
    • If the value given to it is zero, Math.Sign will give you back the number zero

    This is important here because we want to increase the magnitude of the ball's speed, but the exact speed may be negative, or positive.  In other words, if m_TheSoccer.VelocityX is, say, -.8f, then we want to make the ball go faster in that same direction, by changing m_TheSoccer.VelocityX to -.9f.  However, if we just add BALL_VELOCITY_EXPERT_BOOST_X (which was defined to be 0.1f) to m_TheSoccer.VelocityX (which is -.8f in this example), we'd end up with m_TheSoccer.VelocityX being -.7f, meaning that we just slowed the ball down, instead of speeding it up.  In this case, since Math.Sign(-0.8f) returns -1, then our code will first multiply BALL_VELOCITY_EXPERT_BOOST_X by -1 (which results in -0.1f), and thus add -.1f to the X speed, making it -.9, just like we wanted.

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 referring 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. Practicing Nested If's
   For this exercise, you should use the same project that was explained in the above tutorial.
   Let's say that we want to add another mode to the game - another skill level.  Let's say that after the player has bounced the ball twice as many times as EXPERT_LEVEL_BOUNCES, we want to again play the 'Victory' sound, change the message at the bottom of the screen to "Super Expert", and again increase the speed (by the same amount as the speed was increased when the game changed from Novice to Expert).  You should go through the code, and make all the changes necessary to add this feature.
   • Make sure that your code is efficient - don't add any extra variables, unless you have to.  Adding more constants is fine, since the compiler will translate them into numbers at compile time (i.e., they won't take up any more space in the running program than any other number would)

	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