OOP: Adding our own UpdateBall method

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:
  • parameters for constructor
• Notice:
• SoccerBall constructor: set m_TheBall.ShouldTravel to true! with a non-zero velocity, this will cause m_TheBall to move (automatically)!
• SoccerBall.UpdateBall() method is called in every update to bound the traveling ball

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:

Just like in the prior tutorial, the left thumbstick controls the pink/blue 'spot' on the screen.  Until the user presses 'A' button for the first time, the screen is blank except for the spot (and the top/bottom status messages).  When the player presses the 'A' button, the current soccer ball (if any) disappears from the screen (and from the program's internal logic), and a new one is created on the spot's current location.  If there's a soccerball on the screen, then the right thumbstick can be used to roll it, and the same sort of logic is still used to ensure that the program doesn't crash, prior to the first soccer ball's appearance. 

What's new in this tutorial is that the ball moves constantly.  Here is where we'll start to see the power of OOP, as we can add this 'always moving' functionality to the SoccerBall, and not the overall game.  While this 'always moving' functionality is pretty simple, you could imagine more complicated functionality that we could add to the ball, while keeping the core game logic simple.  A couple of examples include the ball fading in-and-out, the ball 'jumping' from one place to another, etc, etc

2. Game1.cs:

This is almost identical to what we looked at in the prior tutorial.  The only thing that's new is that whenever the game as a whole updates itself (i.e, whenever the UpdateWorld method is executed), we will need to update the SoccerBall (in order to make sure that when it reaches the edge of the screen, it reverses it's currently horizontal/vertical direction).

While we could do this all in the UpdateWorld, it will be better (more object-oriented) to do have the SoccerBall to update itself.  In order to make this possible, the SoccerBall class will implement an UpdateBall method, which we will here in UpdateWorld:

• UpdateWorld():

  if (null != m_TheBall)     {         m_TheBall.RollTheSoccer(GamePad.ThumbSticks.Right.X);         m_TheBall.UpdateBall();     }

  • You'll notice that we're calling this method INSIDE the check to see if there's actually a SoccerBall object.  In the same way that we don't want to crash the program by rolling a non-existent soccer ball, we also don't want to crash by attempting to update a non-existent soccer ball.
  • Notice that the player can roll the soccer ball, right before the UpdateBall method is called.  This means that both effects will be applied to the soccer ball on the screen.  So while the user cannot directly move the SoccerBall object, the user can affect the slightly by rolling it as it moves itself.

1. SoccerBall.cs:

We've decided to neatly encapsulate all the 'motion related' logic here inside the SoccerBall class. Let's examine the details of the code:

• Named constants:

  #region constants private to this class     private const float RADIUS = 3.0f;       private const float ROLL_ANGLE = 1.2f;     private const float MOVE_UNIT = 0.1f;       private const float INIT_VELOCITY_X = 1f;     private const float INIT_VELOCITY_Y = 1f;     #endregion

  • Because we haven't (yet) set things up so that Game1 can specify a starting speed (for example, with another parameter to the constructor), the SoccerBall will need to define appropriate starting speeds (both horizontal and vertical) for the soccer ball.  We'll do that using named constants, as listed above.
• Constructor:

  /// <summary>     /// Constructs a SoccerBall object at the specified position     /// </summary>     /// <param name="centerPosition">position to create the soccer object at.</param>     public SoccerBall(Vector2 centerPosition)     {         m_TheBall = new XNACS1Circle(centerPosition, RADIUS);         m_TheBall.Texture = "SoccerBall";           // set the soccer in motion!         m_TheBall.ShouldTravel = true;         m_TheBall.VelocityX = INIT_VELOCITY_X;         m_TheBall.VelocityY = INIT_VELOCITY_Y;     }

  • As you can see, the constructor is the same as in the prior tutorial, with the exception of three new lines of C# code.
    • The first new line tells the XNACS1 library to move the XNACS1Circle between calls to the game's UpdateWorld method.
      
              m_TheBall.ShouldTravel = true;
    • The second new line tells the XNACS1 library how much to move the circle, horizontally, each time it's moved.  We'll set this to the constant INIT_VELOCITY_X:
      

              m_TheBall.VelocityX = INIT_VELOCITY_X;

    • The final new line tells the XNACS1 library how much to move the circle, vertically, each time it's moved.  We'll set this to the constant INIT_VELOCITY_Y:
      

              m_TheBall.VelocityY = INIT_VELOCITY_Y;

• UpdateBall:

  /// <summary>     /// Make sure the soccer ball does not go outside of the bound     /// </summary>     public void UpdateBall()     {         BoundCollideStatus status = XNACS1Base.World.ClampAtWorldBound(m_TheBall);           switch (status)         {             case BoundCollideStatus.CollideBottom:             case BoundCollideStatus.CollideTop:                 m_TheBall.VelocityY = -m_TheBall.VelocityY;                 break;               case BoundCollideStatus.CollideLeft:             case BoundCollideStatus.CollideRight:                 m_TheBall.VelocityX = -m_TheBall.VelocityX;                 break;         }     }

  • The only updating that we'll do for the ball is to make sure that it doesn't leave the screen (BoundCollideStatus status = XNACS1Base.World.ClampAtWorldBound(m_TheBall);), and to then reverse the direction of the ball if it hits an edge of the screen (the rest of the method).  This should look a lot like games you've seen in previous tutorials, so we won't discuss it in any more detail.
  • Notice that since we're doing this here, it's no longer necessary to do this in the RollTheSoccer method, so this logic has been removed from there.

FURTHER EXERCISES:: 

1. Alter the RollTheSoccer method, so when the user pushes the right thumbstick, a substantially greater rotation happens, so that the change is easier to see.
2. Create a new file named TeleportingBall.cs by opening the Solution Explorer (View → Solution Explorer), right-clicking on the project, then selecting Add → New Item, then finally selecting Class and naming it TeleportingBall.cs.  Copy the SoccerBall code, and paste it into the TeleportingBall.cs file, and rename the class from SoccerBall to TeleportingBall.  The TeleportingBall should behave just like a SoccerBall, except that when it reaches the right edge of the screen, it should teleport to the left edge, WITHOUT switching direction.  When it hits the top or bottom of the screen, it should flip it's vertical velocity, just like it does now.  Modify Game1.cs so that the game uses this new TeleportingBall, instead of a normal SoccerBall.
3. Create another ball, the TwoColorBall, by copying the SoccerBall's code into a new file (named TwoColorBall.cs).  It should have no image associated with it, but instead, as the ball proceeds across the screen, the color changes from green (when it's anywhere on the left HALF of the screen) to blue (on the right HALF of the screen).  Modify Game1.cs so that the game uses this new TwoColorBall, instead of a normal SoccerBall.
   1. Hint: You'll need to get the ball's current position, then change the color based on that.
4. Extra Challenging: Create another ball, the ChromaticBall, by copying the SoccerBall's code into a new file (named ChromaticBall.cs).  It should have no image associated with it, but instead, as the ball proceeds across the screen, the color smoothly change from one color (when it's on the left EDGE of the screen) to a different color (on the right EDGE of the screen).  Modify Game1.cs so that the game uses this new ChromaticBall, instead of a normal SoccerBall.
1. Hint: You'll need to get the ball's current position, then use that to mathematically figure out what to set the color to
2. Hint: You'll need to look at how to create a new Color object based on, say, the RGB values that you can pass into a Color object's 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