Decision Statements: Logical AND Operator

Need (library reference):

• background texture and color
• RemoveFromDrawSet() before delte

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. Track if the player has won the game, and if so, switch to the "You've Won" screen.
  2. Examine the very important logical AND operator, which allows a program to decide to do something only if multiple checks are all true

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. It is possible to 'win' the game.  The player can win the game by bouncing the ball of the paddles more than BOUNCES_NEEDED_TO_WIN times (in a row, without missing it), and missing the ball less than MAX_BALLS_MISSED_TO_WIN times.  However, once the player has bounced the ball BOUNCES_NEEDED_TO_WIN times (in a row, without missing it), then further bounces will decrease the number of misses, until the player wins.

2. When the player wins, the game displays a "You've Won!" screen, which looks like:
   
   Once the player has won, the game stops updating (i.e., the ball & paddles stop moving), and almost all user input is disabled.

3. At any time (before, or after winning), the player may press the 'A' button, and restart the game

Let's examine the source code, feature by feature

2. Winning the game

• 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;     private bool m_YouHaveWon; <code below this point omitted for clarity>

  • We will declare a new instance variable to keep track of whether the player has won or not.  Since the player has either won or not won (there is no 'half-won'), we will use a boolean variable (represented by the bool data type in C#)
    • If has m_YouHaveWon the value false, then the player has not (yet) won.  One way to read is "false" means that YouHaveNotWon.
    • If has m_YouHaveWon the value true, then the player has won the game.  One way to read is "true" means that YouHaveWon.
    • While it's not strictly necessary to do this (it's possible to use a string, like we did for the game's mode, or an integer), using a Boolean will make our code substantially easier to understand and maintain. 
• InitializeStats():

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

  • When the game begins, or when the game is restarted, the player has not yet won.  Therefore, we should initialize m_YouHaveWon by assigning false to it.
• Declaring the named constants

  <code above this point omitted for clarity>     // Bounces for Expert level     private const int EXPERT_LEVEL_BOUNCES = 5;     private const int BOUNCES_NEEDED_TO_WIN = 10;     private const int MAX_BALLS_MISSED_TO_WIN = 2;         #endregion <code below this point omitted for clarity>

  • We defined two new named constants, so that we can easily change the values here, in one place, and know that everywhere else will be updated automatically. 
    • For a game, this is particularly important.  Once we've got the game functioning, we may want to play with these numbers, in order to balance the game between being too hard (and therefore something that would frustrate players) and too easy (and therefore something that would bore players).  The ability to quickly adjust these numbers can be crucial to finding what numbers work well for a fun game.
• UpdateWorld(): Checking if the player has won
  

  <code above this point omitted for clarity>     EchoToBottomStatus("[" + m_SkillLevel + "] " +             "CurrentBounces:" + m_NumBounces +             " MaxBounces:" + m_MaxBounces +             " Total Balls Missed:" + m_BallsMissed);     // Check to see if the player has won     if ((m_NumBounces >= BOUNCES_NEEDED_TO_WIN) && (m_BallsMissed < MAX_BALLS_MISSED_TO_WIN))     {         m_YouHaveWon = true;         BackgroundTexture = "WinImage";     } } // end of UpdateWorld

  • At the very end of the UpdateWorld method, we check to see if the player has won.  We do this by asking if the player has bounced the ball (without missing it) at least BOUNCES_NEEDED_TO_WIN times AND the player has missed fewer than MAX_BALLS_MISSED_TO_WIN balls.

    if ((m_NumBounces >= BOUNCES_NEEDED_TO_WIN) && (m_BallsMissed < MAX_BALLS_MISSED_TO_WIN))

    • Notice the use of the logical AND, which ensure that the player only wins if BOTH criteria are met!!
    • If both criteria are met, then the overall expression evaluates to true, and we execute the two statements inside the curly braces.
      • If the player has won the game, then the first thing that's done is to set m_YouHaveWon to be true.  This way, if we check m_YouHaveWon elsewhere in the code, we'll know that when it's true it's because the player has won the game.
      • Next, we change the background picture.  We can do that by assigning the name of an image to the BackgroundTexture property of the Game1 object.
    • If at least one of the criteria is not met, then the whole expression is is false, and the code inside the curly braces is skipped.  In other words, if the player doesn't have the number of bounces needed to win, the whole expression will be false (and the game will not be won).  If the player has missed too many balls, then the whole expression will be false (and the game will not be won).  If the player has missed too many balls and also doesn't have enough bounces to win, then the whole expression will be false (and the game will not be won). 
• UpdateWorld():
  

  protected override void UpdateWorld() {     if (GamePad.ButtonBackClicked())         this.Exit();     if (GamePad.ButtonAClicked())     {         m_TheSoccer.RemoveFromDrawSet();         InitializeStats();         InitializeSoccer();         BackgroundTexture = "";     }     // The player has won, then don't do anything else     // Don't let the player move the paddles,     // Don't move the ball, etc     if (m_YouHaveWon)     {         return;     }     #region from previous tutorial     // update the left and right paddles with thumbstick

  • Let's start by examining
        // The player has won, then don't do anything else

        // Don't let the player move the paddles,

        // Don't move the ball, etc

        if (m_YouHaveWon)

        {

            return;

        }

    • You'll notice that there are only two things that are checked before this: the "Should we exit the game program?" check that we've always done, and the "Is the A button being pressed?" check that we'll explain below.  The key thing to note here is that we don't do anything else before we get to the code we're examining here - we don't update the position of the soccer ball based on it's velocity, we don't let the player move the paddles up or down, etc.
    • The if (m_YouHaveWon) simply asks "Is the current value of m_YouHaveWon true?"  Since we initialized it to be equal to false, and only set it to be true once the player has won the game, this is the same as asking "Has the player won the game?"
      • If the player has won the game, then the return statement gets executed, meaning that C# will skip the entire rest of this function, and go directly to the Draw step (and after that, back to here, for another Update step)
      • Because of this, if the player has won, then the game will stop updating the ball and paddles, because the game will return from UpdateWorld before any of that gets done.
  • Next up, is the code:
        if (GamePad.ButtonAClicked())

        {

            m_TheSoccer.RemoveFromDrawSet();

            InitializeStats();

            InitializeSoccer();

            BackgroundTexture = "";

        }

    The if statement will evaluate to true if the player has just pushed the 'A' button, meaning that the player wants to restart the game.

    • The GamePad.ButtonAClicked() method is extremely convenient for what we want to do: if the user is holding down the A button, then  GamePad.ButtonAClicked() will return true  the first time that UpdateWorld is called after the button is pushed, and false  until the user releases the A button.  In other words, if the player holds down the A button through multiple UpdateWorld calls, this method will return true only the first time.  This is convenient since UpdateWorld can be run dozens of times a second, meaning that pretty much any time a player even taps the A button, UpdateWorld will run multiple times before the A button can be released.
    • Once we've noticed that the player wants to restart the game, we do the following actions:  First, we take the current soccer ball, and remove it from the set of on-screen objects that we want XNACS1Lib to draw for us:
              m_TheSoccer.RemoveFromDrawSet();

      Next, we reset all the numbers, including the current and maximum number of bounces, and the number of missed balls (which all go back to zero), as well as putting the game back into Novice mode.
              InitializeStats();

      Having done that, we can then create a brand new soccer ball, and pick a new, random velocity for it:

              InitializeSoccer();

      Finally, we want to remove the "You've Won" screen, which we do by setting the BackgroundTexture property to be the empty string:
              BackgroundTexture = "";

• BounceOffPaddles():
  

  private void BounceOffPaddles() {     if (m_RightPaddle.Collided(m_TheSoccer))     {         m_TheSoccer.VelocityX = -m_TheSoccer.VelocityX;         PlayACue("Bounce");         if (m_NumBounces > BOUNCES_NEEDED_TO_WIN && m_BallsMissed >= MAX_BALLS_MISSED_TO_WIN)             m_BallsMissed--;         else             m_NumBounces = m_NumBounces + 1;     }     else if (m_LeftPaddle.Collided(m_TheSoccer))     {         m_TheSoccer.VelocityX = -m_TheSoccer.VelocityX;         PlayACue("Bounce");         if (m_NumBounces > BOUNCES_NEEDED_TO_WIN && m_BallsMissed >= MAX_BALLS_MISSED_TO_WIN)             m_BallsMissed--;         else             m_NumBounces = m_NumBounces + 1;     } }

  • The last thing left to do is to ensure that once the player has enough bounces in a row to win, that further bounces will 'cancel out' missed balls, until the player has enough bounces (and sufficiently few misses) to win the game.  We will do this by 'decorating' the if...else if statement in the  BounceOffPaddles function with nested if/else statements.
  • Once we've figured out that the soccer ball has collided with the right (or left) paddle, then it's just a matter of figuring out whether we should increment (increase by 1) m_NumBounces, or else decrement (decrease by 1) m_BallsMissed.

    There are basically four cases:

    1. The player does NOT have enough bounces, and also does NOT have too many misses.  In this case, we should increment m_NumBounces.
    2. The player does NOT have enough bounces, but DOES have too many misses.  In this case, we should still increment m_NumBounces - we keep incrementing until the player has enough bounces, then worry about misses at that point
    3. The player DOES  have enough bounces, but also does NOT have too many misses.  In this case, we should increment m_NumBounces. Once the program reaches the end of the current UpdateWorld method, the game will notice that the player has won, so this case won't happen more than once.
    4. The player DOES have enough bounces, but DOES have too many misses.  In this case, we should decrement m_BallsMissed.
    • Looking at the above cases, we notice that the only situation we decrement m_BallsMissed is if the player has enough bounces to win, but also has too many misses to win.  In all other cases, we will increment m_NumBounces, instead.
  • Based on the above reasoning, we assemble the following code:
            if (m_NumBounces > BOUNCES_NEEDED_TO_WIN && m_BallsMissed >= MAX_BALLS_MISSED_TO_WIN)

                m_BallsMissed--;

            else

                m_NumBounces = m_NumBounces + 1;

    The if statement asks "Does the player have enough bounces to win AND also have too many misses to win?"  If that's true, then this new bounce 'cancels out' an earlier miss (by decrementing m_BallsMissed).  In the other three cases, we simply increment m_NumBounces (which is handled for us by the else clause)

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.

• Resetting The Game: New Block Layout
  For this exercise, you should use the same project that was explained in the above tutorial.

  You should create a method that will create all the blocks in the game, similar to the way in which you have a method which initializes the soccer ball.  Make sure that this method can be used not only to initialize the game, but also to reset the positions of the blocks when the game is restarted.  Once this is done, pushing the 'A' button should not only reset all the numbers, but should also create a new bunch of blocks on the screen (in new locations)

• Using the logical AND
  For this exercise, you should use the same project that was explained in the above tutorial.
  Modify the program so that the player is allowed to advance to expert mode only if the player has at least EXPERT_LEVEL_BOUNCES, and has no more than 2 missed balls.  Once the player has EXPERT_LEVEL_BOUNCES, any further bounces should decrease the number of previously missed balls.

	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