All computer games require a means of interacting with players, whether it is through gamepads, a keyboard, a mouse, or some combination of devices. XNA provides programmers with several classes designed to support interaction with various input devices. These classes include the GamePad, Keyboard, and Mouse classes, which as you can guess, provide access to methods and properties that let you interact with gamepads, keyboard, and the mouse. These classes are all made available through the Microsoft.Xna.Framework.Input namespace.

Input devices are made up of two different types of controls, digital and analog. A digital control is one that reports either of two states (on or off). These states are represented by Boolean values of true or false. For example, the gamepad’s X, Y, B, A, Back, and Start buttons are all digital controls. Likewise, the buttons on a Zune player, mouse, and all of the keys on a keyboard are also digital controls.

Analog controls differ from digital controls in that they report a range of values. Examples of analog controls include the gamepad thumbpads and the movement of the mouse.

Gamepads are excellent game controllers. Both the Xbox 360 and Windows computers can support as many as four gamepad controllers at a time. The gamepad consists of a collection of analog and digital controls, in the forms of buttons, thumbsticks, and a Dpad. This collection of controls makes the gamepad an excellent controller for playing most types of games.

Figure 7.1 shows the collections of controls provided by a gamepad controller.

Figure 7.1. The gamepad controller can collect player input via an assortment of buttons, two thumbsticks, and a Dpad.

Once a connection is established to a gamepad, XNA can interact with it in both directions, retrieving data from it and sending instructions to it. Data retrieved from a gamepad includes coordinate data supplied by thumbsticks, as well as state information provided by button presses. Conversely, you can enable the vibration on gamepad controllers in order to provide game feedback to players.

Gamepad data is provided in XNA applications via the GamePadState class. The GamePadState class is used in conjunction with the GamePad class to set up connections to gamepad controllers. The GamePad class has a method called Get-State() which is used to retrieve the state information from a gamepad controller. When called, you must pass the GetState() method a parameter identifying the gamepad being referenced, as demonstrated here:

GamePadState gamePadOne = GamePad.GetState(PlayerIndex.One);

if(pad1.Buttons.Start == ButtonState.Pressed)
{
    //Do something here
}

Thumbstick Controls

Gamepads have two thumbstick controls, referred to as the left thumbstick and the right thumbstick. As depicted in Figure 7.2, these thumbsticks generate floating-point values in the range of –1 to 1 on both their X and Y coordinates when pressed by the player.

Figure 7.2. A depiction of the range of values returned by thumbstick controls.

In addition to assisting you in acquiring state data for gamepad buttons, the GamePadState structure also lets you use its ThumbSticks property to retrieve data for both the left and right thumbstick controls. For example, the following statements establish a reference to a gamepad and then retrieve data from the gamepad’s left thumbstick.

GamePadState gamePadOne = GamePad.GetState(PlayerIndex.One);
paddle.X = paddle.X + (5 * gamePadOne.ThumbSticks.Left.X);

The thumbpad data is used in a calculation that adjusts the location of an object named paddle by 5 pixels along the x-axis, as might be done as part of a breakout style game. Note that to reference the left thumbstick, you must specify the object representing the gamepad (gamePadOne) and then using dot notation you must specify the ThumbSticks property, followed by either Left or Right (depending upon which thumbstick you want to work with) and then X, representing the X coordinate.

Hint

Note that in this previous example, the X coordinate value returned from the left thumbstick’s X coordinate is multiplied by 5 (pixels). So, if the player were pushing the thumbstick all the way to the right, X would be equal to 1 and when multiplied by 5 the result would be 5. A value of 5 is then added to the current X coordinate belonging to the paddle object, moving it 5 pixels to the right. If, on the other hand, the player was pressing the thumbstick halfway to the left, a value of .5 would be multiplied by 5, yielding a value of 2.5, which would then be added to the object’s current X coordinate, moving it 2.5 pixels to the left.

