Chapter 10: Handling Input

Learn how to handle keyboard, mouse, and gamepad input in MonoGame.

When you play a game, you need ways to control what's happening; using a keyboard or gamepad to control a character or clicking the mouse to navigate a menu, MonoGame helps us handle all these different types of controls through dedicated input classes:

Keyboard: Detects which keys are being pressed.
Mouse: Tracks mouse movement, button clicks, and scroll wheel use.
GamePad: Manages controller input like button presses and thumbstick movement.
TouchPanel: Manages touch input on devices with a touch panel such as mobile phones and tablets.

Each of these input types has a GetState method that, when called, checks what is happening with that device at that moment. Think of it like taking a snapshot; when you call GetState, MonoGame looks at that exact moment to see which buttons are pressed, where the mouse is, or how the controller is being used.

In this chapter you will, we will learn how to use each of these dedicated input classes to handle player input.

Keyboard Input

The keyboard is often the primary input device for PC games, used for everything from character movement to menu navigation. MonoGame provides the Keyboard class to handle keyboard input, making it easy to detect which keys are being pressed at any time. Calling Keyboard.GetState will retrieve the current state of the keyboard as a KeyboardState struct.

KeyboardState Struct

The KeyboardState struct contains methods that can be used to determine if a keyboard key is currently down or up:

Method	Description
IsKeyDown(Keys)	Returns `true` if the specified key is down; otherwise, returns `false`.
IsKeyUp(Keys)	Returns `true` if the specified key is up; otherwise, returns `false`.

For example, if we wanted to see if the Space key is down, you could use the following:

// Get the current state of keyboard input.
KeyboardState keyboardState = Keyboard.GetState();

// Check if the space key is down.
if(keyboardState.IsKeyDown(Keys.Space))
{
    // The space key is down, so do something.
}

Tip

Notice we store the keyboard state in a variable instead of calling Keyboard.GetState multiple times. This is more efficient and ensures consistent input checking within a single frame.

Mouse Input

The mouse is often the secondary input device for PC games, used for various actions from camera movement to interacting with menus and objects. MonoGame provides the Mouse class to handle mouse input, making it easy to detect which buttons are pressed, the position of the mouse cursor, and the value of the scroll wheel. Calling Mouse.GetState will retrieve the current state of the mouse as a MouseState struct.

MouseState Struct

The MouseState struct contains properties that can be used to determine the state of the mouse buttons, the mouse position, and the scroll wheel value:

Property	Type	Description
LeftButton	ButtonState	Returns the state of the left mouse button.
MiddleButton	ButtonState	Returns the state of the middle mouse button. This is often the button when pressing the scroll wheel down as a button
Position	Point	Returns the position of the mouse cursor relative to the bounds of the game window.
RightButton	ButtonState	Returns the state of the right mouse button.
ScrollWheelValue	`int`	Returns the cumulative scroll wheel value since the start of the game
XButton1	ButtonState	Returns the state of the first extended button on the mouse.
XButton2	ButtonState	Returns the state of the second extended button on the mouse.

Note

ScrollWheelValue returns the cumulative value of the scroll wheel since the start of the game, not how much it moved since the last update. To determine how much it moved between one update and the next, you would need to compare it with the previous frame's value. We'll discuss comparing previous and current frame values for inputs in the next chapter.

Unlike keyboard input which uses IsKeyDown(Keys)/IsKeyUp(Keys) methods mouse buttons return a ButtonState:

ButtonState.Pressed: The button is being held down.
ButtonState.Released: The button is not being pressed.

For example, if we wanted to see if the left mouse button is down, you could use the following

// Get the current state of mouse input.
MouseState mouseState = Mouse.GetState();

// Check if the left mouse button is pressed down.
if(mouseState.LeftButton == ButtonState.Pressed)
{
    // The left button is down, so do something.
}

Gamepad Input

