Decision Statements: Nested Conditionals, and Obstacles for the Game!

Need (library reference):

• Collide again.
• Random function again.

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. See an example of refactoring code
  2. Randomly place some obstacles in the middle of the screen, to make the game more interesting
• We will not be seeing any new programming techniques in this tutorial.

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 several changes:

1. Internally, we've refactored some code so that instead of initializing all the 'statistics' (number of bounces, number of misses, etc) in InitializeWorld, the code will now call a separate function to do that.

2. There are several blocks in the middle of the screen. Each block is labeled with a letter and does not move.  If the soccer ball hits one of these blocks, the ball will bounce off the block, and we'll change the message at the top of the screen to remind the player what the last impacted block is..  The blocks are positioned randomly, so that each game will be a little bit different.

Let's examine the source code, change by change

Let's start with the code refactoring. Code refactoring refers to taking some existing code, and changing it in a way that doesn't change the functionality the code effects, but does change how the code is organized. In this case, we'll take several lines from the InitializeWorld routine, and move those lines into their own function.  On an immediate level, this will improve the readability of the InitializeWorld function, as it will now be clear that those lines initialize the 'statistics' of the game (i.e., the number of times the ball has bounced off a paddle, the number of times the ball was missed, etc).  On a longer-term level, having a function that sets all the statistics to their initial, starting, level will be useful when we allow the user to restart the game.  Eventually, when the player restarts the game, we will call this new function to re-set the statistics to their starting levels.

In order to do this, we will first need to replace the code in InitializeWorld with a call to the new function.  The second thing that we'll do is define the function.