GamePadState pad1 = GamePad.GetState(PlayerIndex.One);
if(pad1.DPad.Left == ButtonState.Pressed)
{
    //Do something if the Dpad is being pressed left
}
else if (pad1.DPad.Right == ButtonState.Pressed)
{
    //Do something if the Dpad is being pressed right
}
else if (pad1.DPad.Up == ButtonState.Pressed)
{
    //Do something if the Dpad is being pressed up
}
    else if (pad1.DPad.Down == ButtonState.Pressed)
{
    //Do something if the Dpad is being pressed down
}
else
{
    //Do something if the Dpad is not being pressed
}

GamePad.SetVibration(PlayerIndex.One, 1, 1);

GamePad.SetVibration(PlayerIndex.One, .5, 0);

GamePad.SetVibration(PlayerIndex.One, 0, 0);

if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
{
    GamePad.SetVibration(PlayerIndex.One, 0, 0);
    this.Exit();
}

You can use the keyboard to collect player input on both a Windows computer and the Xbox 360. To use a keyboard on the Xbox 360, simply plug a standard USB keyboard into an open Xbox 360 USB port and within a few moments, Xbox will be ready to work with it. A keyboard is a digital control and is used in games that provide the player with lots of choices that can be selected or disabled at any moment at the click of a button (e.g., key).

Different keyboards have different buttons. For example, some may have keys that control the computer’s volume, while others only support a standard 101-key US key layout or perhaps a 104-key Windows layout.

Keyboard data is provided in XNA applications via the Keyboard class, which is used in conjunction with the KeyboardState structure to retrieve keyboard state data. In addition, keyboard information is made available through the Keys object and the GetPressedKeys array. The Keys object is an enumerated data type. Enumerated data types are types in which a range of name value types are available (e.g., all of the letters, numbers, and special characters available on the keyboard). The GetPressedKeys method retrieves an array made up of a list of all currently depressed keyboard keys.

An example of how to interact with and retrieve keyboard data is provided later in this chapter.

If you are creating XNA games specifically for Microsoft Windows, you have the option of the computer’s mouse as an input source during game play. XNA is capable of reacting to mouse button clicks. Most mice have three digital buttons: a left button, a right button, and a mouse scroll wheel that when clicked serves as a third button. Some mice also support additional buttons on the left and right side of the mouse. The mouse scroll button also doubles as an analog control. The mouse is often used in games where the player needs to be able to select different objects. When moved, the mouse works as an analog device, providing very precise data regarding the location of the mouse pointer within the game window.

A computer mouse reports data in the form of pixels, based on a coordinate system where 0,0 is the upper-left corner of the screen or window. To collect and process mouse input, you must use the Mouse class’s GetState() method to retrieve a MouseState object. You’ll need to repeatedly execute the GetState() method every time the Update() method is executed. The MouseState object provides access to the current position of the mouse pointer.

The mouse pointer’s location is traced via a coordinate system that originates at location 0,0, which is the upper-left corner of the game window. In this coordinate system, introduced in Chapter 5, the X coordinate represents the location of the mouse pointer along the X-axis and the Y coordinate represents the location of the mouse pointer along the Y-axis.

Table 7.2 provides a listing of the different properties exposed through the MouseState object. As you can see, it provides access for up to six mouse buttons, the mouse pointer’s coordinates, and the scroll wheel’s value.

protected override void Initialize()
{
    this.IsMouseVisible = true;
    base.Initialize();
}

Unlike the personal computer or Xbox, where the range of available controllers varies based on the devices that are attached, the Zune is limited to the digital and analog buttons and controllers that are built into the device. These include two digital button controls (Back and Start/Pause) and a Zune Pad, as shown in Figure 7.3.

Figure 7.3. The Zune is equipped with multiple digital controls and an analog control.

