Improved Pong Soccer Game

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:
  • Final Implementation of a Pong Soccer Game, with three types of blockers: normal, breakable, and MovableBlock
  • MovaBlock moves vertically upon collision with the soccer
• Notice:
• ArrayOfBlock class (centralized collection of blocks)
• Some game logic as we have seen previously (please refer to: the final example from decision structures ).

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 go back & redo the Pong game, this time using Object-Oriented Programming techniques.  Changes from the previous tutorial include the addition of a MoveableBlock (which moves a short, vertical distance when the SoccerBall object collides with it), and putting all the logic that relates to the array of blocks into a separate class (named ArrayOfBlocks)

1. Block.cs, BreakableBlock.cs

These are effectively identical to what was presented in the prior tutorial.  - we've changed some named constants to make things look nicer, but that's it.  You should be able to understand all of these changes on your own.

2. Paddle.cs,

This is very similar to what was presented in the prior tutorial.  Some of the named constants have been adjusted slightly in order to make everything look better, and the constructor now calls the new InitializePaddleState method in order to initialize (or reinitialize) each paddle object.

• InitializePaddleState():

  /// <summary>     /// Initializes the paddle's collision count     /// </summary>     public void InitializePaddleState()       {         m_HitCount = 0;     }

  • As you can see, this (re)sets the starting hit count to be zero.  This method will be called not just by the constructor, but also by the Game1 class, whenever the user presses the 'A' button, in order to restart a new game.

3. MovableBlock.cs,

As you can see from the code, this new class inherits from from the basic Block class.  Given that we want to create a new type of block that closely resembles the existing type of block, with the exception of a new and more specialized behavior when the soccer ball collides with this new block, inheritance makes a lot of sense.

As you examine the code (and at this point, you should be able to confidently and correctly examine all of MovableBlock on your own), you'll notice that we declare the named constant MOVE_UNIT to define the default distance that a MovableBlock will be moved, when hit.  We then copy that constant into an instance variable in the constructor, so that we can change the direction each time the block is hit by changing the sign on the number from positive to negative.

The PlayCollisionCue method is overridden so that hitting a MovableBlock will play a different sound, and the CollideWithSoccer method is overridden in order to adjust the MovableBlock's location when it gets hit. Note that the direction is reversed each time that the MovableBlock is hit, so that the block doesn't move off the screen

4. ArrayOfBlocks

In the previous tutorial, we used an array of Block (and BreakableBlock) objects In this tutorial, we will take all the functionality of that deals with the 'array of Blocks' and nicely encapsulated into a class, so as to make the code easier to understand (i.e., to simplify Game.cs) and promote reuse (in case we wanted to use this elsewhere).  The ArrayOfBlocks' responsibilities include creating the array, creating a randomly chosen set of Blocks to put into the array, detecting collisions between the soccer ball and any block, and displaying some interesting information to the top status bar.

