RSS Feed
Download our iPhone app
Browse DevX
Sign up for e-mail newsletters from DevX


Introducing XNA Game Studio Express : Page 5

Microsoft's XNA Game Studio Express gives you powerful game tools, and the ability to create games for both Windows and Xbox 360.

Counting Hazards Passed
The XNA Framework provides a nice way to display text in a game. To begin the process, you need to add a new item to your project. So right-click on your project and choose Add New Item from the context menu. In the Add New Item dialog box (see Figure 8), select the SpriteFont object. Name it myFont and click Add.

Figure 8: Adding the sprite font to the game project.

Figure 9: Modifying the sprite font XML file.
That adds a new SpriteFont object to your project, which is basically an XML file that provides some information about a system font that you want to use in your game. You'll need to edit that information to indicate which font to use as well as the size and style of the font. Edit the SpriteFont XML file as shown in Figure 9.

To show the count (score) onscreen, add two new objects to the top of the Game1.cs class:

   private int mHazardsPassed;
   private SpriteFont mFont;
The mHazardsPassed integer keeps track of how many hazards a player has passed successfully. The SpriteFont object lets you to load a font into the game, which you can use to write text to the screen.

The code snippet below initializes the number of hazards passed in the StartGame method. That way, every time the user starts or restarts the game, the number of hazards passed resets to 0. Add the following line of code to the StartGame method:

   mHazardsPassed = 0;
Next, load the font into the SpriteFont object in the LoadGraphicsContent method using this code:

   mFont = content.Load<SpriteFont>("myFont");
Every time a hazard scrolls off-screen (meaning the player successfully passed it), you need to increment the mHazardsPassed counter. To do that you'll enhance the UpdateHazard method. You'll also increase the velocity every time the player successfully passes a hazard just to add an extra level of complexity to the game.

Add the following code to the UpdateHazard method within the if block that checks to see if the hazard has exited the viewing area:

   mHazardsPassed += 1;
   mVelocityY += 0.1F;
Finally, this snippet displays the number of hazards the player has passed. Add the following code to the Draw method:

      "Hazards: " + mHazardsPassed.ToString(), 
   new Vector2(5, 25), Color.White, 0, new
      Vector2(0, 0), 
      1.0f, SpriteEffects.None, 0);
Figure 10: Drawing the text to the screen.
Build the game and check your handiwork. As the hazards scroll off the screen, you should see the number in the upper left of the window display the number of hazards (and increase) as shown in Figure 10.

You're almost ready to start making it a little harder to run right over the hazards, but first there's one more concept to add to the game. When working on a game, you reach a point where you realize that—depending on what's going on—you need to display certain things at certain times, but not at others. This brings me to the topic of game state.

Game State
Game state, in its simplest form, is just a way of keeping track of what state your game is in. Complex games may have many states, but this game has only two states: Running and Crash. You'll create an enum to define the various states the game can be in, and an object to indicate which state the game currently is in at the top of the Game1.cs class.

   private enum State
   private State mCurrentState;
When the game starts you initialize the current state to Running in the StartGame method.

   mCurrentState = State.Running;
Next, enhance the Update method to respond to the various states. Using the state information, you'll update certain things only when the game is running:

   KeyboardState aCurrentKeyboardState =
   GamePadState aCurrentGamePadState =
   if (aCurrentKeyboardState.IsKeyDown(Keys.Escape)
      == true || 
      aCurrentGamePadState.Buttons.Back == 
   switch (mCurrentState)
      case State.Running:
         If ((aCurrentKeyboardState.IsKeyDown(Keys.Space) == true && 
            mPreviousKeyboardState.IsKeyDown(Keys.Space) == false) || 
            (aCurrentGamePadState.Buttons.X == ButtonState.Pressed && 
            mPreviousGamePadState.Buttons.X == ButtonState.Released))
            mCarPosition.X += mMoveCarX;
            mMoveCarX *= -1;
      case State.Crash:
   mPreviousKeyboardState = aCurrentKeyboardState;
   mPreviousGamePadState = aCurrentGamePadState;
Basically, the preceding code wraps the existing code in the Update method in a switch block when the current state is Running. The Keyboard state remains outside of the block, but was shown for context.

Currently, the game doesn't do anything when a crash occurs; in fact, there is no way to detect a crash. You'll change that in the next section, but first, quickly build the game just to make sure everything still runs as it should with the newly added game state code.

Close Icon
Thanks for your registration, follow us on our social networks to keep up-to-date