XNA maps the Zune player’s controls to gamepad controls, allowing you to interact with them using the GamePad class. Table 7.3 shows how XNA maps out the Zune player’s controls to those of the gamepad.

As shown in Table 7.3, Zune’s Back button is mapped to the gamepad’s back button and Zune’s Play/Pause button is mapped to the gamepad’s B button. The Zune pad control maps to several different gamepad controls depending on how it is used. When pressed in the center as a button control, the Zune Pad maps to the gamepad’s A button. When pressed on its top, bottom, left, or right sides, the Zune Pad is mapped to the gamepad’s Dpad control. Lastly, any motion over the Zune Pad is mapped to the gamepad’s left thumbstick.

Depending on the types of games you are creating, it is often a good idea to allow the player to control the games in different ways. For example, suppose you created a simple game that you could run on your Windows computer, Xbox 360, and Zune. If the game was complex, you might create a copy of the game for each platform and then customize each copy to support environment-specific controls.

However, if your game was not too complex, you might find it desirable to keep the programming logic for dealing with user interface controls for all three platforms together. As an example, look at the following statements.

GamePadState pad1 = GamePad.GetState(PlayerIndex.One);

if(pad1.Buttons.A == ButtonState.Pressed ||
    pad1.DPad.Down == ButtonState.Pressed ||
    keys.IsKeyDown(Keys.Down))
{
            //Do something
}

Here, logic has been added to allow the game to perform a given action using several different commands. If the game containing these statements ran on Microsoft Windows, the player could press the green A gamepad button, the downward side of the Dpad control, or the down arrow key to perform a given action. An Xbox 360 player could perform the same three actions if a keyboard is installed or just the two gamepad options if a keyboard were not available. A Zune player, on the other hand would be able to initiate that same action by the player pressing on the down side of the Zune Pad.

To bring together all of the information presented in this chapter, you will learn how to create a new XNA application called the InputCollector that demonstrates how to work with the gamepad, mouse, and keyboard. Of course, since the Zune’s controls map to gamepad controls, this example can also be modified to work with Zune players. Figure 7.4 provides a view of the application in action.

Figure 7.4. An example of the InputCollector application in action.

As you can see, the application is organized into three sections, one section for each device type. The data retrieved from the gamepad includes data collected from the controller’s Dpad, left and right thumbsticks, as well as the left and right shoulder controls. Mouse data includes the X and Y coordinate data as well as the status of the mouse’s left and right buttons and wheel input. The Keyboard section displays keyboard data keyed in while the application is running. Of course, if you create a version of this application for the Zune, the only data that will be available is for the Zune controls that map to the gamepad.

In order to create this new application, you will need to perform a number of steps, as outlined here:

Once you have completed all of these steps, you will be able to save and run the application on your computer. Later, in Chapter 11, you will learn how to modify and port your application over to other platforms, including the Zune and Xbox 360.

//Load the font used to display windows text
font = Content.Load<SpriteFont>("SpriteFont1");

public class Game1 : Microsoft.Xna.Framework.Game
{
    GraphicsDeviceManager graphics;
    SpriteBatch spriteBatch;

    SpriteFont font; //Declare variable to store font
    Color ScreenColor = Color.White; //Define background color

    //Declare variables used to collect and report gamepad data
    String StartMsg = "";
    String DpadMsg = "";
    String LThumbX = "";
    String LThumbY = "";
    String RThumbX = "";
    String RThumbY = "";
    String LShoulder = "";
    String RShoulder = "";

    //Declare variables used to collect and report keyboard data
    String mouseX = "";
    String mouseY = "";
    String LMouse = "";
    String RMouse = "";
    String MouseWheel = "";