• InitializeWorld():

  protected override void InitializeWorld() {     World.SetWorldCoordinate(new Vector2(0,0), 100.0f);     // initialize 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);         #region initialize the blocks     // (This region is left folded, for now)     #endregion         // initialize statistics     InitializeStats(); }

  • The first thing you'll notice is that while some new code in InitializeWorld, most of it should be familiar.  For right now, we're going to leave the region entitled "initialize the blocks" folded up, since that code pertains to a different feature, which we'll examine in detail later on.
  • The main difference that we're looking at here is that we've taken the code to initialize the game's statistics:
        // initialize statistics

        m_NumBounces = 0;

        m_SkillLevel = "Novice";

        m_BallsMissed = 0;
    and moved that code into a new function, named InitializeStats();

• InitializeStats():

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

  • Looking at this new function, you'll see that it contains the exact same code that we used to have in the InitializeWorld method, so this method will behave in the same was as the old version did.
  • In addition to having the same functionality, it will now be easier to implement a 'restart game' option for the player - simply call this method, and all the stats will be reset to their initial, starting values.

2. Adding Obstacles:  Putting (Labeled) Blocks In The Middle Of The Screen

Now that we've refactored the initialization code, let's add a new feature: we will put a bunch of (labeled) blocks in the middle of the screen.  Since we haven't covered the programming topic of "an array of objects" yet, we will need to keep track of each block individually, which we will do using instance variables.  We will place the blocks a specific distance apart on the X axis, but randomly choose the height (on the Y axis); in order to make it easy to adjust those values, we'll use constants to define those numbers.  Once we've got the instance variables and named constants for the new feature, we'll need to initialize (which involves both creating and placing) all of the blocks.  Finally, we'll create a new function to check for a collision between the ball and any of the blocks, which we will call from UpdateWorld.

Let's examine each of those steps in detail:

• Declaring the instance variables and named constants

  We need to declare (to define, really) our instance variables before we can use them. 

  <code above this point omitted for clarity>     private XNACS1Rectangle m_LeftPaddle;     private XNACS1Rectangle m_RightPaddle;     #region random blocks and their positions     private XNACS1Rectangle m_ABlock;     private XNACS1Rectangle m_BBlock;     private XNACS1Rectangle m_CBlock;     private const float BLOCK_A_X_POSITION = 40.0f;     private const float BLOCK_X_OFFSET = 10.0f;     private const float BLOCK_POSITION_MIN_Y = 10.0f;     private const float BLOCK_POSITION_MAX_Y = 55.0f;     private const float BLOCK_WIDTH = PADDLE_WIDTH;     private const float BLOCK_HEIGHT = PADDLE_HEIGHT / 1.5f;     #endregion     // collect statistics     private int m_BallsMissed; <code below this point omitted for clarity>

  • We've enclosed the new instance variables and constants in a region, since they're all related to each other, and there's enough of them that it might be nice to 'fold them away', if we're focusing on some other part of the program.
  • You'll notice that we declare the rectangles just like normal, instance variable rectangles.  You'll notice that we've declared them as instance variables, despite the fact that once they've been created, they'll never change.  We do this because (for technical reasons) we can't simply put the word const in the blocks' declarations, and the steps we'd have to go through to make the blocks constant would obscure the other things we're trying to teach.  In other words, making the blocks constant would be both complicated enough and unrelated enough that it would hinder the topics we're trying to teach in this tutorial, so we'll leave the blocks as normal instance variables.  To quickly summarize some of the issues:
    • If we tried to make the blocks const, we would have to initialize the blocks in their declarations. Since we're doing fairly complicated initializations (e.g., we're adjusting variables in between creating the blocks), we can't really use this approach.
    • If we tried to make the blocks readonly, we would have to initialize the blocks in Game1 constructor. While this actually wouldn't be all that hard, it's different enough from the "initialize everything in InitializeWorld" pattern that we've been using that it would be distracting to cover that topic here.
    • The distinction between const and readonly is pretty unique to C# (neither Java, nor C++, have this distinction).  So while it would be interesting to see how these differ, we don't want to get bogged down in details that are overly specific to one language this early in the tutorials.  In other words, we want these tutorials to teach you how to program video games and interactive graphics using C#, but in a way that will allow you to move on to other languages and courses in the future.
  • For this tutorial, we will create three blocks, labeled (from left to right) A, B, and C.  We will therefore name the instance variables m_ABlock, m_BBlock, and m_CBlock.
  • The constants can be (mentally) divided up into three 'categories': those that are used for the horizontal (X-axis) spacing of the blocks, those used for the vertical (Y-axis) random placement of the blocks, and those that define the dimensions (height and width) of the blocks.
    • In terms of the horizontal placement of the blocks, the strategy that we'll use is to first place the A block, then move rightwards some distance, and place the B block, then move rightwards some distance, and place the C block.  If we wanted to add blocks, we can repeat the process more times.  We'll use the constant BLOCK_A_X_POSITION to define what horizontal distance between the left edge of the screen, and the center of the first block (of the A block).  After placing the A block, we'll move to the right by a distance of BLOCK_X_OFFSET, and place the B block there.  We'll repeat that to place the C block, etc.
    • In terms of the vertical placement of the blocks, the strategy that we'll use is to randomly pick a height for each of the blocks.  The values will range from BLOCK_POSITION_MIN_Y up to BLOCK_POSITION_MAX_Y.
    • In terms of the dimensions of the blocks, we'll define the width of the blocks to be the same as the width of the paddles (by declaring the BLOCK_WIDTH constant like so: private const float BLOCK_WIDTH = PADDLE_WIDTH;), and we'll define the height to be a bit smaller than the paddles (by declaring the BLOCK_HEIGHT constant like so: private const float BLOCK_HEIGHT = PADDLE_HEIGHT / 1.5f;)