Gamepads are often used as a primary input for a game or an alternative for keyboard and mouse controls. MonoGame provides the GamePad class to handle gamepad input, making it easy to detect which buttons are pressed and the value of the thumbsticks. Calling GamePad.GetState will retrieve the state of the gamepad as a GamePadState struct. Since multiple gamepads can be connected, you will need to supply a PlayerIndex value to specify which gamepad state to retrieve.

GamePadState Struct

The GamePadState struct and properties that can be used to get the state of the buttons, dpad, triggers, and thumbsticks:

Property	Type	Description
Buttons	GamePadButtons	Returns a struct that identifies which buttons on the controller are pressed.
DPad	GamePadDPad	Returns a struct that identifies which directions on the DPad are pressed.
IsConnected	`bool`	Returns a value that indicates whether the controller is connected.
ThumbSticks	GamePadThumbSticks	Returns a struct that contains the direction of each thumbstick. Each thumbstick (left and right) are represented as a Vector2 value between `-1.0f` and `1.0` for the x- and y-axes.
Triggers	GamePadTriggers	Returns a struct that contains the value of each trigger. Each trigger (left and right) are represented as a `float` value between `0.0f`, meaning not pressed, and `1.0f`, meaning fully pressed.

Buttons

The GamePadState.Buttons property returns a GamePadButtons struct that can be used to identify which buttons on the controller are pressed. This struct contains the following properties:

Property	Type	Description
A	ButtonState	Returns the state of the A button
B	ButtonState	Returns the state of the B button
Back	ButtonState	Returns the state of the Back button
BigButton	ButtonState	Returns the state of the BigButton button
LeftShoulder	ButtonState	Returns the state of the LeftShoulder button
LeftStick	ButtonState	Returns the state of the LeftStick button
RightShoulder	ButtonState	Returns the state of the RightShoulder button
RightStick	ButtonState	Returns the state of the RightStick button
Start	ButtonState	Returns the state of the Start button
X	ButtonState	Returns the state of the X button
Y	ButtonState	Returns the state of the Y button

Note

Recall from Chapter 01 that MonoGame is a implementation the XNA API. Since XNA was originally created for making games on Windows PC and Xbox 360, the names of the gamepad buttons match those of an Xbox 360 controller.

Front	Back
Xbox

Playstation

Like with the mouse input, each of these buttons are represented by a ButtonState enum value. For instance, if you wanted to check if the A button is being pressed you could do the following:

// Get the current state of player one's gamepad
GamePadState gamePadState = GamePad.GetState(PlayerIndex.One);

// Check if the A button is pressed down.
if(gamePadState.Buttons.A == ButtonState.Pressed)
{
    // Button A is pressed, do something.
}

DPad

The DPad property returns a GamePadDPad struct that can be used to identify which DPad buttons on the controller are pressed. This struct contains the following properties:

Property	Type	Description
Down	ButtonState	Returns the state of the DPad Down button.
Left	ButtonState	Returns the state of the DPad Left button.
Right	ButtonState	Returns the state of the DPad Right button.
Up	ButtonState	Returns the state of the DPad Up Button.

Like with the Buttons, these also return a ButtonState enum value to represent the state of the DPad button. For instance, if you wanted to check if the DPad up button is being pressed, you could do the following:

// Get the current state of player one's gamepad
GamePadState gamePadState = GamePad.GetState(PlayerIndex.One);

// Check if the down on the DPad is pressed.
if(gamePadState.DPad.Down == ButtonState.Pressed)
{
    // DPad down is pressed, do something.
}

Thumbsticks

The ThumbSticks property returns a GamePadThumbSticks struct that can be used to retrieve the values of the left and right thumbsticks. This struct contains the following properties:

Property	Type	Description
Left	Vector2	The direction the left thumbstick is pressed.
Right	Vector2	The direction the right thumbstick is pressed.

The thumbstick values are represented as a Vector2 value:

X-axis: A value between -1.0f (pushed fully to the left) and 1.0f (pushed fully to the right).
Y-axis: A value between -1.0f (pushed fully downward) and 1.0f (pushed fully upward).

