Arrays: Using Arrays (And Loops) To Keep Track of Multiple Objects

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:

• In this tutorial, we will:
  • Examine how one might use an array of object references to simplify the Pong Soccer game that was covered in previous tutorials.
  • Examine how to use the .Length property of an array, instead of a named constant, in order to determine the number of elements in an array.

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:

For this tutorial, we're going to go back and revisit a program that we examined earlier - the 'Pong Soccer' game that we looked at throughout the Chapter on decision structures, culminating in the finished game in tutorial 4000.900 (Pong Soccer).  The game plays exactly the same as before, although the appearance of the blocks has changed slightly (they're now numbered, instead of being labeled with letters).

2. Examining The Program:

Let's examine the C# source code that produces the behavior we see on-screen

• Declaring the instance variables and named constants

  private const int NUM_BLOCKS = 5;     // new representation of all the blocks     private XNACS1Rectangle[] m_Blocks;

  • The major change for this tutorial is that we will keep track of all the blocks using an array of references to XNACS1Rectangle objects.  Note that we've simplified the declaration substantially - now we only need to declare how many blocks we want, and an array. 
    • In contrast, we needed to declare each and every block separately, back when we didn't know about arrays, like so:
      private XNACS1Rectangle m_ABlock;

      private XNACS1Rectangle m_BBlock;

      private XNACS1Rectangle m_CBlock;

      private XNACS1Rectangle m_DBlock;

      private XNACS1Rectangle m_EBlock;

• InitializeWorld():

  // Allocate memory and initialize the blocks     m_Blocks = new XNACS1Rectangle[NUM_BLOCKS];     float blockXPos = BLOCK_A_X_POSITION;     for (int i = 0; i<m_Blocks.Length; i++) {         m_Blocks[i] = InitializeRectangle(  blockXPos,                                             RandomFloat(BLOCK_POSITION_MIN_Y, BLOCK_POSITION_MAX_Y),                                             BLOCK_WIDTH,                                             BLOCK_HEIGHT);         m_Blocks[i].Label = "Block-" + i;         blockXPos = blockXPos + BLOCK_X_OFFSET;     }

  • We're basically using the same approach to initialize the blocks as we used to initialize the soccer balls in the prior tutorial.  Note that the order of the statements has been changed a little bit, and that the opening curly brace for the loop is on the same line as the for loop (this is perfectly legal, and many people prefer this style of indentation).  Note that in this example, instead of tracking the X offset from the left-most soccer ball, blockXPos tracks the X value of the (center of the) current rectangle.
  • Notice also that we're using the array's .Length property, instead of using a named constant:
        for (int i = 0; i < m_Blocks.Length; i++) {

    In C#, each array knows how many elements it stores, and you can ask for this number using the .Length property, as you see above.  Since the array was declared to have five elements, then m_Blocks.Length has the value 5.  Remember that since the elements are numbered 0, 1, 2, 3, and 4 (NOT 5!), the loop will run correctly when we use the 'strictly less than' operator ( <  ), rather than 'less than or equal to'.

  • Notice how much more compact, efficient, and easy to understand this is, in contrast to the 30 lines of very repetitive code that all looked like:
        blockXPos = blockXPos + BLOCK_X_OFFSET;

        m_EBlock = InitializeRectangle(blockXPos,

        RandomFloat(BLOCK_POSITION_MIN_Y, BLOCK_POSITION_MAX_Y),

        BLOCK_WIDTH, BLOCK_HEIGHT);

        m_EBlock.Label = "E";

• BounceOffBlocks() (called by UpdateWorld() ):

  // notice, we only really need to find the first colliding block     // there is no reason for further test after one collision has been     // detected: physically impossible to collide with two blocks!     for (int i=0; i< m_Blocks.Length; i++)     {         if (m_Blocks[i].Collided(m_TheSoccer)) {             m_TheSoccer.VelocityX = -m_TheSoccer.VelocityX;             EchoToTopStatus("Last block collision:" + i + "-Block");             PlayACue("Break");         }     }

  • The loop that's being used here simply iterates through all the valid indices of the array - it starts at 0, then goes to 1, 2, 3, and 4 (technically, i++ will move the value of i up to 5, but the check will then fail, so we are assured that the body of the loop will never execute when i has the value 5)
        for (int i=0; i< m_Blocks.Length; i++)
    • Notice that we're once again using the .Length property
  • Inside the loop, we have an if statement
            if (m_Blocks[i].Collided(m_TheSoccer)) {

    The first time through the loop, i has the value zero, so during the first iteration of the loop, we're really asking if the rectangle object referred to by element #0 has collided with the soccer ball.  The next time through the loop, i has the value 1, so the code is then equivalent to:
            if (m_Blocks[0].Collided(m_TheSoccer))

  • If a collision is detected, we flip the horizontal velocity of the ball, update the message at the top of the screen, and play a sound, like we've done previously.
  • Notice how compact and efficient this code is.  The prior version of this game needed about 30 lines of code, which repeatedly did the same thing, over and over again, using the following pattern:
        else if (m_EBlock.Collided(m_TheSoccer))

        {

            m_TheSoccer.VelocityX = -m_TheSoccer.VelocityX;

            EchoToTopStatus("Last block collision: E-Block");

            PlayACue("Break");

        }

    We've managed to both minimize the amount of repeated code, as well as set things up so that our code will automatically check for a collision with all the blocks (should we choose to add more) without us needing to change anything.

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. Adding Blocks
   For this exercise, you should use the same project that was explained in the above tutorial, and modify it so that there are 2 more blocks on the screen.  When doing this exercise, you should strive to make the fewest possible changes to the source code, while still producing a correct program. Once you've done that, add change the code that there are a total of 10 blocks - notice how little code needs to be changed to effect this change!
3. Labeling Blocks With Letters Instead Of Numbers
   For this exercise, you should use the same project that was explained in the above tutorial, and modify it so that instead of labeling the blocks with nubmer (e.g., "Block 1"), instead the blocks are labeled with letters (e.g., "Block-A"). 
   Hint: Instead of creating a giant if...else if statement, how can you use an array containing the strings { "A", "B", "C", "D", "E" }to fix this problem?

	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