    //Declare variable and array used to collect and report mouse data
    String KeyboardText = "";
    Keys[] PrevKeyPresses = new Keys[0];
    .
    .
    .

protected override void Initialize()
{
    this.IsMouseVisible = true;
    base.Initialize();
}

protected override void Update(GameTime gameTime)
{
     //Retrieve gamepad, keyboard and mouse state data
     GamePadState pad1 = GamePad.GetState(PlayerIndex.One);
     KeyboardState keys = Keyboard.GetState();
     MouseState MouseObj = Mouse.GetState();

    // Allows the game to exit
     if(GamePad.GetState(PlayerIndex.One).Buttons.Back ==
       ButtonState.Pressed)
          this.Exit();

     base.Update(gameTime);

}

// Allows the game to exit
if(GamePad.GetState(PlayerIndex.One).Buttons.Back ==
   ButtonState.Pressed || keys.IsKeyDown(Keys.Escape))
   this.Exit();

//Process gamepad buttons (A, B, X, and Y)
if (pad1.Buttons.A == ButtonState.Pressed) ScreenColor = Color.LightGreen;
if (pad1.Buttons.B == ButtonState.Pressed) ScreenColor = Color.IndianRed;
if (pad1.Buttons.X == ButtonState.Pressed) ScreenColor = Color.LightBlue;
if (pad1.Buttons.Y == ButtonState.Pressed) ScreenColor = Color.Yellow;

//Process gamepad Start button
if (pad1.Buttons.Start == ButtonState.Pressed) {
   StartMsg = "Pressed";
}
else
{
   StartMsg = "";

}

//Process gamepad DPad input
if (pad1.DPad.Left == ButtonState.Pressed)
{
   DpadMsg = "Left DPad Pressed";
}
   else if (pad1.DPad.Right == ButtonState.Pressed)
{
   DpadMsg = "Right DPad Pressed";
}
   else if (pad1.DPad.Up == ButtonState.Pressed)
{
   DpadMsg = "Up DPad Pressed";
}
   else if (pad1.DPad.Down == ButtonState.Pressed)
{
   DpadMsg = "Down Dpad Pressed";
}
   else
{
   DpadMsg = "";
}

//Process gamepad left and right thumbstick input
LThumbX = pad1.ThumbSticks.Left.X.ToString();
LThumbY = pad1.ThumbSticks.Left.Y.ToString();
RThumbX = pad1.ThumbSticks.Right.X.ToString();
RThumbY = pad1.ThumbSticks.Right.Y.ToString();

//Process gamepad left and right shoulder buttons
if (pad1.Buttons.LeftShoulder == ButtonState.Pressed)
{
   LShoulder = "Pressed";
}
else
{
   LShoulder = "";
}
   if (pad1.Buttons.RightShoulder == ButtonState.Pressed)
{
   RShoulder = "Pressed";
}
else
{
   RShoulder = "";
}

//Store mouse pointer coordinates
mouseX = MouseObj.X.ToString();
mouseY = MouseObj.Y.ToString();

//Process left and right mouse buttons
if (MouseObj.LeftButton == ButtonState.Pressed)
{
   LMouse = "Pressed";
}
else
{
   LMouse = "";

}

if (MouseObj.RightButton == ButtonState.Pressed)
{
   RMouse = "Pressed";
}
else
{
   RMouse = "";
}

//Process Mouse wheel data
MouseWheel = MouseObj.ScrollWheelValue.ToString();

//Define an array and load it with a list of pressed keys
Keys[] CurrentKeys;
CurrentKeys = keys.GetPressedKeys();

//Process keyboard input and store as a string
for (int i = 0; i < CurrentKeys.Length; i++)
{
    bool match = false;
    for (int j = 0; j < PrevKeyPresses.Length; j++)
    {
        if (CurrentKeys[i] == PrevKeyPresses[j])
        {

           match = true;
           break;
        }
    }
    if(match == false)
    {
       switch(CurrentKeys[i])
       {
           case Keys.Space:
               KeyboardText = KeyboardText + " ";
               break;
           case Keys.Enter:
               KeyboardText = KeyboardText + "
";
               break;
           case Keys.OemPeriod:
               KeyboardText = KeyboardText + ".";
               break;
           default:
               KeyboardText = KeyboardText + CurrentKeys[i].ToString();
               break;
        }
    }
}
PrevKeyPresses = CurrentKeys;

protected override void Draw(GameTime gameTime)
{
   GraphicsDevice.Clear(ScreenColor);

   Color Pur = Color.Purple; //Define text color for headings
   Color Blu = Color.Blue;      //Define text color for detailed data

   //Specify the coordinates where console text is to be written
   Vector2 v1 = new Vector2(20, 10);      //Gamepad-----
   Vector2 v2 = new Vector2(20, 50);      //Start Button
   Vector2 v3 = new Vector2(410, 50);    //Dpad
   Vector2 v4 = new Vector2(20, 100);    //Left Thumbstick X
   Vector2 v5 = new Vector2(20, 130);    //Left Thumbstick Y
   Vector2 v6 = new Vector2(410, 100); //Right Thumbstick X
   Vector2 v7 = new Vector2(410, 130); //Right Thumbstick Y
   Vector2 v8 = new Vector2(20, 180);    //Left Shoulder
   Vector2 v9 = new Vector2(410, 180); //Right Shoulder
   Vector2 v10 = new Vector2(20, 250); //Mouse-----
   Vector2 v11 = new Vector2(20, 290); //Mouse X Coordinate
   Vector2 v12 = new Vector2(20, 320); //Mouse Y Coordinate
   Vector2 v13 = new Vector2(410, 290); //Mouse Left Button
   Vector2 v14 = new Vector2(410, 320); //Mouse Right Button
   Vector2 v15 = new Vector2(20, 370); //Mouse Wheel

   Vector2 v16 = new Vector2(20, 440); //Keyboard- - - - - - -
   Vector2 v17 = new Vector2(20, 480); //Typing area

   spriteBatch.Begin();
   spriteBatch.DrawString(font, "- Gamepad -", v1, Pur);
   spriteBatch.DrawString(font, "Start Button: " + StartMsg, v2, Blu);
   spriteBatch.DrawString(font, "Dpad : " + DpadMsg, v3, Blu);
   spriteBatch.DrawString(font, "Left Thumbstick X: " + LThumbX, v4, Blu);
   spriteBatch.DrawString(font, "Left Thumbstick Y: " + LThumbY, v5, Blu);
   spriteBatch.DrawString(font, "Right Thumbstick X: " + RThumbX, v6, Blu);
   spriteBatch.DrawString(font, "Right Thumbstick Y: " + RThumbY, v7, Blu);
   spriteBatch.DrawString(font, "LeftShoulder: " + LShoulder, v8, Blu);
   spriteBatch.DrawString(font, "RightShoulder: " + RShoulder, v9, Blu);
   spriteBatch.DrawString(font, "- Mouse -", v10, Pur);
   spriteBatch.DrawString(font, "Mouse Position X: " + mouseX, v11, Blu);
   spriteBatch.DrawString(font, "Mouse Position Y: " + mouseY, v12, Blu);
   spriteBatch.DrawString(font, "Left Mouse Button: " + LMouse, v13, Blu);
   spriteBatch.DrawString(font, "Right Mouse Button: " + RMouse, v14, Blu);
   spriteBatch.DrawString(font, "Mouse Wheel: " + MouseWheel, v15, Blu);
   spriteBatch.DrawString(font, "- Keyboard -", v16, Pur);
   spriteBatch.DrawString(font, KeyboardText, v17, Blu);
   spriteBatch.End();

   base.Draw(gameTime);
}

In this chapter, you learned how to work with various input devices including the gamepad, keyboard, and mouse. You also learned how the Zune player’s controls map to gamepad controls, allowing your applications to interact with them using the same program code that works with gamepad controllers. Using the information provided in this chapter, you will be able to develop games that can be played using one or more of the controllers covered in this chapter.