• Class declaration, Named Contants:

  public class ArrayOfBlocks     {         #region Constants for the blocks         // in x, blocks will be equally spaced begining from 20, and end at 80         private const float BLOCK_BEGIN_X_POSITION = 20.0f;         private const float BLOCK_X_SPAN = (80.0f - BLOCK_BEGIN_X_POSITION);           private const float CHANCE_OF_BREAKABLE = 0.4f; // chance a block is breakable         private const float CHANCE_OF_MOVABLE = 0.6f; // chance a block is movable         #endregion

  • As you can see, the ArrayOfBlocks class does not inherit from any other classes
    

    public class ArrayOfBlocks

  • We have declared several named constants here, which basically fall into two categories: the first two deal with the placement of blocks on the screen, the second two assign probabilities that a special type of block is created. 
    • For the first category, we define the X value of the left-most block ( BLOCK_BEGIN_X_POSITION ), and how much distance (on the X axis) between the first block and the last block ( BLOCK_X_SPAN - since we stop placing blocks at 80.0f units across, we simply subtract the left-most position from 80 in order to get this span).
    • For the second category, we define the probability of creating a breakable, or movable block, where 0 means 0% and 1 means 100%.
      • Note that the probabilities don't have to sum up to 1 (100%). 
      • As you'll see later, there's a  CHANCE_OF_BREAKABLE % chance that a BreakableBlock is created.  If a BreakableBlock is not created, then there's a CHANCE_OF_MOVABLE % chance that a MovableBlock is created.  If a MovableBlock is not created, then a normal Block is created by default. 
        • So technically the chance of creating a movable block is actually less than the listed CHANCE_OF_MOVABLE .
• Instance Variables:

  private Block [] m_Blocks = null ;    // Array of blocks         private int m_TotalBlocks;          // total number of blocks         private int m_NumBreakable;         // number of breakable ones         private int m_NumMovable;           // number of movable ones         private int m_TotalHit;             // total number of collisions with the blocks

  • The ArrayOfBlocks uses it's private Block array to keep track of all the Blocks on the screen.
    

    private Block [] m_Blocks = null ;    // Array of blocks

    • Remember that each slot in the array can refer to either a basic Block class, or a any subclass of the Block class (such as BreakableBlock, or MovableBlock). 
    • Note that the m_Blocks variable starts out with the value null, meaning that when the ArrayOfBlocks object is first created, it doesn't actually have an array.  Instead, we'll create the array in the InitializeBlocks method.  By setting things up this way, it will allow us to call the InitializeBlocks method again later, in order to restart the game
  • The next several instance variables track the total number of blocks (of any type), the number of breakable blocks, and the number of movable blocks.
    

            private int m_TotalBlocks;          // total number of blocks

            private int m_NumBreakable;         // number of breakable ones

            private int m_NumMovable;           // number of movable ones

  • Finally, we also track the number of times that any block anywhere has been hit by the soccer ball:
    

            private int m_TotalHit;             // total number of collisions with the blocks

• Contructor, InitializeBlocks method:

  /// <summary>     /// Create n blocks, will create breakable, movable, and regular blocks     /// </summary>     /// <param name="total"> Total number of blocks to create. </param>     public ArrayOfBlocks( int total)     {         m_TotalBlocks = total;           InitializeBlocks();     }       /// <summary>     /// Allocate and initialize all the blocks. If blocks have been previously initialize, will remove     /// all blocks from the AutoDrawSet and re-create the blocks.     /// </summary>     public void InitializeBlocks()     {         if ( null != m_Blocks)          {             // blocks already showing, must remove them first             for ( int i = 0; i < m_Blocks.Length; i++)                 m_Blocks[i].RemoveFromAutoDrawSet();         }           m_Blocks = new Block [m_TotalBlocks];         m_NumBreakable = 0;         m_NumMovable = 0;         m_TotalHit = 0;           float offset = BLOCK_X_SPAN / m_Blocks.Length;         float blockXPos = BLOCK_BEGIN_X_POSITION;         for ( int i = 0; i< m_Blocks.Length; i++)         {              if ( XNACS1Base .RandomFloat() < CHANCE_OF_BREAKABLE)             {                 m_Blocks[i] = new BreakableBlock (blockXPos);                 m_NumBreakable++;             }             else if ( XNACS1Base .RandomFloat() < CHANCE_OF_MOVABLE)             {                 m_Blocks[i] = new MovableBlock (blockXPos);                 m_NumMovable++;             }             else             {                 m_Blocks[i] = new Block (blockXPos);             }             blockXPos = blockXPos + offset;         }     }

  • ArrayOfBlocks' constructor simply copies the parameter into the m_TotalBlocks instance variable (so that we don't have to keep passing this value in every time we call InitilizeBlocks, and then calls InitializeBlocks
  • InitializeBlocks uses the previously-explained trick of checking if m_Blocks has the value null to determine if there are aleady a bunch of Blocks on the screen.  If m_Blocks is NOT null, then there must be blocks there, so we loop through those blocks and remove them all from the screen:
    

            if ( null != m_Blocks)

             {

                // blocks already showing, must remove them first

                for ( int i = 0; i < m_Blocks.Length; i++)

                    m_Blocks[i].RemoveFromAutoDrawSet();

            }

  • Next, the method unconditionally allocates a new array, and resets all the instance variables that track things:
    

            m_Blocks = new Block [m_TotalBlocks];

            m_NumBreakable = 0;

            m_NumMovable = 0;

            m_TotalHit = 0;

    • This does mean that if we already had an array, we will discard it when we allocate a new one.
  • Prior to starting the loop, we initialize the offset variable to hold the distance between each block (all the blocks are the same distance apart).  Clearly, this is the total distance across which we're putting blocks (BLOCK_X_SPAN) divided by the number of blocks are want to pace (m_Blocks.Length).  We also define a variable to keep track of the X position of the current block that we're tracking:
    

            float offset = BLOCK_X_SPAN / m_Blocks.Length;

            float blockXPos = BLOCK_BEGIN_X_POSITION;

  • The loop executes once for each slot in the array, thus guaranteeing that by the time this method finishes, all the array elements will have been assigned a Block (of some type). 
    

            for ( int i = 0; i< m_Blocks.Length; i++)

            {

                if ( XNACS1Base .RandomFloat() < CHANCE_OF_BREAKABLE)

                {

                    m_Blocks[i] = new BreakableBlock (blockXPos);

                    m_NumBreakable++;

                }

    • Inside the loop, we generate a random number between 0 and 1, and compare it to CHANCE_OF_BREAKABLE .  If the number we generated is less than CHANCE_OF_BREAKABLE then we create a new BreakableBlock in this slot, and increment the counter that tracks how many BreakableBlocks we've created.
    • Similar code is used to create the MovableBlock.  Note that the use of the if ... else if ... else structure ensures that we will only create ONE type of block.
    • If neither of the above two blocks are created (BreakableBlock or MovableBlock), then the final else clause ensures that  a normal Block is created.
    • Each of the Block objects is responsible for randomly picking a Y value (height) for it's location.  This loop needs to provide the X value (distance from left edge) using the blockXPos variable.  Regardless of which type of Block is created, we need to move blockXPos over at the end of each iteration of the loop:
      

                  blockXPos = blockXPos + offset;

       

• CollideWithSoccer:

  /// <summary>     /// Collide the soccer ball with each of the blocks in the array.     /// </summary>     /// <param name="theSoccer"> The soccer ball to bounce with. </param>     /// <returns> true if collided, otherwise returns false. </returns>     public bool CollideWithSoccer( SoccerBall theSoccer)     {         bool found = false ;      // have not found the first block that collide with the soccer         int i = 0;               // loop iterator           while ( (!found) && (i<m_Blocks.Length) ) {                         if ( (m_Blocks[i].CollideWithSoccer(theSoccer)) ) {                 found = true ;                 m_TotalHit++;                 if (!m_Blocks[i].BlockIsActive())                     m_NumBreakable--;             }             else                 i = i + 1;         }           return found;    // found one collision     }

  • In a nutshell, this method is intended to find the first wall that the soccer ball has collided with (if any).  It does this by going through the array, and stopping on the first block that collides with the soccer ball.

  • In order to both count through the array slots, and stop once we've found a collision, we declare two variables.  We'll initialize found to false, to indicate that we have not yet found a collision, and set it to true if and when we do find a collision.  The integer i will be used as a counter:
    

            bool found = false ;      // have not found the first block that collide with the soccer

            int i = 0;               // loop iterator

  • The loop will continue while we have NOT found a collision, and while i is still inside the bounds of the array:
    
    while ( (!found) && (i<m_Blocks.Length) ) {

  • Within the loop, we'll check to see if the soccer ball has collided with the current block.  If it has, then we'll set found to true (thus exiting the loop), increment the total number of times any block has been hit, and if the block was a breakable block that has switched from being active to being inactive, we'll decrement the m_NumBreakable count by one.  If the soccer ball hasn't collided with any blocks, then we'll simply increment i by one, so that we'll examine the next block on then next iteration:
    

            while ( (!found) && (i<m_Blocks.Length) ) {

               

                if ( (m_Blocks[i].CollideWithSoccer(theSoccer)) ) {

                    found = true ;

                    m_TotalHit++;

                    if (!m_Blocks[i].BlockIsActive())

                        m_NumBreakable--;

                }

                else

                    i = i + 1;

            }

    
    

  • At the end of the above, we'll return found, which will be true, if we found a block that the soccer ball has collided with, and will be false if the soccer ball didn't collide with anything.
    

            return found;    // found one collision

• BreakableBlocksLeft:

  /// <summary>     ///     /// </summary>     /// <returns> Total number of breakable blocks </returns>     public int BreakbleBlocksLeft()     {         return m_NumBreakable;     }

  • This simply returns the number of breakable blocks left. 
    • We don't provide a similar method for the number of movable blocks, although we could do so easily, if we wanted to.
• ComputeAndEchoBlockStat:

  /// <summary>     /// Collect the state information of the current blocks and echo to TopStatus     /// </summary>     public void ComputeAndEchoBlockStat()     {         int minBounce = m_Blocks[0].TotalHits(); // initialization         int maxBounce = m_Blocks[0].TotalHits();         int numActive = 0;         float avgBounce = 0.0f;           for ( int i = 0; i < m_Blocks.Length; i++)         {             // compute min             if (m_Blocks[i].TotalHits() < minBounce)                 minBounce = m_Blocks[i].TotalHits();               // comptue max             if (m_Blocks[i].TotalHits() > maxBounce)                 maxBounce = m_Blocks[i].TotalHits();               // accumate conditionally             if (m_Blocks[i].BlockIsActive())                  numActive++;         }         avgBounce = ( float )m_TotalHit / ( float )m_Blocks.Length;           XNACS1Base .EchoToTopStatus( "Block Stat: Bounces:(total=" + m_TotalHit +                             " min=" + minBounce +                             " max=" + maxBounce +                             " avg=" + avgBounce + ") " +                             "NumActive=" + numActive);     }

  • ComputeAndEchoBlockStat is responsbible for collecting up some simple statistics, and displaying them into the top status bar.

    • We use a loop to figure out what is the smallest number of hits that any one block has, storing that result into minBounce .

    • We that same loop to figure out what is the largest number of hits that any one block has, storing that result into maxBounce .

    • We also use that same loop to figure out how many blocks are still active.

    • Having calculated the above (and since we've still got m_TotalHit that we're maintaining), we can calculate the average number of bounces (hits) per block.  We then echo all of the above to the top status bar.

3. SoccerBall.cs,

In additon to handling the image, position, and velocity of the on-screen soccer ball, this class will also track whether the ball is in 'expert mode', and the total count of the number of misses.  Each time the ball has hit the left/right edge of the screen counts as a 'miss' (i.e., the number of times it has been missed by the player).  When the ball is in 'expert mode', the speed will be increased.  Note that the ball only tracks which mode it's in - the Game1 object will actually decide when to go into expert mode.

• BreakableBlocksLeft:

  #region Constants for soccer ball         // Ball size, position, velocity and lossing conditions         private const float BALL_INIT_X = 50.0f;    // initial ball X and Y positions         private const float BALL_INIT_Y = 25.0f;         private const float BALL_RADIUS = 1f;         private const float BALL_VELOCITY_MIN_X = 0.5f;         private const float BALL_VELOCITY_MAX_X = 1.1f;         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;         private const float BALL_VELOCITY_EXPERT_BOOST_X = 0.1f;         private const float BALL_VELOCITY_EXPERT_BOOST_Y = BALL_VELOCITY_EXPERT_BOOST_X / 3.0f;         #endregion           private bool m_ExpertBall;   // if the soccer ball is in expert mode         private int m_BallsMissed;   // how many times did the soccer ball fall of the side boundaries.

  • As you can see from the SoccerBall.cs file, we declare a fair number of named constants, plus two instance variables, in order to make this all happen.  You can sort through the named constants at your own; we'd like to focus your attention on the instance variables here:
    

            private bool m_ExpertBall;   // if the soccer ball is in expert mode

            private int m_BallsMissed;   // how many times did the soccer ball fall of the side boundaries.

    • The bool will track whether the ball is in expert mode or not; m_BallsMissed will track the number of times that the ball has been missed, in total, by the players.
• Constructor, InitializeBall:

  /// <summary>         /// Constructor of the soccer ball, with default position and velocity.         /// </summary>         public SoccerBall()         {             // instance variable in the class             m_ExpertBall = false ;             m_BallsMissed = 0;               ShouldTravel = true ;               InitializeBall();         }           /// <summary>         /// Private utility class to initialze the ball position and velocity         /// will check and set the ball to an "expert" ball if in the proper mode.         /// </summary>         public void InitializeBall()         {             // These are accessors from the XNACS1Circle super class.             Center = new Vector2 (BALL_INIT_X, BALL_INIT_Y);             Radius = BALL_RADIUS;             Texture = "SoccerBall" ;               Velocity = new Vector2 ();             VelocityX = XNACS1Base .RandomFloat(BALL_VELOCITY_MIN_X, BALL_VELOCITY_MAX_X);             VelocityY = XNACS1Base .RandomFloat(BALL_VELOCITY_MIN_Y, BALL_VELOCITY_MAX_Y);               if (m_ExpertBall)                 SetToExpertMode();         }         /// <summary>         /// Sets the ball to expert mode by increasing its velocity         /// </summary>         public void SetToExpertMode()         {             m_ExpertBall = true ;             VelocityX += Math .Sign(VelocityX) * BALL_VELOCITY_EXPERT_BOOST_X;             VelocityY += Math .Sign(VelocityY) * BALL_VELOCITY_EXPERT_BOOST_Y;         }

  • Just like with the ArrayOfBlocks class, the constructor sets up the bare minimum needed to call the InitializeBall method.  InitializeBall will also be used whenever the ball reaches one edge of the screen and needs to be moved back to the center.
    • Note that neither m_ExpertBall nor m_BallsMissed get reset.  So when InitializeBall is called later in the game, it may be necessary to call SetToExpertMode() in order to accelerate the ball to a speed that's appropriate for 'expert mode'
• UpdateBall():

  /// <summary>     /// Updates the ball by colliding it with the world boundaries. Will update the ball miss number if the     /// ball goes out of bound (on either sides of the play field).     /// </summary>       public void UpdateBall()     {         XNACS1Lib. BoundCollideStatus status = XNACS1Base . World .CollideWorldBound( this );         switch (status)         {             case BoundCollideStatus .CollideTop:             case BoundCollideStatus .CollideBottom:                 VelocityY = -VelocityY;                 break ;               case BoundCollideStatus .CollideRight:             case BoundCollideStatus .CollideLeft:                 // Fall off from either side, must reinitialize                  InitializeBall();                   m_BallsMissed++;                 XNACS1Base .PlayACue( "BallDie" );                 break ;               case BoundCollideStatus .InsideBound:                         // REMOVE THIS??                 break ;         }       }

  • The above code is very similar to prior boundary-handling code blocks.  When the soccer ball hits the top or the bottom of the screen, the vertical speed of the ball is reversed, as you've seen before.  What happens when the ball hits one of the side walls is a bit more complicated (but not much):
    

                case BoundCollideStatus .CollideRight:

                case BoundCollideStatus .CollideLeft:

                    // Fall off from either side, must reinitialize

                     InitializeBall();

     

                    m_BallsMissed++;

                    XNACS1Base .PlayACue( "BallDie" );

                    break ;

    • By calling InitializeBall, the ball will be moved back to the center of the screen, and a new, random velocity will be chosen.  If the ball is in expert mode, then the expert mode speed boost will be applied.
    • After that, the total number of missed balls is incremented, and a sound is played to indicate that the ball has left the screen.

2. Game.cs

This object keeps track of the game overall (using the SoccerBall, the two Paddles, and the ArrayOfBlocks), and it's responsible for knowing when to advance to expert mode.  Instead of examining the entire file here, we'll walk through the UpdateWorld method, and leave the rest for you to examine in more detail.

• UpdateWorld():

  protected override void UpdateWorld()         {             if (GamePad.ButtonBackClicked())                 this .Exit();               if (GamePad.ButtonStartClicked())             {                 if (m_GameState == GameState .Paused)                     m_GameState = GameState .Playing;                 else                     m_GameState = GameState .Paused;             }               if (GamePad.ButtonAClicked())             {                 m_LeftPaddle.InitializePaddleState();                  m_RightPaddle.InitializePaddleState();                   m_TheSoccer.InitializeBall();                 m_Blocks.InitializeBlocks();                 InitializeStats();             }               // 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_GameState != GameState .Playing)             {                 m_TheSoccer.ShouldTravel = false ;                 return ;             }             else             {                  m_TheSoccer.ShouldTravel = true ;             }                 #region move paddles and update the soccer             // update the left and right paddles with thumbstick             m_LeftPaddle.UpdatePaddlePosition(GamePad.ThumbSticks.Left.Y);             m_RightPaddle.UpdatePaddlePosition(GamePad.ThumbSticks.Right.Y);               m_TheSoccer.UpdateBall();             #endregion               // Check for collision with the blocks             m_Blocks.CollideWithSoccer(m_TheSoccer);             m_Blocks.ComputeAndEchoBlockStat();               // Check for collision with the paddles             m_LeftPaddle.CollideWithSoccer(m_TheSoccer);             m_RightPaddle.CollideWithSoccer(m_TheSoccer);               m_NumBounces = m_LeftPaddle.TotalHits() + m_RightPaddle.TotalHits();               // If we did collide with a paddle, and we have a new             // max bounces, update that here             if (m_NumBounces > m_MaxBounces)                 m_MaxBounces = m_NumBounces;               // Should we move from Notice to Expert mode?                         if (m_MaxBounces > EXPERT_LEVEL_BOUNCES)             {                  // String equality test                 if (m_SkillLevel == "Novice" )                 {                     World .SetBackgroundTexture( "ExpertImage" );                     PlayACue( "Victory" );                     m_TheSoccer.SetToExpertMode();                 }                 m_SkillLevel = "Expert" ;             }               EchoToBottomStatus( "[" + m_SkillLevel + "] " +                    "CurrentBounces:" + m_NumBounces +                    " MaxBounces:" + m_MaxBounces +                     " Total Balls Missed:" + m_TheSoccer.BallsMissed());                   // Check to see if the player has won or lost             CheckForEndState();         }

  • The game starts by checking to see if the game should exit (if the player has pressed the 'back' button), and then checking to see if the game should be paused.  Even if the game is paused, the player should still be allowed to reset the game (using the 'A' button).
  • Next, we check if (m_GameState != GameState .Playing) , in order to figure out if the game is in 'Playing' mode.  If it's in anything except 'Playing' mode, then we need to freeze the screen, and exit this method (so that we don't update anything).
  • Next, we update the paddles & soccer ball

  • Following that, we ask the ArrayOfBlocks object is any of the blocks are overlapping the SoccerBall.  Once that's done, we ask it to display the interesting statistics at the top of the screen:
    

                // Check for collision with the blocks

                m_Blocks.CollideWithSoccer(m_TheSoccer);

                m_Blocks.ComputeAndEchoBlockStat();

  • Next we figure out if the soccer ball collided with either of the paddles, followed by calculating the maximum number of bounces off both paddles since the last time a ball was missed.  If that maximum is greater than EXPERT_LEVEL_BOUNCES , we then advance into 'expert mode'

  • Finally, we check if the game is over.  If it is, then we'll stop updating the screen on the next update (because if (m_GameState != GameState .Playing) will be true).

FURTHER EXERCISES::  

1. Extra Challenge: Try to extend the program so that multiple soccer balls are supported.  Try putting (say) three SoccerBall objects onto the screen at the same time, and make sure that you've made all applicable modifications have been made to the program in order to make this work.

	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