For example, if you wanted to move a sprite using the left thumbstick, you could do the following

// Get the current state of player one's gamepad
GamePadState gamePadState = GamePad.GetState(PlayerIndex.One);

// Get the value of the left thumbstick.
Vector2 leftStick = gamePadState.Thumbsticks.Left;

// Invert the y-axis value
leftStick.Y *= -1.0f;

// Apply the value to the position of the sprite.
sprite.Position += leftStick;

Important

Notice that we inverted the y-axis value of the thumbstick by multiplying it by -1.0f. This is necessary because the thumbstick y-axis values range from -1.0f (down) to 1.0f (up). The y-axis of the screen coordinates in MonoGame increases downward, as we saw in Chapter 06.

This inversion aligns the thumbstick's y-axis value with the screen movement.

Triggers

The Triggers property returns a GamePadTriggers struct that can be used to retrieve the values of the left and right triggers. This struct contains the following properties:

Property	Type	Description
Left	`float`	The value of the left trigger.
Right	`float`	The value of the left trigger.

The trigger values are represented as a float value between 0.0f (not pressed) to 1.0f (fully pressed). The triggers on a gamepad, however, can be either analog or digital depending the gamepad manufacturer. For gamepads with digital triggers, the value will always be either 0.0f or 1.0f, as a digital trigger does not register values in between based on the amount of pressure applied to the trigger.

For example, if we were creating a racing game, the right trigger could be used for acceleration like the following:

// Get the current state of player one's gamepad
GamePadState gamePadState = GamePad.GetState(PlayerIndex.One);

// Get the acceleration based on how far the right trigger is pushed down.
float acceleration = gamePadState.Triggers.Right;

GamePadState Methods

The GamePadState struct also contains two methods that can be used to get information about the device's inputs as either being up or down:

Method	Description
IsButtonDown(Buttons)	Returns a value that indicates whether the specified button is down. Multiple Buttons values can be given using the bitwise OR `\|` operator. When multiple buttons are given, the return value indicates if all buttons specified are down, not just one of them.
IsButtonUp(Buttons)	Returns a value that indicates whether the specified button is up. Multiple Buttons values can be given using the bitwise OR `\|` operator. When multiple buttons are given, the return value indicates if all buttons specified are up, not just one of them.

You can use the IsButtonDown(Buttons) and IsButtonUp(Buttons) methods to get the state of all buttons, including the DPad. The following is a complete list of all of the Buttons enum values:

Caution

While you can use these methods to get the state of any of these button inputs, the state will only tell you if it is being pressed or released. For the actual thumbstick values and trigger values, you would need to use the properties instead.

For example, if we wanted to check if the A button on the the first gamepad is pressed, you could use the following:

// Get the current state of player one's gamepad
GamePadState gamePadState = GamePad.GetState(PlayerIndex.One);

// Check if the A button is down.
if(gamePadState.IsButtonDown(Buttons.A))
{
    // The A button is pressed, do something.
}

GamePad Vibration

Another capability of gamepads is haptic feedback through vibration motors. MonoGame allows you to control this feature using the GamePad.SetVibration method. This method takes three parameters:

The PlayerIndex of the gamepad to vibrate.
The intensity of the left motor (from 0.0f for no vibration to 1.0f for maximum vibration).
The intensity of the right motor (using the same scale).

Most modern gamepads have two vibration motors, a larger one (usually the left motor) for low-frequency rumble and a smaller one (usually the right motor) for high-frequency feedback. By controlling these independently, you can create various haptic effects:

// Make the gamepad vibrate at full intensity
GamePad.SetVibration(PlayerIndex.One, 1.0f, 1.0f);

// Stop all vibration
GamePad.SetVibration(PlayerIndex.One, 0.0f, 0.0f);

// Create a subtle, low-intensity vibration
GamePad.SetVibration(PlayerIndex.One, 0.3f, 0.1f);

TouchPanel Input