• InitializeWorld():

  protected override void InitializeWorld() {     // initialize 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); #region initialize the blocks     // initilaize the random blocks along the way     float blockXPos = BLOCK_A_X_POSITION;     m_ABlock = InitializeRectangle(blockXPos, RandomFloat(BLOCK_POSITION_MIN_Y, BLOCK_POSITION_MAX_Y),                     BLOCK_WIDTH, BLOCK_HEIGHT);     m_ABlock.Label = "A";     blockXPos = blockXPos + BLOCK_X_OFFSET;     m_BBlock = InitializeRectangle(blockXPos, RandomFloat(BLOCK_POSITION_MIN_Y, BLOCK_POSITION_MAX_Y),                     BLOCK_WIDTH, BLOCK_HEIGHT);     m_BBlock.Label = "B";     blockXPos = blockXPos + BLOCK_X_OFFSET;     m_CBlock = InitializeRectangle(blockXPos, RandomFloat(BLOCK_POSITION_MIN_Y, BLOCK_POSITION_MAX_Y),                     BLOCK_WIDTH, BLOCK_HEIGHT);     m_CBlock.Label = "C"; #endregion     // initialize statistics     InitializeStats(); }

  • For now, we've decided to keep all the new initialization code in the InitializeWorld method, instead of calling a separate method.  Also, you can see the familiar, grayed-out code at the start and end of the method that you've seen previously.
  • We will randomly generate the height (on the Y axis) for each block, so we don't need to keep track of any information about the Y axis.  However, for the X axis, we'll start BLOCK_A_X_POSITION units from the left edge, and move BLOCK_X_OFFSET units over for each block.  Thus, we'll need to keep track of what the current X value for the block is, but only while we're creating & placing the blocks here in this method.  Therefore, we will create a local variable, named blockXPos, which we'll use to temporarily store the current 'X' value.
    • Since the first block is placed BLOCK_A_X_POSITION  units from the left edge, we'll initialize blockXPos to be BLOCK_A_X_POSITION , when we declare blockXPos.
  • First, we'll create the 'A' block, then label it with 'A', like so:
        m_ABlock = InitializeRectangle(blockXPos, RandomFloat(BLOCK_POSITION_MIN_Y, BLOCK_POSITION_MAX_Y),

                        BLOCK_WIDTH, BLOCK_HEIGHT);

        m_ABlock.Label = "A";

  • After that, we want to move rightwards by move BLOCK_X_OFFSET units over before creating the next block, which we do with the following line:
        blockXPos = blockXPos + BLOCK_X_OFFSET;
  • Next, we create the 'B' block, label it as 'B', and then move blockXPos over by another BLOCK_X_OFFSET units.
  • Finally, we create the 'C' block, label it as 'C'
  • Notice that with this very nice, regular, repeating pattern ("create a block, label it, move blockXPos units to the right"), we could easily create more blocks if we wanted to.
• UpdateWorld():

  <code above this point omitted for clarity>     // move the soccer center by velocity     m_TheSoccer.Center = m_TheSoccer.Center + m_BallVelocity; #endregion     // Check for collision with the blocks     BounceOffBlocks();     // simple if tests for world bound     CheckWorldBound();     // paddle colliding with the soccer     BounceOffPaddles(); <code below this point omitted for clarity>

  • UpdateWorld is almost exactly the same as in the previous tutorial.  The only differences are that we've removed the EchoToTopStatus command from the UpdateWorld (it used to be just below the line that moved the soccer ball's center, and above the #endregion line), and that we need to check if the ball has bounced off any of the new blocks.
  • We'll check for the ball bouncing off the blocks using a new function, BounceOffBlocks(), that we'll create in the 'utility functions' region of the program.
• BounceOffBlocks():

  /// <summary> /// Test for collision with the blocks, if collision occurs, /// flip the sign of the x-component of the velocity. /// </summary> private void BounceOffBlocks() {     if (m_ABlock.Collided(m_TheSoccer))     {         m_TheSoccer.VelocityX = -m_TheSoccer.VelocityX;         EchoToTopStatus("Last block collision: A-Block");         PlayACue("Break");     }     else if (m_BBlock.Collided(m_TheSoccer))     {         m_TheSoccer.VelocityX = -m_TheSoccer.VelocityX;         EchoToTopStatus("Last block collision: B-Block");         PlayACue("Break");     }     else if (m_CBlock.Collided(m_TheSoccer))     {         m_TheSoccer.VelocityX = -m_TheSoccer.VelocityX;         EchoToTopStatus("Last block collision: C-Block");         PlayACue("Break");     } }

  • Looking at this new function, you'll see that it's very similar to the BounceOffPaddles() method.  Essentially, it goes through the list of blocks, and for each block it asks "Does this block overlap the soccer ball?"  If it does, then we reverse the horizontal speed of the soccer ball, change the top-of-the-screen message to indicate which block the ball most recently bounced off of, then then plays a sound.
  • Notice that since it's impossible for the ball to simultaneously overlap multiple blocks, we check for each of the collisions using the nested/chained if... else if structure.

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. Refactoring Code
   For this exercise, you should use the same project that was explained in the above tutorial.
   Create a new method, named something like InitializeBlocks, which will create and initialize all the blocks on the screen.  Make sure that instead of doing all this work in InitializeWorld, you call the new InitializeBlocks method, instead. 
3. Making the blocks into constant objects: Making the blocks readonly
   For this exercise, you should use the same project that was explained in the above tutorial.
   A readonly variable can be initialized when it's declared, or in the constructor, but can't be changed anywhere else.  So after the constructor is done, the variable can't be modified anymore, which makes readonly variables very similar to const variables.  You should be able to make the blocks readonly by:
   1.  putting the word readonly into their declarations (in the same place that you'd put a const), and then
   2. moving everything in the #region "random blocks and their positions" into the Game1 constructor.

	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