OOP: Constructor with parameters ;
Null references

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 parameter
• Left thumb stick move the spot, A to create, Right thumb stick to roll

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 left thumbstick controls the pink/blue 'spot' on the screen (shown here near the bottom of the screen, beneath the soccerball).  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.  Note that when there's no soccerball on the screen, rolling the soccer ball does nothing.  While this seems like a minor, obvious point, it's important that the program not crash when the user attempts to roll the non-existent soccerball.  This is fairly easy to implement, but a very important detail to keep in mind.

2. SoccerBall.cs:

The code in this class is almost exactly the same as the prior tutorial.  The only two differences are that

1. The constructor now has a parameter, that allows the code in the Game1 class to specify where to create the new SoccerBall, and
2. Because the Game1 class now says where to create the soccerball, the INIT_X and INIT_Y constants have been moved into that class.

• UpdateWorld():

  /// <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";     }

  • As you can see, the constructor for the SoccerBall class now takes a single parameter: Vector2 centerPosition.  This gets passed along to the constructor for the XNACS1Circle, thus ensuring that the new SoccerBall object's image is created at centerPosition.

2. Game1.cs:

There are several changes that are being made here:

1. The named constants INIT_X and INIT_Y are moved to this file from SoccerBall.cs.  We also add the SPOT_RADIUS constant to this file, so that we'll have a well-define radius for the on-screen spot.
2. We'll add code to track where the spot is.  It'll start the program centered at (INIT_X, INIT_Y), and will be controlled by the left thumbstick.  Since you've seen this in previous tutorials, we won't go through any of the details here.
3. The Game1 object's reference to the SoccerBall object will start out with the special value null, meaning that there is no SoccerBall (yet).  The program will not crash if the user attempts to roll the non-existent SoccerBall object.
4. When the 'A' button is pushed, the old soccer ball is destroyed, and a new SoccerBall object is created whereever the spot currently is.  If there is already a SoccerBall object on the screen, it's discarded (and removed from the list of things that the XNACS1 library should draw)

• InitializeWorld():

  protected override void  InitializeWorld()     {         World.SetWorldCoordinate(new Vector2(0, 0), 100.0f);           // Initially only the spot         m_TheBall = null;         m_TheSpot = new XNACS1Circle(new Vector2(INIT_X, INIT_Y), SPOT_RADIUS);     }

  • You'll notice that m_TheSpot is initialized so that it refers to a new XNACS1Circle object, centered at (INIT_X, INIT_Y).
  • Notice that m_TheBall is NOT assigned a reference to an object.  Instead, we assign it the special value null:
    

            m_TheBall = null;

    
    null is a special value, used to indicate that m_TheBall does not refer to an actual, valid object.  You can check if m_TheBall (or any other reference (including references to strings and arrays) ) is null using an if statement, like:
    

        if (m_TheBall == null)

        {

             // Do something if there's no soccer ball

        } 

• UpdateWorld():

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

  • The UpdateWorld method is listed above.  Anything that's unchanged from the previous tutorial, or that pertains to the basic 'spot' functionality, is grayed out.
  • Starting from the bottom, we have the code that will attempt to roll the soccer ball, but only if the SoccerBall object already exists!
    • We see if there's already a SoccerBall object by asking if m_TheBall is not null:
      
              if (null != m_TheBall)
      • If m_TheBall is not null (which only happens when we currently have a SoccerBall object on the screen), the above check will be true, and therefore we'll call RollTheSoccer on the SoccerBall
      • If m_TheBall is null (which only happens when we do NOT have a SoccerBall object on the screen - this only happens at the start of the program, before the user has pushed the 'A' button), the above check will be false, and therefore we'll skip the call to RollTheSoccer.
  • Above that code, we have the code to remove the old SoccerBall (if there is one), and to create another SoccerBall object, but only when the user presses the 'A' button:
    

            if (GamePad.ButtonAClicked())

            {

                if (null != m_TheBall)

                    m_TheBall.RemoveFromDraw();
    

                m_TheBall = new SoccerBall(m_TheSpot.Center);

            }

    • You'll notice that we want to avoid crashing the program (which would happen if we executed the m_TheBall.RemoveFromDraw();
       statement), so we'll use the same trick that we did for rolling the soccer ball: we will only remove the soccer ball object if there currently is one:
      

             if (null != m_TheBall)

                      m_TheBall.RemoveFromDraw();
      

    • Regardless of whether there's currently a soccer ball, we now want to create a new one:
      

                  m_TheBall = new SoccerBall(m_TheSpot.Center);

      • Notice that we pass (as an argument) the Vector2 that holds the current center point of the spot into the constructor for the SoccerBall object.  This will ensure that when we create the image for the soccer ball, it will appear where the spot currently is.

FURTHER EXERCISES:: 

1. In the code listed below, remove the if statement (for example, comment it out), compile and run the program, and see what error message you get:
   

           if (null != m_TheBall)

               m_TheBall.RollTheSoccer(GamePad.ThumbSticks.Right.X);

2. In the code listed below, remove the if statement (for example, comment it out), compile and run the program, and see what error message you get:
   

               if (null != m_TheBall)

                   m_TheBall.RemoveFromDraw();

	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