Controlling Your Game in C#

Handling Keyboard and Mouse Inputs in C#

In this tutorial, you will learn how to handle keyboard and mouse inputs in C#.

When writing a game, one of the first decisions you need to make is how you will handle input. Will the players use the keyboard for input? Will the game support a mouse, a joystick or all three? C# takes much of the work out of handling input devices, but you can take advantage of several techniques.

The keyboard and mouse are the primary input device(s) for most games.

The Keyboard

The keyboard is the primary input device in most applications and games. Even those that provide joystick play will make some attempt to provide keyboard commands and shortcuts. The reason for this is simple – you can be sure that there is a keyboard of some type integrated on most PC’s.

Here are some common keyboard inputs for a game:

Move forward:            W or Up arrow key

Move backward:         S or Down arrow key

Move left:                   A or Left arrow key

Move right:                 D or Right arrow key

Jump:                           Spacebar

Fire:                             X or Ctrl key

Launch:                       E

The W, A, S, and D keys or WASD keys on the computer keyboard are used in place of the arrow keys.

They are often used because they allow the gamer to access more of the keys around them, which means more keys may be assigned to other tasks in the game.

You can detect most physical key presses by handling the KeyDown or KeyUp events. Key events occur in the following order:

• KeyDown event occurs when the user presses any key on the keyboard, it repeats while the user keeps the key depressed.
• KeyPress event occurs when the user presses an ANSI key. This event is not raised by noncharacter keys, unlike KeyDown and KeyUp, which are also raised for noncharacter keys.
• KeyUp event occurs when the user releases the key.

Note: The KeyDown and KeyPress events alternate repeatedly until the user releases the key, at which time the KeyUp event occurs.

The KeyDown and KeyUp events have several properties, in most cases the Keycode and KeyValue are used.

• KeyCode property gets the keyboard code for the key pressed.
• KeyValue gets the keyboard value for the key pressed.

The KeyPress event has two properties, the Handled and KeyChar properties.

• Handled property gets the value indicating whether the KeyPress event was handled.
• KeyChar property gets the character corresponding to the key pressed.

Keyboard Procedures

In a typical game you can use a form’s KeyDown, KeyPress, and KeyUp events for registering user input via the keyboard. Take a look at what keyboard procedures are available.

KeyDown and KeyUp

The KeyDown and KeyUp events are useful in a space game where you want to fire the weapon continuously, you can fire the weapon – but you need to know when to turn it off. You can also use the KeyDown event to move the Spaceship using the character keys WSAD and the Arrow keys.

The KeyEventArgs class provides data for the KeyDown or KeyUp event,

Keys are identified by key values, which consist of a key code and a set of modifiers combined into a single integer value.

private void frmkeyboard_KeyDown(object eventSender, KeyEventArgs eventArgs)
{
short KeyCode1 = (short)eventArgs.KeyCode;

//is this our engine key
switch (KeyCode1)
{
case (short)Keys.E:
// yes, fire the weapon
MyWeapon (Fire);
}
}

private void frmkeyboard_KeyUp(object eventsender, KeyEventArgs eventArgs)
{
short KeyCode1 = (short)eventArgs.KeyCode;

//is this our fire weapon key, which has a key value of 88.
if (KeyCode1 == (short)Keys.X)
{
//stop firing the weapon
MyWeapon (StopFire);
}
}

As long as the player presses the “X” key, the weapon will fire.

KeyPress

The KeyPress event is used to assign hot keys to menu options and controls. You can use the KeyPress to use the character keys such as the WSAD to move, but not the arrow keys.

The KeyPressEventArgs class provides data for the KeyPress event.

private void frmkeyboard_KeyPress(object eventsender, KeyPressEventArgs eventArgs)
{
short KeyAscii = Convert.ToInt16((eventArgs.KeyChar));

// Determine whether this is a key we want
if (KeyAscii == 97) // the letter a has an ACSII value of 97.
{
// code to move spaceship left
MySpaceship (MoveLeft);
}
else if (KeyAscii == 100) // the letter d has an ASCII value of 100.
{
// code to move spaceship right
MySpaceship (MoveRight);
}
}

In this example we use the ASCII code for the key pressed and compare it to the ASCII value for the key.

Key States

When you use the KeyUp and KeyDown methods, the keyboard state keys can be monitored. The Ctrl, Alt, and Shift keys will generate up and down events. An advantage to the states keys is that they won’t fill the keyboard buffer when they are held down. They will not generate KeyPress events, because they don’t have ASCII values.

KeyPreview

The KeyPreview property enables and disables the global handling of keyboard events. If KeyPreview is True, all keyboard events are sent to the form first. This routine permits you to set up a global keyboard handler for the entire game and the keystrokes at the form level rather than writing code for each control that might receive keystroke events.

Keyboard Examples:

The spaceship and weapon fire will be used to illustrate the keyboard events.