Decision Statements: "If / Else" Statements and More Functions

Need (library reference):

• World.WorldMin/World.WorldMax   This is described, below - factor this out to the Library reference?

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 if/else construct, which allows a program to decide between two, mutually exclusive options
  2. Change the program so that the ball will bounce off the all edges of the screen
  3. Change the program so that the ball will bounce off the paddles
  4. Change the program so that the ball will bounce off to keep track of whether the player is in novice or expert mode

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 three new features:

1. The ball now bounces off all edges of the screen, so that the ball can never leave the screen

2. The ball now bounces off both paddles

3. The game now keeps track of the total number of times that the ball has bounced off a paddle (either left or right, it doesn't matter which).  Once that total exceeds a certain threshold, then the game changes into Expert mode.  At this point, the only thing that differentiates Novice mode and Expert mode is a message at the bottom of the screen, but we'll add more stuff in later on.

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.  Further, we'll move through the changes feature by feature, staring with the feature that makes the ball bounce off all the edges of the screen.  This will ensure that the ball will never leave the screen.  There are two changes that make this happen.

• UpdateWorld():

  protected override void UpdateWorld() { <code omitted, for clarity>     #endregion     // simple if tests for world bound     CheckWorldBound();     // paddle colliding with the soccer     BounceOffPaddles(); }

  • The first thing you'll notice is that most of the UpdateWorld code from the previous tutorial has been placed inside of a foldable #region, so that we can quickly fold away the code that we're already familiar with, in order to focus on the new material.
  • Here in UpdateWorld, we make a call to a new function, named CheckWorldBound().  This function will actually do the work of figuring out if the ball has gone past the edge of the screen, and turn the ball around.  This function is NOT built into XNA, which is why our next step will be to define it ourselves, in the 'utility functions' region of the program.
• 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;     if (m_TheSoccer.CenterX < World.WorldMin.X)         m_TheSoccer.VelocityX = -m_TheSoccer.VelocityX;     if (m_TheSoccer.CenterY > World.WorldMax.Y)         m_TheSoccer.VelocityY = -m_TheSoccer.VelocityY;     if (m_TheSoccer.CenterY < World.WorldMin.Y)         m_TheSoccer.VelocityY = -m_TheSoccer.VelocityY; }

  • The core logic for this function should be familiar from previous tutorials - each if statement asks "If the center of the soccer ball is bigger/smaller than a particular value, then reverse the direction of the ball's velocity for either the X or Y direction"
  • What's new here is that instead of hard-coding the width of the screen, we will use the built-in variables WorldMax and WorldMin. Both are Vector2 objects, meaning that each one has an X and a Y part.  The WorldMax is a point in the upper-right hand corner of the screen, and WorldMin is the lower-left corner, as shown in the following picture:
    
  • Therefore, if our program asks if (m_TheSoccer.CenterX > World.WorldMax.X), what it's really asking is if the X value of the coordinate of the soccer ball's center is greater than the largest X value on the screen.  In other words, has the soccer ball gone past the right edge of the screen.  If that's true, then execute the code m_TheSoccer.VelocityX = -m_TheSoccer.VelocityX;, which will reverse the ball's horizontal direction.  This will cause the ball to bounce off the right side of the screen.
  • Similarly,
        if (m_TheSoccer.CenterX < World.WorldMin.X)

            m_TheSoccer.VelocityX = -m_TheSoccer.VelocityX;

    asks if the X value of the coordinates of the soccer ball's center is less than the X value of the lower left corner.  In other words, has the soccer ball gone off the left side of the screen.  If so, then execute the code m_TheSoccer.VelocityX = -m_TheSoccer.VelocityX;, which will reverse the ball's horizontal direction.  This will cause the ball to bounce off the left side of the screen.

  •  Identical reasoning is used to bounce the ball off the top & bottom of the screen.
  • Note that using WorldMin and WorldMax instead of numbers (like 100, or 0) have several advantages, all of which strongly resemble the advantages that named constants have over numbers:
    1. We can now replace numbers with a word, which makes the code more readable. 
       Instead of guessing that 100 is the right edge of the screen, we can now read the phrase WorldMax.X, and know that it's intended to be the right edge of the screen.
    2. We use WorldMin/Max multiple places, and know that all the uses will be correct.
       If we wrote "100" for the screen's largest X value everywhere, but then decided to change the width to 10 (say), we'd have to go back & change all the 100's to 10. But ONLY those 100's that represent the screen's largest X value - other 100s we should leave alone. 
       However, if we wrote "WorldMax.X" for the screen's largest X value everywhere, but then decided to change the width to 10 (say), C# will make sure that WorldMax.X is changed to 10 everywhere for us.
    3. Someone else defined WorldMax/WorldMin for us, so that we don't have to
       The best part of all this is that we don't have to even declare any new variables, since this is all built into the XNACS1Lib. :)
  • You'll also notice that XNACS1Lib automatically calculates the Y value of WorldMax for us automatically - since we set the width of the screen to be 100 units, and the lower-left corner to be (0,0), XNACS1Lib automatically calculates WorldMax.Y to be the very exact value of 56.27572 - no more guessing, and no more approximating - we now have an exact value! 

3. Ball Bouncing Off The Paddles:

Let's move on to making the ball bounce of the paddles.  This is an important step towards taking the game towards it's final form.

There are two changes that make this happen:

• UpdateWorld():

  protected override void UpdateWorld() { <code omitted, for clarity>     #endregion     // simple if tests for world bound     CheckWorldBound();     // paddle colliding with the soccer     BounceOffPaddles();     // the if then else     if (m_NumBounces > EXPERT_LEVEL_BOUNCES)         EchoToBottomStatus("EXPERT: bounces=" + m_NumBounces);     else         EchoToBottomStatus("NOVICE: bounces=" + m_NumBounces); }

  • Here in UpdateWorld, we make a call to a new function, named BounceOffPaddles().  This function will actually do the work of figuring out if the ball has collided with either paddle, and if so, it will turn the ball around.  This function is NOT built into XNA, which is why our next step will be to define it ourselves, in the 'utility functions' region of the program.
• BounceOffPaddles()

  /// <summary> /// Test collision between the soccer ball and the two paddles, /// if collide flip ball's velocity X-component, and keep track /// of number of bounces. /// </summary> private void BounceOffPaddles() {     if (m_RightPaddle.Collided(m_TheSoccer))     {         m_TheSoccer.VelocityX = -m_TheSoccer.VelocityX;         PlayACue("Bounce");         m_NumBounces = m_NumBounces + 1;     }     if (m_LeftPaddle.Collided(m_TheSoccer))     {         m_TheSoccer.VelocityX = -m_TheSoccer.VelocityX;         PlayACue("Bounce");         m_NumBounces = m_NumBounces + 1;     } }

  • The core logic for this function should be familiar from previous tutorials - each if statement asks "If the (right/left) paddle has collided with the soccer ball, then reverse the horizontal speed of the ball, and play a sound"
  • For right now, we'll ignore the lines
        m_NumBounces = m_NumBounces + 1;

    These lines aren't tough to understand, but since they're part of the 'count the bounces and go to expert mode' feature, so we'll leave them for later

4. Going To Expert Mode By Counting Bounces

Let's move on to keeping track of how many times the ball has bounced off the paddles, and once the player has bounced the ball at least 5 times, moving the game to expert mode. The basic strategy that we'll use is to create a variable to hold the current number of bounces, which starts at zero.  Each time the ball hits a paddle, we will increase that number by 1. In the UpdateWorld function, we'll check to see if the current number of bounces is above or below the threshold for being in expert mode, and display the appropriate message to the user based on that. Let's go through the changes, one by one:

• Declaring the instance variables

  <code above this point omitted for clarity>     private XNACS1Rectangle m_LeftPaddle;     private XNACS1Rectangle m_RightPaddle;     // collect statistics     private int m_NumBounces;     public Game1()         : base(new Vector2(0.0f, 0.0f), 100.0f) <code below this point omitted for clarity>

  • We want our game to keep track of how many times the ball has bounced off of either paddle.  We will use an instance variable to keep track of this information.
    • We use a variable because the information that we're tracking will change over time.  In contrast, a named constant never changes, and thus can't be used to record the current, changing, number of bounces.
    • We use an instance variable because we need to keep track of this information throughout the entire game, and instance variables will exist throughout the game.  In contrast, a local variable would only exist for the duration of a single function, then disappear, taking the information with it when it ceases to exist.
    • We use an int (an integer) because we only need to keep track of a whole number of bounces.  The ball has bounced (say) either 3 times, or 4 times, but never 3.5 times, or 3.99 times.  An integer is the best type of number to represent this data
    • We mark the instance variable private because we're not planning on sharing this data with other programs.
• 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; }

  • When the game starts, the ball hasn't collided with the paddles at all.  We could also say that the ball has collided with the paddles zero times.  We write exactly that, in C#, in order to initialize the m_NumBounces instance variable.
• Incrementing the bounce count:

  Now that we've got a properly initialized instance variable with which to track the number of bounces, we actually need to increase that value, each time a bounce happens.  Let's return to the BounceOffPaddles() function, and see where that happens:

  private void BounceOffPaddles() {     if (m_RightPaddle.Collided(m_TheSoccer))     {         m_TheSoccer.VelocityX = -m_TheSoccer.VelocityX;         PlayACue("Bounce");        m_NumBounces = m_NumBounces + 1;     }     if (m_LeftPaddle.Collided(m_TheSoccer))     {         m_TheSoccer.VelocityX = -m_TheSoccer.VelocityX;         PlayACue("Bounce");         m_NumBounces = m_NumBounces + 1;     } }

  • Since you've already seen this function (above), everything has been grayed out except for the code that adjusts the number of bounces.
  • You'll notice that the logic for both cases is the same - if the ball has collided with the [ Right or Left ] paddle, then reverse the direction, play a sound, and increase the number of bounces by one.
    • In computer programming, the act of increasing a variable's value by one is often called incrementing. For example, we could have described the logic as "If the ball has collided with the [ Right or Left ] paddle, then reverse the direction, play a sound, and increment the number of bounces"
    • There's even an operator in C# that increments a variable.  If we wanted to, instead of writing
              m_NumBounces = m_NumBounces + 1;

      we could instead write:

              m_NumBounces++;

      In this particular situation, these two different lines of code will produce the exact same effect - the value stored in m_NumBounces will go up by one

• UpdateWorld(), Version #1:

  protected override void UpdateWorld() { <code above this point omitted for clarity>      // paddle colliding with the soccer     BounceOffPaddles();     // the if then else     if (m_NumBounces > 5)         EchoToBottomStatus("EXPERT: bounces=" + m_NumBounces);     else         EchoToBottomStatus("NOVICE: bounces=" + m_NumBounces); }

  • You'll notice that we're using a new feature of the C# language: an if/else condition.  Let's first examine the syntax for the new code that has been added:
        if (m_NumBounces > 5)

            EchoToBottomStatus("EXPERT: bounces=" + m_NumBounces);

        else

            EchoToBottomStatus("NOVICE: bounces=" + m_NumBounces);

    • Firstly, and most importantly, all the rules for writing the 'if' part are still the same.  if must be lowercase, followed by (, followed by something that evaluates to true or false, followed by ), WITHOUT a semi-colon on that line, followed by either a single statement on the next line (like we see above), or else followed by { and } surrounding multiple statements (like we saw in the BounceOffPaddles() function). 
      • This is another example of how we compose more complicated programs out of simpler ones - the else clause adds to the basic if clause, but doesn't change how the basic 'if' logic works.
    • The word else MUST be lowercase.  If you type it correctly, Visual Studio will color-code it blue, to tell you that it recognizes this word as being a keyword in the C# language.
    • The else MUST NOT have any sort of "test" after it.  You'll notice that after the if, there's the test "Is m_NumBounces greater than 5?".  For the else clause, there is no test - we'll see why when we explain how C# executes the if/else, below.
    • Notice that there is NO SEMI-COLON at the end of the line with the else.  Putting a semi-colon at the end will compile, but will NOT do what you want it to!
    • The line beneath the if statement can contain an opening curly brace - {.  If it does, then there will be a matching, closing curly brace - }- a couple of lines down.
      • In this particular example, we do NOT have the curly braces (for either the if, or the else clauses) because we only have a single line of code to execute.  But if we had wanted to, we could have easily written:
            if (m_NumBounces > 5)
           {
                EchoToBottomStatus("EXPERT: bounces=" + m_NumBounces);

           }
            else

           {
                EchoToBottomStatus("NOVICE: bounces=" + m_NumBounces);

           }
        Since we only have a single statement (the EchoToBottomStatus command), it's not required that we put in the curly braces.

      • If you want to include multiple statements for either the if, or the else clause, you MUST use the curly braces.  For example, if we wanted to echo the same message to the bottom and top of the screen, we would have to do the following:
            if (m_NumBounces > 5)
           {
                EchoToBottomStatus("EXPERT: bounces=" + m_NumBounces);

                EchoToTopStatus("EXPERT: bounces=" + m_NumBounces);

           }
            else

           {
                EchoToBottomStatus("NOVICE: bounces=" + m_NumBounces);

                EchoToTopStatus("NOVICE: bounces=" + m_NumBounces);

           }

  • Now, let's examine the semantics of the new code:

    • Conceptually, what's happening is that the program arrives at the line if (m_NumBounces > 5),  and asks "is the value of m_NumBounces greater than five?"  In other words, "Has the ball bounced off the paddles more than five times?"  If that's true, then the program will execute the statement immediately underneath the if clause, just like normal.  In other words, if the ball has bounced off the paddles more than five times, then we'll echo the message to the bottom status bar telling the user that they're in expert mode
      However, if that's not true (i.e., m_NumBounces is five, or less than five), then the program will skip over the statement(s) immediately beneath the if clause, and instead jump to the statement(s) immediately beneath the else clause, and run those statement(s) instead.
      
      We can  represent this code:
      

          // the if then else

          if (m_NumBounces > 5)

              EchoToBottomStatus("EXPERT: bounces=" + m_NumBounces);

          else

              EchoToBottomStatus("NOVICE: bounces=" + m_NumBounces);

      Using this picture:
      

    • One implication of this is that EITHER the if clause (display "EXPERT"), OR the else clause (display "NOVICE") will be executed, BUT NOT BOTH. This means that we will only try to echo one or the other of the messages.

    • Another implication of this is that one of the two clauses MUST be executed.  It is not possible to get to the line with the if, and then somehow skip both the if and the else.  This means that we will echo one of the messages - it's impossible to run this code but not echo anything.

  • One last thing: You'll notice that our if statement asks specifically if the ball has bounced more than five times, using the number five.  If we wanted to change this, we would have to make sure that we correctly change all the right 5s throughout our code.  Let's end this tutorial by making a new, named constant to both clarify our code, and to make it easy to change the number of bounces we need to go to expert mode.
• Declaring the named constant

  We need to declare (to define, really) named constant before we can use it. 

  public class Game1 : XNACS1Base { <code above this point omitted for clarity>          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;     // Bounces for Expert level     private const int EXPERT_LEVEL_BOUNCES = 5;     #endregion

  • Since we can only have a whole number of bounces, we'll use an integer.  We pick a name that's reasonably clear, and declare the constant in the same part of the program as our other constants, and give it the value five.

• UpdateWorld(), Version #2:

  protected override void UpdateWorld() { <code above this point omitted for clarity>      // paddle colliding with the soccer     BounceOffPaddles();     // the if then else     if (m_NumBounces > EXPERT_LEVEL_BOUNCES )         EchoToBottomStatus("EXPERT: bounces=" + m_NumBounces);     else         EchoToBottomStatus("NOVICE: bounces=" + m_NumBounces); }

  • The last thing to do is to replace the number 5 with the named constant, resulting in the above code.

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. Working with WorldMin and WorldMax
   Calculate the width of the screen, given:
   1. WorldMin = (0,0)
      WorldMax = (100,56)
   2. WorldMin = (10,10)
      WorldMax = (100,56)
   3. WorldMin = (-5,-5)
      WorldMax = (20,56)
3. Working with WorldMin and WorldMax; Math Formulas In Programs
   For this exercise, you should use the same project that was explained in the above tutorial.
   What is the formula that you use to calculate the screen's width?  Write up your formula in C#, echo the answer to the top status bar, and check your code against your answers to the previous question by adjusting the values that you use in the constructor.
4. Chained if/else's
   Let's start by examining the following code:

   private void CheckWorldBound() {     if (m_TheSoccer.CenterX > World.WorldMax.X)         m_TheSoccer.VelocityX = -m_TheSoccer.VelocityX;     else if (m_TheSoccer.CenterX < World.WorldMin.X)         m_TheSoccer.VelocityX = -m_TheSoccer.VelocityX;     if (m_TheSoccer.CenterY > World.WorldMax.Y)<         m_TheSoccer.VelocityY = -m_TheSoccer.VelocityY;     if (m_TheSoccer.CenterY < World.WorldMin.Y)         m_TheSoccer.VelocityY = -m_TheSoccer.VelocityY; }

   
   You'll notice that we've added in an extra else, which now connects the first two if statements.  Pictorially, we can represent these four lines with the following chart:
   

   1. First, change the code in your project to match what's given above.  Make sure that it compiles, and that the program continues to behave correctly.
   2. Why does it make sense to chain these first two if statements?  How is this more efficient than having two, separate statements?  Does this clarify the programmer's intentions here?
   3. Make a similar change so that the vertical edges are checked using this sort of approach, too.
   4. Does the following code cause the program to run correctly?  Is it more efficient than the original version?  Is it more clear?

      private void CheckWorldBound() {     if (m_TheSoccer.CenterX > World.WorldMax.X)         m_TheSoccer.VelocityX = -m_TheSoccer.VelocityX;     else if (m_TheSoccer.CenterX < World.WorldMin.X)         m_TheSoccer.VelocityX = -m_TheSoccer.VelocityX;     else if (m_TheSoccer.CenterY > World.WorldMax.Y)         m_TheSoccer.VelocityY = -m_TheSoccer.VelocityY;     else if (m_TheSoccer.CenterY < World.WorldMin.Y)         m_TheSoccer.VelocityY = -m_TheSoccer.VelocityY; }

5. Sequencing:
   Currently, the part of UpdateWorld that checks for the ball bouncing off the paddles, and updating the Novice/Expert message, looks like this:

   // paddle colliding with the soccer     BounceOffPaddles();     // the if then else     if (m_NumBounces > EXPERT_LEVEL_BOUNCES)         EchoToBottomStatus("EXPERT: bounces=" + m_NumBounces);     else         EchoToBottomStatus("NOVICE: bounces=" + m_NumBounces);

   The sequencing (the ordering) is important here because if the player currently has bounced the ball, say, 5 times, and the ball is about to bounce of a paddle, then by FIRST checking for bounces, then NEXT updating the message, we will immediately update the message after detecting the latest bounce.
   What if we change the code to look like this:

   // the if then else     if (m_NumBounces > EXPERT_LEVEL_BOUNCES)         EchoToBottomStatus("EXPERT: bounces=" + m_NumBounces);     else         EchoToBottomStatus("NOVICE: bounces=" + m_NumBounces);     // paddle colliding with the soccer     BounceOffPaddles();

   1. Why does the second sequence appear to work, even though the message at the bottom is being set before figuring out if the ball has collided with a paddle?
   2. The lesson to learn here is that in many cases, you can get things wrong, and yet have things work out ok because of something else in the program.  The most important thing to do is to make sure that you have a clear understanding of why things are happening, so that you can modify your program in the future (if you want) correctly.

	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