Full LibGDX Game Tutorial – Input Controller

Sharing is caring!

Full LibGDX Game Tutorial – Input Controller

Welcome to part 6 of our Full LibGDX Game Tutorial. This part will focus on the input controller which will allow us to take input from the user and control objects in game. If you haven’t seen the earlier parts of this tutorial I advise you to start at Full LibGDX Game Tutorial – Project setup as this tutorial continues from these earlier parts. For those of you who have come from part 5, you can continue on.

What is an input controller?

An input controller allows the game to take input from the user such as W,A,S,D keystrokes and then allows us the programmer to control how our game reacts. We can use input controllers to check for keystrokes, mouse locations, mouse button presses etc. We can also use the input controller to query a gamepad but there is already an extension for accessing controllers which makes supporting controllers a lot simpler.

Adding our controller class.

We are going to create the controller class and it will be full of flags for each key, e.g the left arrow key will have a flag, the right arrow key will have a flag etc. This means we can just query our controller’s left or right flag to see if the user wants to go left or right. It also means if we add other control methods say for a gamepad or for a phone’s accelerometer(phone tilt) we can just have them set a left or right flag as well and our game code stays the same. For now, we will just set up controls using the keyboard.

Let’s start by making a class in a new package called controller.

What are all these methods for?

Now we have our class in the new controller package, we want to implement the InputProcessor and add the unimplemented methods. You will end up with some code similar to this.

Here you can several methods that have been added for us. These methods are:

• keyDown
  • This is activated once when a key on the keyboard is pressed down.
• keyUp
  • This as activated once when the key that was pressed down is released.
• keyTyped
  • This is activated everytime the keyboard sends a character. Unlike KeyUp and KeyDown this will be called many times while the key is down.
• touchDown
  • Called when a mouse button or finger(on phone) is pressed down.
• touchUp
  • Called when a finger or mouse button is released.
• touchDragged
  • Called each time the finger or mouse moves while in the down state.
• mouseMoved
  • Called when the mouse moves whether a button is pressed or not.
• scrolled
  • Called when a mouse scroll wheel is moved.

Adding our flags.

The first things we well check for are the left, right, up and down arrows. So let’s add the flags for these:

Here you can see we have added the left, right, up and down all on the same line. This is the same as doing:

Now we have our flags we have to set them to true when those keys are pressed. To do that we’re going to use a switch statement. You’ve seen this before in our orchestrator class to change screens. A switch statement is used to run code based on the variable passed.

Replace your keyDown method with the code above. This will check for the direction arrow keys and return true if a key that we check for was pressed. There is a problem with this code and that is that it only checks for one key at a time. So if a player is pressing up and left, only left will be processed. This is a cool mechanic because it allows you to control how a character is allowed to move. For example, a maze game that only allows left, right, up or down movement could use this code, but for a game like the one we’re making, we want to allow diagonal movement. This is done by adding a flag to say at least one key has been pressed and then checking if the flag has changed after all keys have been checked.

Update your keyDown code again to match the following:

So what have we updated and why did we do it? Well, we added the keyProccesed flag which is false by default. This is then switched to true if any key is pressed. It is then returned at the end. So if a key is pressed the keyProcessed will be true and will return true. However, if no key is pressed keyProcessed is false by default and will return false. We also added a “break;” to the top 3 switch code blocks. This is because a switch statement will go to the first code block that is true and then execute all the code blocks below it. So if there was no “break;” in any of the code blocks and the left key was pressed every block underneath would also be run meaning our controller would think left, right, up and down were all being pressed.

So now our flags are set to true when a key is pressed down but they are never set to false when the key goes back up. We’re going to have to do this again in our keyUp method except this time we set the flag to false.

Setting the controller as the input processor.

We now have a controller that will have our 4 flags for the arrow keys. Now all we have to do is add it to our mainScreen so it can react to the input and the allow our model to access the controller. In your main screen update the following methods:

Here we added a new KeyboardController which is then passed to the model and we added “Gdx.input.setInputProcessor(controller);” to set our controller as the class which processes inputs. So now the main screen is now sending all the inputs it receives to our controller and our model now has a reference to our controller. We just need to update our model to take the controller as an argument and then we can query our controller and make it move items on our game. So let’s update our model:

Here we have updated our model to have a KeyboardController field and set it in our constructor. Now we can access our controller in our model, so let’s make our player who is currently swimming if you’ve been following along with this tutorial do something.

Applying the controls to our character.

Update your logic method to match the following:

You should now have an application that allows you to control the player square with the arrow keys like this video:

[embedyt] http://www.youtube.com/watch?v=GjRIffVvnu0[/embedyt]

So now we can control our player with the keyboard, how can we use the mouse? Well, yet again we’re going to use flags. We will have flags for each button 1(left),2(right) and 3(middle). We will also have a Vector2 which will store our mouse location. Add these fields to our controller and add the necessary imports as usual:

Update all the mouse methods to match the following:

Now we can query the mouse like we query our keyboard keys in our model. Something to note about the mouse position from a controller and the position in the Box2D world is that they are not a direct relation. So your mouse location that you get from the controller is the location it is on the screen and not the location it is pointing to in the world. This is important because when our character moves through the world we will have to adjust the position we get from the controller to match the world. Luckily this is already taken care of in LibGDX using the OrthographicCamera class.

We went over the OrthographicCamera class back in part 3 of this tutorial which told us how the camera shows a part of our world. We can use this to convert our mouse location from a screen position to a world’s position using the unproject method. In order to use the camera in our model, our model will have to have a reference to the camera. So let’s add the camera to our model’s constructor adding imports as needed:

Update your mainScreen constructor to pass the camera to our model like below:

As we might want to check if a click hits any body and not just our player we will add a method that takes a body and the mouse location and returns true if they intersect.

Here we take the body we want to check and the mouse location. We then convert it to a 3D Vector as the unproject method requires a 3D Vector. We then unproject the position and use an if statement to check if the point the mouse clicked is in the first fixture of the body. This isn’t ideal as it only checks the first fixture so bodies with multiple fixtures may not get caught. Now we have our method for checking we can use it in our logic method to output some text when the mouse clicks the player using the following code:

Now we are able to create a world, add objects and players, control our players with the keyboard or mouse clicks. We still need a lot of things before our game starts to take shape such as loading assets, rendering the world and players, player and enemy entities, enemy AI and pathfinding to name a few.

In part 7 we will go into using the asset manager to load our assets such as images and sounds.

← Box2d Contact Listener

— Contents —

Rendering And Asset Manager →

Sharing is caring!