Controlling Games with the Keyboard and Mouse - Mouse and Joystick
(Page 3 of 8 )
Responding to the Mouse
Although the keyboard is firmly in place as the most necessary of user input devices, the graphical nature of modern computers establishes the mouse or a similar pointing device as a standard input device as well. The mouse, however, doesn't share the wide range of input applications to games that the keyboard has. This stems from its primary usage as a point-and-click device; if you haven't noticed, a lot of games don't follow the point-and-click paradigm.
In regard to gaming, the usefulness of the mouse is totally dependent on the type of game and, therefore, the type of user interaction dictated by the game. However, as quickly as some people write off the mouse as being a useless interface in some games, others praise the fine control it provides. Again, a good example is Doom. Personally, I think the keyboard is much more responsive than the mouse, and the keyboard enables me to get around faster and with more control. But I have friends who feel lost playing the game without a mouse.
Clearly, this is a situation in which the game designers saw a way to provide support for both the keyboard and mouse. With the exception of the most extreme cases, this should be your goal as well. Different game players like different things, and the safest solution is to hedge your bets and support all input devices whenever possible. By following this simple rule, you can develop games that can be appreciated and enjoyed by a broader group of game players.
Interacting with Joysticks
Although not quite as standard as keyboards and mouse devices, joysticks nonetheless represent a very common component of modern computer systems. Joysticks are in many ways a throwback to video games of old—many of which relied heavily on joysticks for controlling characters, spaceships, and other game objects. Joysticks come in both digital and analog form, although the difference between the two isn't terribly important from a programming perspective. The primary thing to consider when assessing the role of joysticks in games is whether it makes sense to play the game with a joystick. In other words, does the movement in the game lend itself to being carried out with a vertical stick (or flat game pad), as opposed to using keyboard keys or a mouse? Of course, it's not a bad idea to support multiple input devices—in which case, you might opt to include joystick support just to be flexible. Most game pads count as joysticks because they provide a similar functionality in terms of providing a multidirectional control for movement, as well as several buttons.
It's worth mentioning that some games out there seem to be expressly designed for being played with joysticks. For one, the extremely popular game Halo (and its successor Halo 2) on the Xbox console system uses a unique feature that would be difficult to replicate with a keyboard or mouse. Halo allows you to press the joystick inward to activate a rifle scope on your gun. So, if you see some bad guys off in the distance, you can push in on the joystick to zoom with the scope and pick them off one by one. The scope/zoom feature in Halo is an excellent example of an ingenious game feature made possible by a specific type of input device. Of course, the Xbox controller had to include a joystick with the push feature in order for Halo to work, so Microsoft deserves some credit on the hardware side of things.
Assessing Keyboard Input for Games
You know that messages are used heavily throughout the Win32 API to deliver notifications regarding things such as window creation, window destruction, window activation, window deactivation, and so on. You might be glad to find out that this same messaging system is used to deliver notifications regarding key presses on the keyboard. More specifically, the Win32 API defines messages called WM_KEYDOWN and WM_KEYUP that inform you whenever a key has been pressed or released, respectively. These two messages are quite easy to handle in a Windows program, and I'd love to show you how to use them, but there's a problem. The problem is that the standard Windows messaging system is painfully slow when it comes to delivering keyboard messages. Because games rely heavily on responsive controls, it simply isn't acceptable to work with the Windows keyboard messages.
The bottom line is that none of your games can support keyboards. Okay, I'm kidding. The truth is that there is always a workaround in game programming, and the slow keyboard messaging problem presents a perfect opportunity for a workaround. If you recall, the timing for the Game Engine was established back in Chapter 2, "Creating an Engine for Games," in the WinMain() function. The WinMain() function includes a program loop that repeats over and over, processing messages for the program. When the function isn't processing messages, it spends its time running through cycles of the game engine. In other words, the game engine takes advantage of idle time in the main program loop to carry out its game-related tasks. This idle time is what you can use to your advantage when processing key presses and releases on the keyboard.
Note - The concept of "idle time" with respect to the WinMain() function is a little misleading. When you consider that games don't typically process very many messages from Windows, the vast majority of the time spent by a game program is idle time or time when it's not responding to standard Windows messages. This time can therefore be put to use running the game engine, which is what I mean when I talk about running through the game cycles during idle time.
The idea behind this juiced up approach to keyboard event handling is that instead of sitting around waiting for Windows to eventually send you a keyboard message, you constantly check the keyboard to see if any of the keys you're interested in have been pressed. If so, the game instantly springs into motion and efficiently responds to the key press. If no key is pressed, the game engine hums along with no interruptions. The strategy here is to basically take keyboard processing into your own hands and bypass the standard Windows approach, which ultimately results in much more responsive keyboard controls for your games. You learn how to implement this speedy keyboard handler in code a little later in the chapter. For now, let's take a look at how to respond to mouse events.
 This chapter is from Beginning Game Programming, by Michael Morrison (Sams, ISBN: 0672326590). Check it out at your favorite bookstore today.
Buy this book now. |
Next: Tracking the Mouse >>
More PC Gaming Articles
More By Sams Publishing
| Recommended by Dev Hardware |
|---|
|