For mobile devices such as Android/iOS phones and tablets, the primary input device is the touch panel screen. Touching a location on the screen is similar to clicking a location on your computer with a mouse. MonoGame provides the TouchPanel class to handle touch input.

The TouchPanel class offers two ways of retrieving information about touch input:

TouchPanel.GetState retrieves a TouchCollection struct that contains TouchLocation values for each point of touch on the touch panel.
TouchPanel.ReadGesture retrieves a GestureSample struct that contains information about recent gestures that have been performed like a vertical or horizontal drag across the screen.

TouchCollection

When calling TouchPanel.GetState a TouchCollection struct is returned. This collection contains a TouchLocation value for each point of touch.

TouchLocation

Each TouchLocation value in a touch collection contains the following properties:

Property	Type	Description
Id	`int`	The id of the touch location.
Position	Vector2	The position of the touch location.
Pressure	`float`	The amount of pressure applied at the touch location. (Only available for Android devices.)
State	TouchLocationState	The current state of the touch location.

The important properties of the location are the Position and the State The position property will tell us the location of the touch event, and the state can be one of the following values:

State	Description
Invalid	This touch location position is invalid.
Moved	This touch location position was updated or pressed at the same position.
Pressed	This touch location was pressed.
Released	This touch location was released.

When the state is moved or pressed, then we know that location on the touch panel is being touched. So we can capture it and use it like the following:

// Get the current state of touch input.
TouchCollection touchCollection = TouchPanel.GetState();

foreach(TouchLocation touchLocation in touchCollection)
{
    if(touchLocation.State == TouchLocationState.Pressed || touchLocation.State == TouchLocationState.Moved)
    {
        // The the location at touchLocation.Position is currently being pressed,
        // so we can act on that information.
    }
}

Note

Unlike mouse input which only tracks a single point, TouchPanel supports multiple simultaneous touch points. The TouchCollection contains all active touch points, which is why we loop through them in the sample above.

The state of a touch location progresses through the states typically in order of:

Pressed: Initial contact with the screen.
Moved : Touch point moved while maintaining contact.
Released: Contact with screen ended.
Invalid : Touch data is invalid (using when tracking data is lost).

GestureSample

When calling TouchPanel.ReadGesture a GestureSample struct containing the information about recent gestures that have been performed is returned. The GestureSample struct contains the following properties:

Property	Type	Description
Delta	Vector2	Gets the delta information about the first touch-point in the gesture sample.
Delta2	Vector2	Gets the delta information about the second touch-point in the gesture sample.
GestureType	GestureType	Gets the type of the gesture.
Position	Vector2	Gets the position of the first touch-point in the gesture sample.
Position2	Vector2	Gets the position of the second touch-point in the gesture sample.

Note

Gestures have two delta properties and two position properties. This is because some gestures require multiple touch inputs to perform, such as performing a pinch to zoom in or out. You would need the location of both touch points to determine the correct zoom to apply during the gesture.

To determine what type of gesture is performed, we can get that from the GestureType property which will be one of the following values:

Gesture Type	Description
DoubleTap	The user double tapped the device twice which is always preceded by a Tap gesture.
DragComplete	States completion of a drag gesture (VerticalDrag, HorizontalDrag, or FreeDrag).
Flick	States that a touch was combined with a quick swipe.
FreeDrag	The user touched a point and the performed a free-form drag.
Hold	The user touched a single point for approximately one second.
HorizontalDrag	The user touched the screen and performed either a left-to-right or right-to-left drag gesture.
None	No gesture.
Pinch	The user converged or diverged two touch-points on the screen which is like a two-finger drag.
PinchComplete	An in-progress pinch gesture was completed.
Tap	The user touched a single point.
VerticalDrag	The user touched the screen and performed either a top-to-bottom or bottom-to-top drag gesture.

Important

Before gestures can be detected, they have to be enabled using TouchPanel.EnabledGestures. This can be done in Game.Initialize like the following:

protected override void Initialize()
{
    base.Initialize();
    
    // Enable gestures we want to handle
    TouchPanel.EnabledGestures =
        GestureType.Tap |
        GestureType.HorizontalDrag |
        GestureType.VerticalDrag;
}

The following is an example of using a gesture to detect horizontal and vertical drags:

while(TouchPanel.IsGestureAvailable)
{
    GestureSample gesture = TouchPanel.ReadGesture();

    if(gesture.GestureType == GestureType.HorizontalDrag)
    {
        // A horizontal drag from left-to-right or right-to-left occurred.
        // You can use the Delta property to determine how much movement
        // occurred during the swipe.
        float xDragAmount = gesture.Delta.X;

        // Now do something with that information.
    }

    if(gesture.GestureType == GestureType.VerticalDrag)
    {
        // A vertical drag from top-to-bottom or bottom-to-top occurred.
        // You can use the Delta property to determine how much movement
        // occurred during the swipe.
        float yDragAmount = gesture.Delta.Y;

        // Now do something with that information.
    }
}

Important

Notice above that we use a while loop with TouchPanel.IsGestureAvailable as the condition for the loop. The reason we do this is because when a user performs a gesture, such as a horizontal drag across the screen, very quickly, what can often occurs is a series of multiple small drag gestures are registered and queued.

Each time TouchPanel.ReadGesture is called, it will dequeue the next gesture. So to ensure that we handle the complete gesture, we loop the gesture queue until there are none left.

Implementing Input in Our Game

For our game, we're going to implement keyboard and gamepad controls based on the following criteria:

Keyboard Input	Gamepad Input	Description
[Keys.W] and [Keys.Up]	[Thumbstick.Left.Y] and [Buttons.DPadUp]	Moves the slime up the screen.
[Keys.S] and [Keys.Down]	[Thumbstick.Left.Y] and [Buttons.DPadDown]	Moves the slime down the screen
[Keys.A] and [Keys.Left]	[Thumbstick.Left.X] and [Buttons.DPadLeft]	Moves the slime left on the screen.
[Keys.D] and [Keys.Right]	[Thumbstick.Left.X] and [Buttons.DPadRight]	Moves the slime right on the screen.
[Keys.Space]	[Buttons.A]	Increased the speed of the slime.

Open Game1.cs and update it with the following:

using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using MonoGameLibrary;
using MonoGameLibrary.Graphics;

namespace DungeonSlime;

public class Game1 : Core
{
    // Defines the slime animated sprite.
    private AnimatedSprite _slime;

    // Defines the bat animated sprite.
    private AnimatedSprite _bat;

    // Tracks the position of the slime.
    private Vector2 _slimePosition;

    // Speed multiplier when moving.
    private const float MOVEMENT_SPEED = 5.0f;

    public Game1() : base("Dungeon Slime", 1280, 720, false)
    {

    }

    protected override void Initialize()
    {
        // TODO: Add your initialization logic here

        base.Initialize();
    }

    protected override void LoadContent()
    {
        // Create the texture atlas from the XML configuration file
        TextureAtlas atlas = TextureAtlas.FromFile(Content, "images/atlas-definition.xml");

        // Create the slime animated sprite from the atlas.
        _slime = atlas.CreateAnimatedSprite("slime-animation");

        // Create the bat animated sprite from the atlas.
        _bat = atlas.CreateAnimatedSprite("bat-animation");

        base.LoadContent();
    }

    protected override void Update(GameTime gameTime)
    {
        if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed || Keyboard.GetState().IsKeyDown(Keys.Escape))
            Exit();

        // Update the slime animated sprite.
        _slime.Update(gameTime);

        // Update the bat animated sprite.
        _bat.Update(gameTime);

        // Check for keyboard input and handle it.
        CheckKeyboardInput();

        // Check for gamepad input and handle it.
        CheckGamePadInput();

