Decision Statements: Case 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 Case construct, which allows a program to decide between many mutually exclusive options
  2. Continue to improve the game by placing the ball back at it's starting location when the player misses it
  3. Continue to improve the game by tracking the number of bounces since the last time the ball was missed

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 a couple of new features:

1. The code has been re-factored, so that CheckForWorldBound now uses a case statement.
2. When the player misses the ball, and the ball hits the left or right side of the screen, then the ball is moved back to the ball's original starting point, given a new, random velocity, and the player gets to try bouncing the ball again.
3. The game now tracks the number of times that the ball has bounced off a paddle, since the last time the player missed the ball and the ball bounced off the left or right wall.  The game now also tracks the largest number of times that the ball's been bounced off of the paddles without being missed.  This is displayed to the user as "MaxBounces:" at the bottom of the screen.  Further, moving from Novice to Expert mode now depends on this maximum number of bounces non-missed bounces, rather than the current number of bounces.

Let's examine the source code, feature by feature

• 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() {     XNACS1Lib.BoundCollideStatus status = CollideWorldBound(m_TheSoccer);     switch (status)     {         case BoundCollideStatus.CollideTop:         case BoundCollideStatus.CollideBottom:             m_TheSoccer.VelocityY = -m_TheSoccer.VelocityY;             PlayACue("Wall");             break;         case BoundCollideStatus.CollideRight:         case BoundCollideStatus.CollideLeft:             m_TheSoccer.Center = new Vector2(BALL_INIT_X, BALL_INIT_Y);             m_TheSoccer.VelocityX = XNACS1Base.RandomFloat(BALL_VELOCITY_MIN_X, BALL_VELOCITY_MAX_X);             m_TheSoccer.VelocityY = XNACS1Base.RandomFloat(BALL_VELOCITY_MIN_Y, BALL_VELOCITY_MAX_Y);             m_BallsMissed++;             m_NumBounces = 0;             PlayACue("BallDie");             break;         case BoundCollideStatus.InsideBound:             break;     } }

• You'll notice that the first line in the function,
      XNACS1Lib.BoundCollideStatus status = CollideWorldBound(m_TheSoccer);

  calls the function CollideWorldBound(m_TheSoccer), which determines if the argument/parameter is currently overlapping the bounds of the world.  In other words, is the soccer ball overlapping the edges of the screen?  You'll notice that there are a limited number of possible responses, which is why the CollideWorldBound function uses the BoundCollideStatus enum to report it's results.  Here's how to interpret the value returned from CollideWorldBound:

  • BoundCollideStatus.CollideTop
    If this value is returned, then the object we've passed in as an argument is at (or above) the top edge of the screen.
  • BoundCollideStatus.CollideBottom
    If this value is returned, then the object we've passed in as an argument is at (or below) the bottom edge of the screen.
  • BoundCollideStatus.CollideRight
    If this value is returned, then the object we've passed in as an argument is at (or beyond) the right edge of the screen.
  • BoundCollideStatus.CollideLeft
    If this value is returned, then the object we've passed in as an argument is at (or below) the left edge of the screen.
