OOP: Interactions of 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 objects from a new Paddle class can interact with the SoccerBall class

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, there is a single paddle on the left side of the screen, which is controlled by the left thumbstick.  The pink spot is controlled by the right thumbstick; when the 'A' button is pressed, a soccer ball appears and immediately begins to move across the screen.  The soccer ball will bounce of the screen's edges, and the paddle.

The major objective of this tutorial is to examine how multiple objects, each one made from a different class, can be made to interact with each other. In this case, there's a class for the SoccerBall, and a separate class for the Paddle.

SoccerBall.cs:

For this tutorial, we will mostly leave the SoccerBall class unchanged.  The only major difference between the SoccerBall class in this tutorial and the previous tutorial is that we've removed MoveTheBall and RollTheSoccer methods that we no longer use (along with the ROLL_ANGLE and MOVE_UNIT constants that they use).  We'll also add the GetCircle method, which Paddle objects will use to determine if the SoccerBall's circle overlaps/collides with the Paddle.

• GetTheCircle():

  /// <summary>     ///     /// </summary>     /// <returns>Returns the circle representing the soccer for interaction.</returns>     public XNACS1Circle GetTheCircle()     {         return m_TheBall;     }

  • As you can see, this method returns a reference to the XNACS1Circle object that the private m_TheBall instance variable refers to.

2. Game1.cs:

This class is also mostly unchanged from the prior tutorial.  The only major change is for the Paddle object has been added to the program.  In order to do this the PADDLE_X constant and the m_ThePaddle instance variable have been added to the class.  The variable is initialized in the InitializeWorld method, similarly to what we did for the SoccerBall class. 

UpdateWorld has been changed slightly, as well:

• UpdateWorld():

  protected override void UpdateWorld()     {         if (GamePad.ButtonBackClicked())             this.Exit();           m_TheSpot.Center += GamePad.ThumbSticks.Right;         m_ThePaddle.UpdatePaddlePosition(GamePad.ThumbSticks.Left.Y);           if (GamePad.ButtonAClicked())         {             if (null != m_TheBall)                 m_TheBall.RemoveFromDraw();             m_TheBall = new SoccerBall(m_TheSpot.Center);         }           if (null != m_TheBall)         {             m_TheBall.UpdateBall();             m_ThePaddle.BounceTheSoccer(m_TheBall);         }           EchoToTopStatus("Left Thumb Stick to move the left paddle, right thumb stick to move the red spot");         EchoToBottomStatus("Current Spot position:" + m_TheSpot.Center);     }

  • The paddle is moved by calling the UpdatePaddlePosition on the Paddle object referred to by m_ThePaddle.  We pass the vertical component of the left thumbstick into the method:
    

            m_ThePaddle.UpdatePaddlePosition(GamePad.ThumbSticks.Left.Y);

  • We also need to check if the ball has bounced off the paddle, but ONLY if the ball actually exists.  In order to do that, we will add code into the if statement that checks if the ball exists.  The added code will ask the paddle to check if it the ball has collided with it (and if it has, then the paddle is responsible for bouncing the ball off of it)
    

            if (null != m_TheBall)

            {

                m_TheBall.UpdateBall();

                m_ThePaddle.BounceTheSoccer(m_TheBall);

            }

    • Notice that in order to give the paddle access to the soccer ball object, we need to pass a reference to m_TheBall into the paddle's method

3. Paddle.cs:

You'll notice that the Paddle class is cery similar to the SoccerBall class - it has several named constants, an instance variable to keep track of the on-screen rectangle, and a constructor that has a parameter for the X part of the paddle's initial (X,Y) position.  What's interesting are the UpdatePaddlePosition and BounceTheSoccer methods.

• UpdatePaddlePosition():

  /// <summary>     /// Allow paddle up/down movement     /// </summary>     /// <returns></returns>     public void UpdatePaddlePosition(float dy)     {         m_Rec.CenterY += dy;         XNACS1Base.World.ClampAtWorldBound(m_Rec);     }

  • Recall that this method will be called from UpdateWorld, and the parameter will be given the value of the vertical component of the left thumbstick.  In this method, we'll add that vertical component to the rectangle's position, and then call the ClampAtWorldBound method, in order to ensure that the paddle can't leave the screen.
• BounceTheSoccer():

  /// <summary>     /// Bounce the soccer ball.     /// </summary>     /// <returns>true if paddle has bounced soccer, otherwise false</returns>     public bool BounceTheSoccer(SoccerBall theBall)     {         XNACS1Circle theBallCircle = theBall.GetTheCircle();           bool hit = m_Rec.Collided(theBallCircle);           if (hit)         {             theBallCircle.VelocityX = -theBallCircle.VelocityX;             // now move the circle to outside of the paddle             theBallCircle.CenterX = m_Rec.MaxBound.X + theBallCircle.Radius;         }         return hit;     }

  • We can't ask the SoccerBall directly if has collided with the Paddle.  Instead, we have to get the SoccerBall's XNACS1Circle, and see if that circle has collided with the paddle's XNACS1Rectangle. On the first line of the method, get obtain a reference to the SoccerBall's circle object using the previously described GetTheCircle method:

    
    

           XNACS1Circle theBallCircle = theBall.GetTheCircle();

  • Next, we'll see if the soccer ball's circle has collided with the paddle's rectangle, using the Collided method that is built into the rectangle.  We will store the result (true if the two objects have collided, false otherwise) into the local variable hit, so that we can return it at the end of the method.
    

    bool hit = m_Rec.Collided(theBallCircle);

  • If the ball has collided with the paddle, then we will reverse the horizontal speed of the ball, and then make sure that the ball is moved rightwards so that it no longer overlaps with the paddle.

     

            if (hit)

            {

                theBallCircle.VelocityX = -theBallCircle.VelocityX;

                // now move the circle to outside of the paddle

                theBallCircle.CenterX = m_Rec.MaxBound.X + theBallCircle.Radius;

            }

    • This second step is important because we don't want the ball to get caught on the paddle.  For example, if the player moves the paddle over the ball, then the ball will reverse direction, but might not move far enough to move away from the paddle.  On the next update, the ball will again reverse direction, and again not move far enough to be clear of the paddle.  This process will repeat until the ball's vertical movement has taken it outside of the top (or bottom) of the paddle.
  • Finally, we return the value of hit to the calling method, to indicate whether the soccer ball has collided with the paddle or not
    

            return hit;

    • Note that the return value is currently unused.  It's a useful return value to produce, and we may make use of it in future tutorials.

FURTHER EXERCISES:

	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