        base.Update(gameTime);
    }

    private void CheckKeyboardInput()
    {
        // Get the state of keyboard input
        KeyboardState keyboardState = Keyboard.GetState();

        // If the space key is held down, the movement speed increases by 1.5
        float speed = MOVEMENT_SPEED;
        if (keyboardState.IsKeyDown(Keys.Space))
        {
            speed *= 1.5f;
        }

        // If the W or Up keys are down, move the slime up on the screen.
        if (keyboardState.IsKeyDown(Keys.W) || keyboardState.IsKeyDown(Keys.Up))
        {
            _slimePosition.Y -= speed;
        }

        // if the S or Down keys are down, move the slime down on the screen.
        if (keyboardState.IsKeyDown(Keys.S) || keyboardState.IsKeyDown(Keys.Down))
        {
            _slimePosition.Y += speed;
        }

        // If the A or Left keys are down, move the slime left on the screen.
        if (keyboardState.IsKeyDown(Keys.A) || keyboardState.IsKeyDown(Keys.Left))
        {
            _slimePosition.X -= speed;
        }

        // If the D or Right keys are down, move the slime right on the screen.
        if (keyboardState.IsKeyDown(Keys.D) || keyboardState.IsKeyDown(Keys.Right))
        {
            _slimePosition.X += speed;
        }
    }

    private void CheckGamePadInput()
    {
        GamePadState gamePadState = GamePad.GetState(PlayerIndex.One);

        // If the A button is held down, the movement speed increases by 1.5
        // and the gamepad vibrates as feedback to the player.
        float speed = MOVEMENT_SPEED;
        if (gamePadState.IsButtonDown(Buttons.A))
        {
            speed *= 1.5f;
            GamePad.SetVibration(PlayerIndex.One, 1.0f, 1.0f);
        }
        else
        {
            GamePad.SetVibration(PlayerIndex.One, 0.0f, 0.0f);
        }

        // Check thumbstick first since it has priority over which gamepad input
        // is movement.  It has priority since the thumbstick values provide a
        // more granular analog value that can be used for movement.
        if (gamePadState.ThumbSticks.Left != Vector2.Zero)
        {
            _slimePosition.X += gamePadState.ThumbSticks.Left.X * speed;
            _slimePosition.Y -= gamePadState.ThumbSticks.Left.Y * speed;
        }
        else
        {
            // If DPadUp is down, move the slime up on the screen.
            if (gamePadState.IsButtonDown(Buttons.DPadUp))
            {
                _slimePosition.Y -= speed;
            }

            // If DPadDown is down, move the slime down on the screen.
            if (gamePadState.IsButtonDown(Buttons.DPadDown))
            {
                _slimePosition.Y += speed;
            }

            // If DPapLeft is down, move the slime left on the screen.
            if (gamePadState.IsButtonDown(Buttons.DPadLeft))
            {
                _slimePosition.X -= speed;
            }

            // If DPadRight is down, move the slime right on the screen.
            if (gamePadState.IsButtonDown(Buttons.DPadRight))
            {
                _slimePosition.X += speed;
            }
        }
    }

    protected override void Draw(GameTime gameTime)
    {
        // Clear the back buffer.
        GraphicsDevice.Clear(Color.CornflowerBlue);

        // Begin the sprite batch to prepare for rendering.
        SpriteBatch.Begin(samplerState: SamplerState.PointClamp);

        // Draw the slime sprite.
        _slime.Draw(SpriteBatch, _slimePosition);

        // Draw the bat sprite 10px to the right of the slime.
        _bat.Draw(SpriteBatch, new Vector2(_slime.Width + 10, 0));

        // Always end the sprite batch when finished.
        SpriteBatch.End();

        base.Draw(gameTime);
    }
}

The key changes made here are:

The _slimePosition field was added to track the position of the slime as it moves.
The MOVEMENT_SPEED constant was added to use as the base multiplier for the movement speed.
The CheckKeyboardInput method was added which checks for input from the keyboard based on the input table above and moves the slime based on the keyboard input detected.
The CheckGamePadInput method was added which checks for input from the gamepad based on the input table above and moves the slime based the gamepad input detected.

