*Disclamer* I am assuming that you already have a basic knowlege of XNA. I'm not going to explain the code that is generated for you when you create a new XNA project. There enough examples doing that already.
It is a (good) standard practice for the first line of the Update code to call another method called HandleInput. Most of the samples I have seen have HandleInput code along the lines of:
KeyboardState keyboardState = Keyboard.GetState();
GamePadState gamepadState = GamePad.GetState(PlayerIndex.One);
// Exit the game when back is pressed.
if (gamepadState.Buttons.Back == ButtonState.Pressed)
Exit();
bool continuePressed =
keyboardState.IsKeyDown(Keys.Space) ||
gamepadState.IsButtonDown(ContinueButton);
(Taken from the Platformer Starter Kit, included with XNA Games Studio 3.0)Does this work? Yes. So what are the problems with it..?
- On the XBox 360 it wont work if if the player's controller is not plugged into the first port (they won't be player 1).
- It is unlikely that people are going to be using a Keyboard and GamePad at the same time - so why are we checking both?
- If we want to add support for another input device then we would have to go through every HandleInput method to make the changes (mouse, guitar, Buzz© controller anyone?)
- Personally, when I'm playing games, I like to be able to configure the controlls to how I like them. When using a Keyboard, what do we have to press to jump? The space bar? Up arrow? Either of them should work?
Thinking back to when I first learnt about the
OO Principles, this is clearly going the opposite way from
Encapsulation. The HandleInput method of our Spaceship class shouldn't need to worry about what the current key mapping is.
I started by creating an interface IInputManager. I wanted to make it easy to create a manager for the GameController and Keyboard so I gave my interface methods corisponding to each of the XBox 360 controller buttons (with several overloads)
Namespace Input
Public Interface IInputManager
Function MainMovement() As Vector2
Function MainSelectPressed() As Boolean
Function MenuMovement() As Vector2
Function MenuMainMovement() As Vector2
Function SecondaryMovement() As Vector2
Function SecondarySelectPressed() As Boolean
Function LeftTrigger() As Single
Function LeftShoulderPressed() As Boolean
Function BackPressed() As Boolean
Function StartPressed() As Boolean
Function RightTrigger() As Single
Function RightShoulderPressed() As Boolean
Function APressed() As Boolean
Function BPressed() As Boolean
Function XPressed() As Boolean
Function YPressed() As Boolean
Function MainSelectDown() As Boolean
Function SecondarySelectDown() As Boolean
Function LeftShoulderDown() As Boolean
Function BackDown() As Boolean
Function StartDown() As Boolean
Function RightShoulderDown() As Boolean
Function ADown() As Boolean
Function BDown() As Boolean
Function XDown() As Boolean
Function YDown() As Boolean
Sub Update(ByVal elapsedTime As Single)
End Interface ' IInputManager
End Namespace ' Input
From this interface I created two implementations, KeyboardInputManager and GamePadInputManager.
Namespace Input
Public Class KeyboardInputManager
Implements iInputManager
Public Sub New()
' Default Key Mapping
With mKeys
.Add("MainMovementUp", Keys.Up)
.Add("MainMovementDown", Keys.Down)
.Add("MainMovementLeft", Keys.Left)
.Add("MainMovementRight", Keys.Right)
.Add("MainSelect", Keys.Q)
.Add("SecondaryMovementUp", Keys.W)
..... etc.
End With
End Sub
Public Function Back() As Boolean Implements iInputManager.BackPressed
Return IsNewKeypress(mKeys("Back"))
End Function
Public Function LeftShoulder() As Boolean Implements iInputManager.LeftShoulderPressed
Return mCurrentKeyboardState.IsKeyDown(mKeys("LeftShoulder"))
End Function
Public Function MainMovement() As Microsoft.Xna.Framework.Vector2 Implements iInputManager.MainMovement
Dim UpDown As Single = 0.0F
Dim LeftRight As Single = 0.0F
With mCurrentKeyboardState
If .IsKeyDown(mKeys("MainMovementUp")) Then
UpDown = -1.0F
ElseIf .IsKeyDown(mKeys("MainMovementDown")) Then
UpDown = 1.0F
End If
If .IsKeyDown(mKeys("MainMovementLeft")) Then
LeftRight = -1.0F
ElseIf .IsKeyDown(mKeys("MainMovementRight")) Then
LeftRight = 1.0F
End If
End With
Return New Vector2(LeftRight, UpDown)
End Function
Public Sub Update(ByVal elapsedTime As Single) Implements iInputManager.Update
mPreviousKeyboardState = mCurrentKeyboardState
mCurrentKeyboardState = Keyboard.GetState(PlayerIndex.One)
End Sub
Private Function IsNewKeypress(ByVal key As Keys) As Boolean
Return mCurrentKeyboardState.IsKeyDown(key) AndAlso Not mPreviousKeyboardState.IsKeyDown(key)
End Function
This is far from complete but is a good start. All out input code is now in the one place. We can easily change it without disturbing our existing game code. Our HandleInput methods can now follow the format HandleInput(input as Input.IInputManager).
This class needs some default action (return False) if there is no mapping for a particular key string/name. Also a method for Saving and Loading keymapping from XML files.
Some other ideas I had regarding input:
- KeyboardInputManager & GamePadInputManager could Inherit from GameComponent.
- Or even better - Inherit from an abstract class InputManager that Inherits from GameComponent.
- Create an InputDeviceManager that would maintain a list of available input devices based on what devices are connected ("If GamePad.GetState(PlayerIndex.One).IsConnected Then") or other ones manually added.
- This would allow selection of the currently active device or devices (e.g. keyboard and mouse).
Note: when I created these classes, I had not experimented at all with getting input from the mouse. The interface may need to be tweaked to make it easy to add a MouseInputManager.
The main point I want to get across is the benefits of Encapsulation and Abstraction. Take all the input related code out of your classes and put it into dedicated input classes. Put an interface inbetween so that your classes do not need to know or care about the implementation details.
Of course this does not just relate to Input! The same principles apply to all parts of your game. Look for areas that can be isolated. Create generic Manager classes. It will initially seem like more work but it is worth it in the long run. It makes updates a lot easier (especially when you can use the same set of Manager Classes for multiple games!).
Some examples of Managers that I can think of (and may eventually blog about):
- Input Manager
- InputDeviceManager
- AudioManager
- ScreenManager
- AnimationManager (2D or 3D)
- TexturedQuadManager
Till next time
Happy Coding =)
G
