The content pipeline does the work of preparing assets for use within an XNA Framework game. Assets are processed in two steps. The first step is importing the content. For the majority of formats, XNA has Content Importer classes to convert content into a common intermediate format. The second step converts the imported content into a final compiled, compressed, format via a Content Processor.

Importing content is as simple as adding new items to the Content project. In most cases, the content pipeline automatically detects the asset type and assigns the correct Content Importer and Content Processor. It is also possible to create custom Content Importer and Content Processor classes for assets not supported by the built-in classes.

In the Chapter 1 HelloXNA sample we demonstrate how to load content a single texture at a time using this code from the LoadContent method:

HeroShip = this.Content.Load<Texture2D>("Sprites/heroship");
SpaceShip = this.Content.Load<Texture2D>("Sprites/spaceship");
Missile = this.Content.Load<Texture2D>("Sprites/missile");

Each content item is loaded into a single texture. When drawn, each item requires its texture to be loaded by the GPU and rendered. The above items are drawn to the screen with these three lines of code in the Draw method:

spriteBatch.Draw(SpaceShip, SpaceShipPosition, Color.White);
spriteBatch.Draw(Missile, MissilePosition, Color.White);
spriteBatch.Draw(HeroShip, HeroShipPosition, Color.White);

Loading each texture is a performance hit for the GPU. A better way is to load a single texture that contains all of the images, and then just tell Draw which area of the texture to draw for that item. This type of texture is called a sprite sheet and is very common to use in game development, especially when creating sprite animation, which we will cover later in the chapter. There are two challenges with using sprite sheets: you have to take all of your individual images and mash them into a larger image, and you have to remember which part of the single large texture contains the particular image you want to draw to the screen.

Luckily AppHub comes to the rescue again with a ready-to-go custom Content Importer and Content Processor that can take a collection of images and automatically turn them into a single sprite sheet, solving the first challenge. For the complete background on the sample, download it here:

http://create.msdn.com/en-US/education/catalog/sample/sprite_sheet

The sample also includes a runtime class to include in your game named SpriteSheet, which allows either named or indexed access to images so that you do not have to remember the exact pixel location, solving the second challenge listed previously.

We implement the SpriteSheet sample in AlienShooter by copying over the SpriteSheetPipeline and SpriteSheetRuntime (Phone) projects from the AppHub SpriteSheetSample and adding them to the Chapter 7 Solution. Right-click the References folder in the AlienShooterContent project, select Add Reference, choose the Projects tab, and select the SpriteSheetPipeline project. Next, right-click on the References folder in the AlienShooter project and select Add Reference, choose the Projects tab, and select the SpriteSheetRuntime (Phone) project.

In the AlienShooterContent project navigate to the Sprites folder and exclude from the project these assets: heroship.tga, missile.tga, and spaceship.tga. We don't want to add the textures twice, so they should not be included as individual assets any more. Next, right-click on the Sprites folder and select Add | New Item... and choose XML File with a name of AlienShooterSpriteSheet.xml. Listing 7-3 shows the edited XML file.

<?xml version="1.0" encoding="utf-8" ?>
<XnaContent>
  <Asset Type="System.String[]">
    <Item>Sprites/heroship.tga</Item>
    <Item>Sprites/missile.tga</Item>
    <Item>Sprites/spaceship.tga</Item>
  </Asset>
</XnaContent>

If you don't edit the file correctly, you will get a compile error if the SpriteSheetPipeline Content Processor cannot find an asset listed in the XML file. Notice in this example that the folder location is included relative to the AlienShooterContent project to correctly identify the asset location. Figure 7-3 shows the Solution tool window with the AlienShooterContent project expanded and the Properties dialog for the AlienShooterSpriteSheet.xml.

Notice in Figure 7-3 that the individual sprite images are hidden and not part of the project in the Sprites folder, though they need to be accessible in the file system to the SpriteSheetProcessor Content Processor so that it can turn them into a single sprite sheet. The only content that is part of the Sprites folder is the AlienShooterSpriteSheet.xml XML file. Also in Figure 7-3, notice that the custom SpriteSheetProcessor Content Processor is configured for the XML file. Let's now draw update the GamePlay screen to start to render our new AlienShooter assets. A using SpriteSheetRuntime statement is added to the top of the GamePlay.cs code file. Three new private fields are added at the top of the GamePlayScreen class:

SpriteSheet alienShooterSpriteSheet;
Texture2D backgroundTexture;
Rectangle screenRect;

The alienShooterSpriteSheet variable will let us render the entire sprite sheet to the screen for debug purposes. The backgroundTexture variable represents our game background as with the HelloXNA sample and the screenRect variable holds a variable that points to the Rectangle object that is the size of the draw area.

Figure 7.3. Solution and Content project after SpriteSheet modifications

The LoadContent method is updated to load the alienShooterSpriteSheetSpriteSheet and backgroundTextureTexture2D variables:

alienShooterSpriteSheet = content.Load<SpriteSheet>("Sprites/AlienShooterSpriteSheet");
backgroundTexture = content.Load<Texture2D>("Textures/background");

Most of the code in the Update and HandleInput methods is commented out since we no longer want the place holder code. The placeholder draw code is modifiedin theDraw method, and the following two additional items are added to draw the backgroundTexture and the alienShooterSpriteSheet to the screen:

spriteBatch.Begin();
//Draw background
spriteBatch.Draw(backgroundTexture, screenRect, Color.White);
//Draw Sprite Sheet
spriteBatch.Draw(alienShooterSpriteSheet.Texture,
  new Rectangle(screenRect.Width / 2, screenRect.Height / 2,
                alienShooterSpriteSheet.Texture.Width / 2,
                alienShooterSpriteSheet.Texture.Height / 2),
    Color.White);
spriteBatch.End();

Everything should compile and the game now shows AlienShooter assets on the GamePlayScreen, as shown in Figure 7-4.

Figure 7.4. AlienShooter SpriteSheet and background textures

Notice how tightly the Hero Spaceship, Missile, and Alien Ship are automatically packed in Figure 7-4 by the custom Content Processor. Just to close the loop, the code to draw an individual image from the AlienShooterSpriteSheet is very simple. Here is the code to just draw the Hero Spaceship at a point in the middle of the screen:

spriteBatch.Draw(alienShooterSpriteSheet.Texture,
    new Vector2((screenRect.Width / 2)-
                alienShooterSpriteSheet.SourceRectangle("heroship").Width / 2,
                          (screenRect.Height / 2)-
                alienShooterSpriteSheet.SourceRectangle("heroship").Height / 2),
    alienShooterSpriteSheet.SourceRectangle("heroship"),

There is a verbose computation to create a Vector2 for the screen center minus the center of the Hero Ship, but otherwise it is the standard Draw(texture, Vector, SourceRectangle, Color) method. Notice how easy it is to identify the Rectangle on the alienShooterSpriteSheet where the Hero Ship resides. Just pass in the asset name and the SpriteSheet class will locate it. More on drawing later in the chapter, but I wanted to close out how to completely work with the SpriteSheet class.

When you download the SpriteSheet Sample from AppHub, it includes an example extension on how to add a compression option to the Content Processor. Unfortunately the extension does not work for the XNA Game Studio 4.0 Reach profile. It just works for the HiDef profile.

We dive into creating a more robust game below but first let's cover some of the other constructs for a real game such as displaying game status text and menus, which is covered in the next section.

The SpriteFont class takes a built in font and rasterizes it based on configuration parameters. To add a text Font for rendering in XNA Game Studio, right-click on the FontsSampleContent project and select Add

While we take fonts for granted when working in Microsoft Word or in Outlook, fonts are licensed content. You must have redistribution rights to include a font in your game. Search the Web for "purchase fonts online" and quite a few sites show up. Some include free fonts with others for purchase.

Luckily XNA Game Studio 4.0 includes a set of OpenTypefonts you can use in your games. Figure 7-5 shows the fonts that are licensed by Microsoft for your use. The image is taken from the AppHub education catalog.

Figure 7.5. Fonts provided by XNA Game Studio for use in XNA framework games

For our sample, name the new Sprite Font item SegoeKeycaps24 and click Add. A new item named SegoeKeycaps16.spritefont is added to the FontSampleContent project. What may surprise you is that the SegoeKeycaps16.spritefont file is an XML file. Listing 7-4 shows the contents of the newly added file.

<?xml version="1.0" encoding="utf-8"?>
<XnaContent xmlns:Graphics="Microsoft.Xna.Framework.Content.Pipeline.Graphics">
  <Asset Type="Graphics:FontDescription">
    <FontName>Segoe UI Mono</FontName>
    <Size>14</Size>
    <Spacing>0</Spacing>
    <UseKerning>true</UseKerning>
    <Style>Regular</Style>
    <!-- <DefaultCharacter>*</DefaultCharacter> -->
    <CharacterRegions>
      <CharacterRegion>
        <Start>&#32;</Start>
        <End>&#126;</End>
      </CharacterRegion>
    </CharacterRegions>
  </Asset>
</XnaContent>

The XML file describes the parameters for what should be rendered when text is drawn using this SpriteFont. For our example, change the FontName element to Segoe Keycaps. Change the Size to 16 and leave everything else at the default values.

You can edit the Spacing element to increase the space between characters, as well as modify the UseKerning item to modify how the font is laid out. Kerning adjusts the spacing between characters to be more pleasing to the eye. An example of kerning is when a capital "W" overhangs a neighboring "e" slightly when typing the word "Well." Without kerning, letters do not overhang or underhang as the case may be. The Style element indicates whether it should be Regular, Bold, or Italic.

The last element to discuss is the CharacterRegions element. CharacterRegions element controls what letters are available in the font. The default range is 32 (ASCII space) to 126 (ASCHII '~'). This reduces the number of characters rasterized as part of the content import process.

To draw the SegoeKeycaps16 Sprite Font, add a new private member named segoeKeycaps16 of type SpriteFont to the Game1 class in the FontSample project. Next add this line of code to the Game1.LoadContent method:

segoeKeycaps16 = Content.Load<SpriteFont>("SegoeKeycaps16");

We used the SpriteBatch.Draw method to draw textures to the screen. The SpriteBatch.DrawString method has six overloads to provide flexibility in drawing text to the screen. Here are a couple of examples:

spriteBatch.DrawString(segoeKeycaps24, text, new Vector2(24, 130), Color.Yellow);

spriteBatch.DrawString(segoeKeycaps24, text, new Vector2(24, 450), Color.Orange,
    -.25f * (float)Math.PI, Vector2.Zero, 3, SpriteEffects.None, 0);

You can tinge the font color by adjusting the fourth parameter with a color value such as Color.Yellow. The second DrawString call above applies a –negative 45 degree rotation in the fifth parameter and a 300 percent scale in the sixth parameter, with an orange tinge applied to the Sprite Font. Another font is added to the project named Miramonte with Italics style and a few more DrawString calls are in the code but Figure 7-6 shows the results.

Figure 7.6. DrawString examples with the SpriteFont class

The scaled font renders pretty well but you can see some stretching in the letter "e" in Figure 7-6 that could be more obvious with other fonts. In the next section we cover how to create a bitmap font.

Bitmap fonts are not dependent on a built-in font. Instead, the fonts are loaded from a texture similar to what is shown in Figure 7-7.

Figure 7.7. Bitmap font texture example

The example in Figure 7-7 was copied from MSDN by zooming in the browser by 200% and taking a screenshot, but you can create a custom bitmap font texture using any drawing program by following the conventions specified in the documentation.

The character order matters, with a space as the upper-left character. You can use a solid white or black background color for monochrome characters. In the previous example, black is used as the background color. Multicolored characters are supported with an alpha channel.

The space between characters must be filled with Magenta color (Red:255 Green:0 Blue:255 Alpha:255). The FontTextureProcessor class is applied to the texture instead of the default processor. The FontTextureProcessor will pack the characters in as close as possible so you don't have to worry about exact spacing between characters.

A new project named BitmapFontSample is added to the Chapter 7 solution. The bitmap font texture in Figure 7-7 is added to the BitmapFontSampleContent project with a name of BitmapFont.bmp. The Content Processor is configured to Sprite Font Texture - XNA Framework from the default of Texture - XNA Framework.

The SpriteFont class is still used as the member type for the bitmapFont object and the bitmap font is loaded in LoadContent just like for a regular SpriteFont content:

SpriteFont bitmapFont;
...//Load Content
bitmapFont = Content.Load<SpriteFont>("BitmapFont");

Drawing is the same as well with the DrawString method:

spriteBatch.Begin();
spriteBatch.DrawString(bitmapFont, text, new Vector2(24, 70), Color.White);
spriteBatch.End();

In summary, the primary differences when using a custom bitmap font is that you must draw out the characters correctly in the proper order and you configure the Content Processor to Sprite Font Texture - XNA Framework for the bitmap font texture.

The MenuScreen class is part of the GameStateManagementSample (Phone) sample project. It is the base class for the MainMenu.cs and OptionsMenu.cs screen objects that are part of the AlienShooter game project.

The MenuScreen class takes advantage of a helper class named MenuEntry, which draws the text and publishes a Selected event. The MenuEntry class does not detect the touch. Instead, the MenuScreen does most of the work to draw, detect a touch, and associate the touch with the correct MenuEntry item. A good way to understand how this works is to look at the constructor for the MainMenuScreen class:

public MainMenuScreen()
    : base("Main Menu")
{
    // Create our menu entries.
    MenuEntry playGameMenuEntry = new MenuEntry("Play Game");
    MenuEntry optionsMenuEntry = new MenuEntry("Options");

    // Hook up menu event handlers.
    playGameMenuEntry.Selected += PlayGameMenuEntrySelected;
    optionsMenuEntry.Selected += OptionsMenuEntrySelected;

    // Add entries to the menu.
    MenuEntries.Add(playGameMenuEntry);
    MenuEntries.Add(optionsMenuEntry);
}

The MainMenuScreen class creates the menu entries and associates event handlers with the menu entries. The base class MenuScreen handles the animation and positioning. A developer can customize the animation and layout by modifying the base MenuScreen class.

One way to customize the menu screens is to change the Font in the AlienShooterContent project. Open the /GameManagement/menufont.spritefont file and change the FontName element to Quartz MS from Figure 7-5 and change the Size to 24. The font has a science fiction look to it, which suites a game named AlienShooter pretty well.

We also modify the GamePlayScreen class to have Score and Lives text across the top with a SlateBlue color background. This is achieved via the SpriteBatch.DrawString method as well as adjusting the background color to SlateBlue and drawing the backgroundTexture 34 pixels lower via the added backgroundPosition Vector2 object. Figure 7-8 shows both the updated menu screen and game play screen.

Figure 7.8. Updated Menu and Game screens for AlienShooter

When you run the project on a device, the animations and transitions look pretty nice. These can certainly be customized as well once you understand how to create animations and transitions in XNA Game Studio. We cover both topics in detail to create the actual game play.

The GameObject class has quite a few public properties declared that are used to animate the sprite and to hold information on Sprite such as the center point, position, velocity and rotation. Here are the declarations:

public SpriteSheet SpriteAnimationSpriteSheet { get; set; }
public string SpriteName { get; private set; }
public int NumberOfAnimationFrames { get; set; }
public TimeSpan FrameTime { get; set; }
public TimeSpan ElapsedFrameTime { get; set; }
public Vector2 SpriteCenter { get; set; }
public bool Alive { get; set; }
public Vector2 Position { get; set; }
public Vector2 Velocity { get; set; }
public float Rotation { get; set; }

There is an additional property related to collision detection that we will cover next.

The BoundingRect property of type Rectangle is used to return the Rectangle area that contains the sprite on screen. This property is used for collision detection. If you have ever played a video game where the objects seemed to touch but nothing happen, it is a result of imperfect collision detection, as shown in Figure 7-12 where a regular shaped object, like a rectangle, is used to define the area of an irregularly shaped object.

Figure 7.12. Bounding box collision detection

There are more than a few algorithms for sprite collision detection that can be found in books focused on the topic that range in accuracy from bounding rectangles to resource intensive point by point comparison. Probably the best answer lies somewhere in-between those extremes, such as using more than one bounding box or only performing point-by-point comparison on sides that could collide, and so on. For our purposes, we check for intersection using the BoundingRect property defined in GameObject:

public virtual Rectangle BoundingRect
{
  get
  {
    return new Rectangle((int)Position.X, (int)Position.Y,
      SpriteAnimationSpriteSheet.SourceRectangle(SpriteName + 0).Width,
      SpriteAnimationSpriteSheet.SourceRectangle(SpriteName + 0).Height);
  }
}

One trick to that you can use to adjust collision detection is to call the Inflate(horizontalAmount,verticalAmount) method to individually increase or decrease (with a negative value) the sides of the Rectangle to better match the object shape.

The rest of the GameObject class contain its individual methods to reset its position if the object flies off the screen, update the object state, and draw the object to screen. Methods are marked with the virtual keyword so that they can be overridden in inherited classes as needed:

public virtual void ResetGameObject()
{
  Position = Vector2.Zero;
  Velocity = Vector2.Zero;
  Alive = false;

}

public virtual void Update(GameTime GameTime)
{
  if (Alive)
  {
    Position += Velocity;
    //Check screen bounds
    if ((Position.X < 0) ||
        (Position.X > _screenRect.Width) ||
        (Position.Y < 0) ||
        (Position.Y > _screenRect.Height))
      ResetGameObject();
    //Update animation
    UpdateAnimation(GameTime);
  }
}

private void UpdateAnimation(GameTime gameTime)
{
  ElapsedFrameTime += gameTime.ElapsedGameTime;
  if (ElapsedFrameTime > FrameTime)
  {
    if (_spriteIndex < NumberOfAnimationFrames - 1)
      _spriteIndex++;
    else _spriteIndex = 0;
    ElapsedFrameTime = TimeSpan.FromMilliseconds(0d);
  }
}

public virtual void Draw(GameTime gameTime, SpriteBatch spriteBatch)
{
  if (Alive)
  {
    spriteBatch.Draw(SpriteAnimationSpriteSheet.Texture, Position - SpriteCenter,
      SpriteAnimationSpriteSheet.SourceRectangle(SpriteName + _spriteIndex.ToString()),
      Color.White);
  }
}

The ResetGameObject is called when an object is "destroyed" or flies off the screen. The method is pretty simple in just setting Position and Velocity to a zero vector and Alive to false.

The Update method checks to see if the object is Alive before updating Position by adding Velocity to it and then checking screen bounds. The Update method also calls the UpdateAnimation method, which leverages the code we developed in the SpriteAnimation sample. Finally, the Draw method simply applies the same logic we used in the SpriteAnimation sample to draw the correct frame to screen as part of the animation sequence.

Now that we have our base class out of the way, we move on to cover the enemy alien class and then move on to the user controlled hero ship and missile classes.

By default, the Game Management sample does not include support for Accelerometer input. The GamePlayScreen class has a HandleInput method that takes a parameter of type InputState, which is a class that captures keyboard, controller, and touch input. It does not capture Accelerometer input by default. In the source code for the book, you will find a modified InputState class, as well as a new class named AccelerometerState, which is shown in Listing 7-6.

public class AccelerometerState
{
  public double X;
  public double Y;
  public double Z;
  public DateTimeOffset Timestamp;
}

The modifications to the InputState class are pretty straightforward:

//robcamer - Add a private instance of AccelerometerState
public AccelerometerState CurrentAccelerometerState { get; private set; }
//robcamer - Add private field for the accelerometer
private Accelerometer accelerometer;

The constructor for the InputState class is modified to instantiate the previous two private variables, as well as add an event handler to the Accelerometer:

CurrentAccelerometerState = new AccelerometerState();
//Robcamer - initialize accelerometer
accelerometer = new Accelerometer();
accelerometer.ReadingChanged +=
  new System.EventHandler<AccelerometerReadingEventArgs>(accelerometer_ReadingChanged);
accelerometer.Start();

The values of CurrentAccelerometerState are updated in the accelerometer_ReadingChanged event handler:

void accelerometer_ReadingChanged(object sender, AccelerometerReadingEventArgs e)
{
  CurrentAccelerometerState.X = e.X;
  CurrentAccelerometerState.Y = e.Y;
  CurrentAccelerometerState.Y = e.Z;
  CurrentAccelerometerState.Timestamp = e.Timestamp;
}

Now that we have the modifications in place for the InputState class, two private fields related to user input are added to the UserGameObject class.

private AccelerometerState _accelerometerState;
private Vector2 _leftRightVector = new Vector2(5, 0);

The _accelerometerState and _leftRightVector fields are modified in the UserGameObject.HandleInput method.

public void HandleInput(InputState input)
{
  //Must check for TouchLocationState as wel as Count
  //Otherwise, FireMissile will be called twice

//Once for 'Pressed' and once for 'Released'
  if ((input.TouchState.Count > 0) &&
    input.TouchState[0].State == TouchLocationState.Pressed)
  {
    FireMissile();
  }

  _accelerometerState = input.CurrentAccelerometerState;
  if (_accelerometerState.X > .1)
  {
    Velocity = _leftRightVector;
  }
  if (_accelerometerState.X < -.1)
  {
    Velocity = -_leftRightVector;
  }
  //near Zero tilt left or right so
  //set velocity to zero
  if ((_accelerometerState.X < .1) &&
    (_accelerometerState.X > -.1))
    Velocity = Vector2.Zero;
}

If the _accelerometerStateX component is greater than .1, a positive or negative velocity is applied to the Velocity vector via the leftRightVector variable in the proper tilt direction. Likewise, if the user holds the phone close to neutral, Velocity is set to zero. If you don't like how it responds, play with the .1 value to see what feels good to you.

The other part of the HandleInput session is to detect if the screen is touched. Each touch fires to TouchState values, one for TouchLocationState.Pressed and one for TouchLocationState.Released. If the screen is touched the FireMissile method is fired.

The UserGameObject class manages a collection of Missile objects since they are closely associated with the hero ship:

public List<MissileGameObject> Missiles;
public int MaxNumberofMissiles;

The Missile related properties are public properties because the GameplayScreen will need to check collisions between missiles and enemy alien ships. Also, the number of available missiles could be adjusted dynamically as part of game play for a "blitz" mode, where the hero ship can fire more than three at a time as an example. The Missiles collection is instantiated in the UserGameObject constructor:

MaxNumberofMissiles = 3;
Missiles = new List<MissileGameObject>();
for (int i=0;i < MaxNumberofMissiles; i++)
  Missiles.Add(new MissileGameObject(loadedTexture,"missile",screenRect));

When the screen is touched, the FireMissile method code searches for an available missile. Only three are available by default, and sets the missile property to Alive and the MissilePosition property to the same Position value for the hero ship / UserGameObject class. Note that once the Missile is set to Alive, it automatically starts moving based on the default logic implemented in the GameObject class.

The UserGameObject class overrides the Update method with custom code to position the spaceship correctly with user input. It also manages the Missiles collection by calling Update for missiles where Alive is true, i.e., they are in flight. Here is the UserGameObject.Update method:

public override void Update(GameTime gameTime)
{
  base.Update(gameTime);

  if (Position.X < SpriteCenter.X)
    Position = new Vector2(SpriteCenter.X,Position.Y);
  if (Position.X > (_screenRect.Width - SpriteCenter.X))
    Position = new Vector2(_screenRect.Width-SpriteCenter.X,Position.Y);


  for (int i = 0; i < MaxNumberofMissiles; i++)
  {
    if (Missiles[i].Alive == true)
      Missiles[i].Update(gameTime);
  }
}

The Draw method is overridden as well:

public override void Draw(GameTime gameTime, Microsoft.Xna.Framework.Graphics.SpriteBatch spriteBatch)
{
  for (int i = 0; i < MaxNumberofMissiles; i++)
  {
    if (Missiles[i].Alive == true)
      Missiles[i].Draw(gameTime, spriteBatch);
  }
  base.Draw(gameTime, spriteBatch);
}

The Draw method checks to see if each Missile is Alive and then calls Draw for the Missile object. The last item in the UserGameObject class to cover is the LoadContent method. In this method, the ContentManager instance is passed in so that the UserGameObject can make a sound effect when a missile is fired from the hero ship. Here is the method:

public void LoadContent(ContentManager content)
{
  _missileLaunchSoundEffect =
                content.Load<SoundEffect>("SoundEffects/MissileLaunch");
}

XNA Game Studio has very rich audio mixing capabilities to support Dolby quality sound. For our game the SoundEffect class provides a quick and easy way to play audio during a game with the Play method. We add three sound effects to the AlienShooterContent project in the SoundEffects folder:

One item to note is that I recorded the sounds using the Windows 7 Recorder tool, which generates a .wma file. When added to the Content project the XNA Framework automatically chose the Song - XNA Framework Content Processor. This format cannot be played by the SoundEffect class. Simply change the Content Processor to Sound Effect - XNA Framework and the audio plays fine.

Let's now move on to a discussion of the Missile class.

Each time a hero ship missile intercepts an alien space ship, 5 points are added to the GameStatusBoard.Score property. The Score property is modified in the GamePlay screen, which we cover later. Within the GameStatusBoard class, updating the score results in a SoundEffect.Play call for the Explosion.wma file:

public int Score
{
  get { return _score; }
  set
  {
    _score = value;

_alienExplosionSoundEffect.Play();
  }
}

The GameStatusBoard.Update method has a switch statement to display a message based on current score:

switch (Score)
{
  case 50: _displayMessage = true;
    _message = "Nice Start!";
    break;
  case 60: _displayMessage = false;
    break;
  case 100: _displayMessage = true;
    _message = "Keep It Up!";
    break;
  case 120: _displayMessage = false;
    break;
  default: break;
}

When the _displayMessage field is true based on score, GameStatusBoard.Draw displays the message in the Status Board with this call:

if (_displayMessage)
  spriteBatch.DrawString(_gameFont, _message, new Vector2(175, 0),
    _livesTextColor);

That's it for score keeping. We next cover tracking hero ship lives and game over functionality.

Be default, when playing the Alien Shooter game, you get 3 lives to start. Each time an alien ship intersects the hero ship, a life is deducted. At 2 lives a message of "Warning!" is displayed. At 1 life, a message of "Danger!" is displayed. Finally, when zero lives are the state, a "Game Over!" message is displayed at top and in the middle of the screen. Also, each time a live is deducted, the phone is briefly vibrated. Here is the declaration and instantiation of the VibrateController class:

private VibrateController _vibrateController = VibrateController.Default;
private TimeSpan _vibrateTimeSpan = TimeSpan.FromMilliseconds(400);

Here is the Lives property where the sound is played and phone vibrated when the Lives property is modified:

public int Lives
{
  get { return _lives; }
  set
  {
    _lives = value;
    _heroShipDamageSoundEffect.Play();
    _vibrateController.Start(_vibrateTimeSpan);
  }
}

Here is the code from the GameStatusBoard.Update method that determines what message to display, and in what color:

switch (_lives)
{
  case 3: _livesTextColor = Color.LightGreen;
          break;
  case 2: _livesTextColor = Color.Yellow;
          _displayMessage = true;
          _message = "Waring!";
          break;
  case 1: _livesTextColor = Color.Red;
          _displayMessage = true;
          _message = "Danger!";
          break;
  case 0: _livesTextColor = Color.Red;
          _displayMessage = true;
          _message = "Game Over!";
          GameOver = true;
          break;
}

Here is the corresponding code from the GameStatusBoard.Draw method that determines when to display a message about the hero ship help on the screen:

if (_displayMessage)
  spriteBatch.DrawString(_gameFont, _message, new Vector2(175, 0),
    _livesTextColor);
if (GameOver)
  spriteBatch.DrawString(_gameFont, _message, new Vector2(175, 370),
    _livesTextColor);

Having an informative game status board is an important component of any game development effort. This section covered how simple it is to provide the basics. In the next section, we cover the overall logic in the GamePlayScreen class that pulls together all of the game objects we just covered.

Now we are ready to modify the GameplayScreen class to manage the game objects. We declare the object instances needed:

//Game objects
GameStatusBoard statusBoard;
List<AlienGameObject> enemies;
int maxEnemies = 5;
UserGameObject heroShip;
int maxMissiles = 3;

//Indicates to draw game over frame;
bool drawGameOverFrame = false ;

The maxMissiles and maxEnemies variable are not a constant because we may want to change it dynamically during the game as part of the game play. Otherwise, one UserGameObject named heroShip and a List of AlienGameObjects are the other key components of the game. Another potential modification would be to increase the number of AlienGameObjects in the game as the score gets higher to make it more interesting. Otherwise a player will get bored if nothing changes.

Next we load and initialize assets in LoadContent():

public override void LoadContent()
{
  if (content == null)
    content = new ContentManager(ScreenManager.Game.Services, "Content");

  gameFont = content.Load<SpriteFont>("gamefont");
  alienShooterSpriteSheet = content.Load<SpriteSheet>("Sprites/AlienShooterSpriteSheet");
  backgroundTexture = content.Load<Texture2D>("Textures/background");
  backgroundPosition = new Vector2(0, 34);
  //Get a pointer to the entire screen Rectangle
  screenRect = ScreenManager.GraphicsDevice.Viewport.Bounds;

  //Initialize Enemies collection
  enemies = new List<AlienGameObject>();
  for (int i = 0; i < maxEnemies; i++)
  {
    enemies.Add(new AlienGameObject(alienShooterSpriteSheet, "spaceship", screenRect));
  }

  //Initialize Player Object
  heroShip = new UserGameObject(alienShooterSpriteSheet, "heroship", screenRect, maxMissiles);
  heroShip.Position = new Vector2(screenRect.Width / 2, 720);
  heroShip.LoadContent(content);

  //Initialize Status Board
  statusBoard = new GameStatusBoard(gameFont);
  statusBoard.LoadContent(content);

  // A real game would probably have more content than this sample, so
  // it would take longer to load. We simulate that by delaying for a
  // while, giving you a chance to admire the beautiful loading screen.
  Thread.Sleep(1000);

  // once the load has finished, we use ResetElapsedTime to tell the game's
  // timing mechanism that we have just finished a very long frame, and that
  // it should not try to catch up.
  ScreenManager.Game.ResetElapsedTime();
}

By breaking out our game assets into objects it greatly unclutters the code in GameplayScreen class. As an example, initializing the enemies object is a matter of passing in the texture information for the animations:

//Initialize Enemies collection
enemies = new List<AlienGameObject>();

for (int i = 0; i < maxEnemies; i++)
{
  enemies.Add(new AlienGameObject(alienShooterSpriteSheet, "spaceship", screenRect));
}

Addingsupport for the heroShip and the AlienGameObject to the GameplayScreen.Update method is pretty straightforward now that we have nice objects that manage work for us:

public override void Update(GameTime gameTime, bool otherScreenHasFocus,
                                                bool coveredByOtherScreen)
{
  if (IsActive)
  {
    if (!statusBoard.GameOver)
    {
      CheckForCollisions();

      heroShip.Update(gameTime);
      statusBoard.Update(gameTime);

      for (int i = 0; i < maxEnemies; i++)
      {
        enemies[i].Update(gameTime);
      }
    }
  }
  base.Update(gameTime, otherScreenHasFocus, coveredByOtherScreen);
}

If StatusBoard.GameOver is not true, i.e. the hero ship has lives available, the game action continues. Otherwise, the code is straightforward, calling Update for each object. Notice the call to the CheckForCollisions method. We cover collision detection in the next sub section.

Adding support for user input is just as easy by adding a call to heroShip.HandleIpnut(input) just after the else in the GameplayScreen.HandleInput method. For the GameplayScreen.Draw method the Draw method is called for each object. If StatusBoard.GameOver is true, the Draw method is not called for the enemies any further and the game is over.

public override void Draw(GameTime gameTime)
{
  ScreenManager.GraphicsDevice.Clear(ClearOptions.Target,
                                      Color.SlateBlue, 0, 0);

  // Our player and enemy are both actually just text strings.
  SpriteBatch spriteBatch = ScreenManager.SpriteBatch;

  spriteBatch.Begin();
  //Draw Background
  spriteBatch.Draw(backgroundTexture, backgroundPosition, Color.White);
  //Draw Status Board
  statusBoard.Draw(gameTime, spriteBatch);
  //Draw Hero Ship
  heroShip.Draw(gameTime, spriteBatch);

//Draw enemies
  if (!statusBoard.GameOver)
  {
    for (int i = 0; i < maxEnemies; i++)
    {
      enemies[i].Draw(gameTime, spriteBatch);
    }
  }
  spriteBatch.End();

  // If the game is transitioning on or off, fade it out to black.
  if (TransitionPosition > 0)
    ScreenManager.FadeBackBufferToBlack(1f - TransitionAlpha);
}