Note

The gamepad implementation includes a priority system for directional input. The code prioritizes the analog thumbstick values over the digital DPad buttons. This design choice provides players with more nuanced control, as analog inputs allow for a variable movements speed based on how far the thumbstick is pushed, while DPad buttons only provide on/off input states. The code first checks if either thumbstick axis has a non-zero value, and only falls back to DPad input when the thumbstick is centered.

To enhance player experience, the gamepad implementation also includes gamepad vibration when the speed boost is activated. Haptic feedback like this creates a more immersive experience by engaging additional senses for the player beyond just visual and auditory feedback.
In Update CheckKeyboardInput and CheckGamePadInput methods are called.
In Draw, the slime is now drawn using _slimePosition as the position.

Running the game now, you can move the slime around using the keyboard with the arrow keys or WASD keys. If you have a gamepad plugged in you can also use the DPad and left thumbstick.


Figure 10-1: The slime moving around based on device input

Conclusion

In this chapter, you learned how to:

Handle keyboard input to detect key presses.
Handle mouse input including button clicks and cursor position.
Work with gamepad controls including buttons, thumbsticks, and vibration.
Understand touch input for mobile devices including touch points and gestures.
Implement movement controls using different input methods.
Consider controller-specific details like coordinate systems and analog vs digital input.

In the next chapter, we'll learn how to track previous input states to handle single-press events and implement an input management system to simplify some of the complexity of handling input.

Test Your Knowledge

Why do we store the result of GetState in a variable instead of calling it multiple times?

Storing the state in a variable is more efficient and ensures consistent input checking within a frame. Each GetState call polls the device, which can impact performance if called repeatedly.
What's the main difference between how keyboard and mouse/gamepad button states are checked?

Keyboard input uses IsKeyUp/IsKeyDown methods, while mouse and gamepad buttons return a ButtonState enum value (Pressed or Released).
When using thumbstick values for movement, why do we multiply the Y value by -1?

The thumbstick Y-axis values (-1.0f down to 1.0f up) are inverted compared to MonoGame's screen coordinate system (Y increases downward). Multiplying by -1 aligns the thumbstick direction with screen movement.
What's the difference between analog and digital trigger input on a gamepad?

Analog triggers provide values between 0.0f and 1.0f based on how far they're pressed, while digital triggers only report 0.0f (not pressed) or 1.0f (pressed). This affects how you handle trigger input in your game.
What's the key difference between TouchPanel.GetState and TouchPanel.ReadGesture?

TouchPanel.GetState returns information about current touch points on the screen, while TouchPanel.ReadGesture provides information about specific gesture patterns like taps, drags, and pinches that have been performed.
Why do we use a while loop with TouchPanel.IsGestureAvailable when reading gestures?

Quick gestures can generate multiple gesture events that are queued. Using a while loop with TouchPanel.IsGestureAvailable ensures we process all queued gestures, as TouchPanel.ReadGesture only returns one gesture at a time.
How does touch input differ from mouse input in terms of handling multiple input points?

Touch input can handle multiple simultaneous touch points through the TouchCollection, while mouse input only tracks a single cursor position. This allows touch input to support features like multi-touch gestures that aren't possible with a mouse.
What are the different states a TouchLocation can have and what do they indicate?
A TouchLocation can have four states:
- Pressed: Initial contact with the screen
- Moved: Touch point moved while maintaining contact
- Released: Contact with the screen ended
- Invalid: Touch data is not valid or tracking was lost

Table of Contents

Chapter 10: Handling Input

Keyboard Input

KeyboardState Struct

Tip

Mouse Input

MouseState Struct

Note

Gamepad Input

GamePadState Struct

Buttons

Note

DPad

Thumbsticks

Important

Triggers

GamePadState Methods

Caution

GamePad Vibration

TouchPanel Input

TouchCollection

TouchLocation

Note

GestureSample

Note

Important

Important

Implementing Input in Our Game

Note

Conclusion

Test Your Knowledge