• Since enums are represented in memory using an underlying integer type, we can use the switch statement to figure out how to respond to the value returned from the call to the CollideWorldBound() function.  The switch statement is often referred to as a 'case statement'
• Let's first examine a simplified example of the syntax for the new code that has been added:
  

      switch (status)

      {

          case BoundCollideStatus.CollideTop:

          case BoundCollideStatus.CollideBottom:

              //POINT #1

              break;

  
  

          case BoundCollideStatus.CollideRight:

          case BoundCollideStatus.CollideLeft:

              //POINT #2

              break;

          case BoundCollideStatus.InsideBound:

              //POINT #3

              break;

      }

  • The statement starts with the word switch, which 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 switch MUST be followed by the open parenthesis - (.  You can optionally choose to put blank spaces between the switch  and the ( , or you can put them right next to each other - that choice is yours.
  • The opening parenthesis must have a matching, closing ).  The closing parenthesis does not have to be on the same line, but for something as short as what we've written above, there's no reason to put it on any further down.
  • Notice that there is NO SEMI-COLON at the end of the line.  Putting a semi-colon at the end will not compile.
  • The line beneath the switch contains an opening curly brace - {.  There's a matching, closing curly brace - }- several of lines down. 
    • These curly braces are REQUIRED.  Unlike the if, and if/else statements, you MUST put in both the opening and closing curly brace.
  • The code below that is divided up into a sequence of cases.  For example:
            case BoundCollideStatus.InsideBound:

                //POINT #3

                break;

    • The word case is followed by a valid value, given the type of the data that was on the line with the switch.  In this case, since status is a BoundCollideStatus, therefore the values after the case must be BoundCollideStatuss, as well.
    • After the value, there is a colon ( : )
    • At "POINT #3", there can be as many individual statements as you want.  As you'll see below, it is NOT required that you put in more curly braces in order to group up the multiple statements.
    • Each and every case must be ended with a break; statement.  C# will nicely give you a compiler error if you forget it.
• Now, let's examine the semantics of the new code:

  • Conceptually, what's happening is that the program at the 'switch' line, the program asks "What is the current value of the variable status?", and then the program jumps directly the case that has that value.  Here is a pictorial representation:
    
    

  • You'll notice that each of the cases are mutually exclusive - if the current value of status is BoundCollideStatus.InsideBound, then the program will jump to the third case, and do nothing, after which it will continue on to the rest of the program.  In C#, one cannot execute multiple cases - the program executes exactly one case, then proceeds onwards to the rest of the program.

  • You'll notice that while you can't execute multiple, separate cases, you can have a case that's triggered my any one of several values.  For example, if the ball has bounced off the top or bottom of the screen, then we want to do the same thing: reverse the Y axis velocity, play the "Wall" sound, and then continue.  We can express this by writing listing out multiple cases, like so:
            case BoundCollideStatus.CollideTop:

            case BoundCollideStatus.CollideBottom:

                m_TheSoccer.VelocityY = -m_TheSoccer.VelocityY;

                PlayACue("Wall");

                break;

    • You can list as many values as you want to, but they must all be listed individually (using the case <value>: format)

  • We'll leave a detailed explanation of the CollideRight and CollideLeft cases for the next section.

3. Putting The Ball Back In The Middle When The Player Misses

• 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() {     XNACS1Lib.BoundCollideStatus status = CollideWorldBound(m_TheSoccer);     switch (status)     {         case BoundCollideStatus.CollideTop:         case BoundCollideStatus.CollideBottom:             m_TheSoccer.VelocityY = -m_TheSoccer.VelocityY;             PlayACue("Wall");             break;         case BoundCollideStatus.CollideRight:         case BoundCollideStatus.CollideLeft:             m_TheSoccer.Center = new Vector2(BALL_INIT_X, BALL_INIT_Y);             m_TheSoccer.VelocityX = XNACS1Base.RandomFloat(BALL_VELOCITY_MIN_X, BALL_VELOCITY_MAX_X);             m_TheSoccer.VelocityY = XNACS1Base.RandomFloat(BALL_VELOCITY_MIN_Y, BALL_VELOCITY_MAX_Y);             if (m_MaxBounces > EXPERT_LEVEL_BOUNCES)             {                 m_TheSoccer.VelocityX = m_TheSoccer.VelocityX + BALL_VELOCITY_EXPERT_BOOST_X;                 m_TheSoccer.VelocityY = m_TheSoccer.VelocityY + BALL_VELOCITY_EXPERT_BOOST_Y;             }             m_BallsMissed++;             m_NumBounces = 0;             PlayACue("BallDie");             break;         case BoundCollideStatus.InsideBound:             break;     } }

• When the player misses the ball, instead of bouncing the ball with a paddle the ball hits the left or right edge of the screen, the ball will be 'restarted'.  We detect this situation by executing code in response to the ball hitting the left or right wall in the CheckWorldBound function's switch/case statement:
          case BoundCollideStatus.CollideRight:

          case BoundCollideStatus.CollideLeft:

• When this case is executed, the ball will be moved back to the middle of the screen:
              m_TheSoccer.Center = new Vector2(BALL_INIT_X, BALL_INIT_Y);
  and given a new velocity:
              m_TheSoccer.VelocityX = XNACS1Base.RandomFloat(BALL_VELOCITY_MIN_X, BALL_VELOCITY_MAX_X);

              m_TheSoccer.VelocityY = XNACS1Base.RandomFloat(BALL_VELOCITY_MIN_Y, BALL_VELOCITY_MAX_Y);

• If the game is in expert mode, then we need to remember to re-apply the 'expert mode speed boost' to the new velocity:
              if (m_MaxBounces > EXPERT_LEVEL_BOUNCES)

              {

                  m_TheSoccer.VelocityX = m_TheSoccer.VelocityX + BALL_VELOCITY_EXPERT_BOOST_X;

                  m_TheSoccer.VelocityY = m_TheSoccer.VelocityY + BALL_VELOCITY_EXPERT_BOOST_Y;

              }

• Regardless, we will continue to increment the 'number of balls missed counter':
              m_BallsMissed++;

  and we will play a sound to provide audio feedback to the player that the ball was missed
              PlayACue("BallDie");

• You'll notice that we also reset the current number of bounces (not the maximum number of bounces). 
              m_NumBounces = 0;
  Let's examine how this variable is used in the next section of this tutorial.

4. Tracking the Maximum Number Of Bounces

Let's examine this new distinction between 'current' and 'maximum' number of bounces.  In a nutshell, the instance variable m_NumBounces tracks the number of times that the ball has bounced off either paddle since the last time the ball was missed.  m_MaxBounces tracks the highest number of bounces in row that the player has ever reached.  m_MaxBounces is used to determine if the game is in Novice or Expert mode, and m_NumBounces is used to determine if m_MaxBounces has increased.

• Declaring the instance variables

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

  • We will create an integer instance variable, named m_MaxBounces, in which to store the maximum number of times the player bounced the ball off the paddles in a row WITHOUT letting the ball hit either the left or right wall.
• InitializeStats():

  /// <summary> /// Initialize the statistics information /// </summary> private void InitializeStats() {     m_BallsMissed = 0;     m_NumBounces = 0;     m_MaxBounces = 0;     m_SkillLevel = "Novice"; }

  • Since the maximum number of bounces starts out being zero, we will initialize it in the InitializeStats method that we already have.
• 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() {     XNACS1Lib.BoundCollideStatus status = CollideWorldBound(m_TheSoccer);     switch (status)     {         case BoundCollideStatus.CollideTop:         case BoundCollideStatus.CollideBottom:             m_TheSoccer.VelocityY = -m_TheSoccer.VelocityY;             PlayACue("Wall");             break;         case BoundCollideStatus.CollideRight:         case BoundCollideStatus.CollideLeft:             m_TheSoccer.Center = new Vector2(BALL_INIT_X, BALL_INIT_Y);             m_TheSoccer.VelocityX = XNACS1Base.RandomFloat(BALL_VELOCITY_MIN_X, BALL_VELOCITY_MAX_X);             m_TheSoccer.VelocityY = XNACS1Base.RandomFloat(BALL_VELOCITY_MIN_Y, BALL_VELOCITY_MAX_Y);             if (m_MaxBounces > EXPERT_LEVEL_BOUNCES)             {                 m_TheSoccer.VelocityX = m_TheSoccer.VelocityX + BALL_VELOCITY_EXPERT_BOOST_X;                 m_TheSoccer.VelocityY = m_TheSoccer.VelocityY + BALL_VELOCITY_EXPERT_BOOST_Y;             }             m_BallsMissed++;             m_NumBounces = 0;             PlayACue("BallDie");             break;         case BoundCollideStatus.InsideBound:             break;     } }

  • Since the m_NumBounces variable now tracks the number of bounces since the ball last hit the left or right wall, we need to remember to reset the variable to zero, when the ball does hit the left/right wall.  This is done using the line m_NumBounces, in the CheckWorldBound() function, above
• UpdateWorld():
  

  <code above this point omitted for clarity>     // paddle colliding with the soccer     BounceOffPaddles();     if (m_NumBounces > m_MaxBounces)         m_MaxBounces = m_NumBounces;     if (m_MaxBounces > 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 + "] " +             "CurrentBounces:" + m_NumBounces +             " MaxBounces:" + m_MaxBounces +             " Total Balls Missed:" + m_BallsMissed); } // end of UpdateWorld

• There's only a couple things that need to be changed here.
• First, we need to update the maximum number of non-missed bounces.  Since the m_NumBounces variable is set back to zero each time the ball hits the left/right wall, it's possible that we could get up to, say, 10 bounces (which is also our maximum), then hit the left wall (bringing the m_NumBounces variable back to zero), and then not update the m_MaxBounces variable for a while.  We do this using the code
      if (m_NumBounces > m_MaxBounces)

          m_MaxBounces = m_NumBounces;

  
  

  Which says to update m_MaxBounces if (and only if) m_NumBounces is higher than the previous maximum, no matter when it occurred.

• The next change is:
      if (m_MaxBounces > EXPERT_LEVEL_BOUNCES)

  Since being in Novice or Expert mode is dependent on the maximum number of non-wall bounces, not the current number, we need to change this if statement accordingly.  The nested if statement (which figures out if this is the first time we've advanced to Expert mode) remains valid, and therefore unchanged.

• Lastly, we need to tell the player what the maximum number of bounces is, so we'll need to update the EchoToBottomStatus command, like so:
      EchoToBottomStatus("[" + m_SkillLevel + "] " +

              "CurrentBounces:" + m_NumBounces +

              " MaxBounces:" + m_MaxBounces +

              " Total Balls Missed:" + m_BallsMissed);

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. Case Statements (C# switch statements)

   For this exercise, you should use the same project that was explained in the above tutorial.
   Examine the BounceOffBlocks routine.  First, without trying to compile such a solution, answer the following question: Does it make sense to refactor this code using a Case structure (i.e., using a C# switch statement?)?  Why, or why not?

3. Case Statements (C# switch statements)

   For this exercise, you should use the same project that was explained in the above tutorial.
   Let's say that you want to add a couple of levels to the game, so that instead of just "Novice", and "Expert", there are the following levels:
   

   
   

   Number of Uninterrupted Bounces	Level Name
   0 - 5	Novice
   6 - 10	Expert
   11-15	Super Expert
   16 - 20	Ultra Super Expert
   21+	Mega Ultra Super Expert

   
   Refactor the code in the UpdateWorld method so that as the player reaches the appropriate number of (uninterrupted) paddle bounces, each of the above levels are displayed in bottom status bar, using a Case statement.

   
   

	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