In this section, you will modify the Turtle class so that the joystick of a gamepad can be used to move the turtle. In particular, this will allow you to precisely control both the speed and the angle of motion of the turtle, which is not possible when using keyboard controls alone. This process will require you to retrieve the instance of the active Controller object. The Controllers class provides the static utility method getControllers, which will help you with this process. Once the Controller has been obtained, you can poll for the state of joysticks, buttons, directional pads, and trigger buttons by using one of four provided get-style methods . Many of these require a single parameter: a constant value that corresponds to a component of the gamepad. These values are gamepad specific, and a particular gamepad might even have different values for different operating systems. The most robust method for determining these values is to allow the player to configure the gamepad mapping at runtime by looping through the different actions required by the game, asking the player to press the corresponding button, and storing the values for later use. For simplicity, you will assume that the player will use an Xbox 360–style controller (which includes those such as the Logitech F310 controller mentioned earlier), and you will create a class to store the constant values corresponding to the various gamepad components for this model. Open the Starfish Collector Gamepad project in BlueJ and create a new class named XBoxGamepad with the following code:

The following Controller class methods are available to poll the state of a gamepad component:

To begin incorporating this new functionality into your project, in the Turtle class , add the following import statements:

Next, you will modify some of the code in the act method, which is where the continuous input is processed. In the following code, you check to see whether a controller is connected by testing whether the Array of controllers (retrieved by the getControllers method) contains at least one element; if not, the else block contains the keyboard controls you previously created as a fallback. If a single gamepad is connected, you retrieve it by getting the zeroth element of the array. Then, you determine the amount that the left analog joystick is being pressed in the x and y directions (remembering to negate the y value as mentioned previously), using the constants defined in the XBoxGamepad class you created earlier. Those values are then used to create a Vector2 object, which represents the direction in which the joystick is being pressed. You then need to check whether the joystick has moved passed a certain threshold (called the deadzone , used to compensate for controller sensitivity, typically set to a value between 10 and 20 percent), which can be determined by checking the length of the vector. If it passes this test, then you set the speed of the turtle to a fraction of its maximum speed (using the length of the direction vector as the percentage) and set the angle of motion of the turtle to the angle in which the direction vector is pointing. To accomplish these tasks, add the following code to the act method of the Turtle class , noting that the code corresponding to processing keyboard input should be moved into the else block:

If you have an XBox 360–style gamepad available, you can test the code at this point.

Next, you will write the code necessary to process discrete gamepad input events. To avoid modifying your existing BaseScreen class , you will create an extension of this class that implements the ControllerListener interface with default versions of all the necessary methods, which can then be overridden as needed. (In practice, you will probably only make use of the buttonDown method.) Any class that uses gamepad input can then extend this new class instead of the original BaseScreen class. To begin, create a new class named BaseGamepadScreen with the following code:

Note that this class must be declared as abstract because it does not implement the initialize or update methods from the BaseScreen class . Also note that the listener is “activated” by adding the currently active Screen to the set of listeners managed by the Controllers class. At the same time, you must also remove (via the clearListeners method) any previously added ControllerListener objects ; you don’t want other Screen objects that may be inactive (but still reside in memory) to respond to input, because this could cause unexpected problems. (For example, if pressing the Start button on a gamepad were used to begin a new game from the menu screen, after switching to the game screen you would no longer want this action to occur when pressing the gamepad Start button; therefore, you must stop the menu screen from “listening” and responding to these events.)

Next, you want to modify the LevelScreen class so that pressing the Back key on the gamepad will restart the level (similar to clicking on the Restart button in the top-right corner of the user interface). This requires three steps. First, in the LevelScreen class, add the following import statement:

Next, change the class declaration so that it extends the BaseGamepadScreen class rather than the BaseScreen class, as follows:

Finally, you need to add a buttonDown method to this class to process discrete gamepad button presses (analogous to how the keyDown method processes discrete keyboard key presses). Add the following method to the LevelScreen class:

That’s all there is to it! Feel free to test out your project once again; move the turtle and collect some starfish, and then press the Back button on the gamepad to reset the level, thus enabling you to enjoy collecting the starfish all over again.

To begin, make another copy of your Starfish Collector project from Chapter 5 and rename this one to Starfish Collector Touchscreen. Download the source code for this project from the book’s website and copy the contents of the downloaded project’s assets folder into your new project’s assets folder. In particular, there are three new images, corresponding to the additions seen in Figure 13-4. (You do not need to copy the contents of the +libs folder; unlike the gamepad project from the first half of this chapter, there are no new JAR files required.)

Your first goal will be to reconfigure where the stages will be displayed on the screen and to add a new stage and table to contain the touch controls. You will need to resize the LevelScreen window to 800 by 800 pixels, reserving the lower 800 by 200 pixels for the touch controls, but to minimize the number of changes you need to make, you will keep the other screens at their original size. In addition, you will want to render the game world in an 800 by 600 region, with its lower-left corner starting at the point (0, 200); this rendering area can be set using a method called glViewport, as you will see later. As a first step, in the BaseScreen class, you need to set the size of the main and user interface stages using a FitViewport object, for otherwise they will default to the size of the entire window (which has been acceptable for previous projects, but will not be for this project). In the BaseScreen class, add the following import statement:

In the BaseScreen constructor, change the lines of code that initialize the mainStage and uiStage objects to the following:

Next, you need to create the stage and table for the controls and determine where everything will be rendered. As in the previous project, you will create an extension of the BaseScreen class, called BaseTouchScreen, which incorporates these new elements and overrides the render method. Unlike the BaseScreen class, however, you will not initialize the stage and table in the BaseTouchScreen constructor method. This is because the BaseTouchScreen constructor immediately and automatically calls the BaseScreen constructor, which in turn calls the initialize method (which is where you will add components to the stage and table), and only after this does the program flow return to execute the rest of the code in the BaseTouchScreen constructor. Due to this unavoidable order of execution, you will create a separate method called initializeControlArea that sets up the stage and table that will contain the controls, and you will call this method from the initialize method in the LevelScreen class. You also need to make sure that the new stage is able to process discrete input by adding it to and removing it from the game’s InputMultiplexer at the appropriate times, which takes place in the show and hide methods. In addition, to avoid the complexity of translating touch/mouse coordinates to viewport coordinates, the stage containing the controls will be the same height as the window, even though only the lower 200 pixels will be used. To implement these features, create a new class called BaseTouchScreen with the following code:

The next steps are to add a joystick-like control, represented by the Touchpad class, and move the Reset button to controlStage, which is covered in the following section.

Touchpad objects are rendered using two images : one representing the background, and the other representing the knob. The user can touch (or click) the knob and drag it off-center; its movement is constrained to a circular area contained within the rectangular region defined by the background image.

These objects require two parameters to be initialized. First, you supply a value for the deadzone radius —the minimal distance (in pixels) the knob must be dragged in order for any change to register. (This is the same deadzone concept as was discussed earlier in the gamepad section of this chapter.) This is useful for situations when the player wants to leave a finger on the touchpad but also wants the character to remain still. Without a deadzone setting , the controls would be too sensitive for this to be possible. It is unlikely that the average player would have pixel-perfect finger positioning to keep the knob exactly centered, and the result would be unwanted (and possibly player-frustrating) drift of the character being controlled.

Second, the images used in a Touchpad object are stored in a TouchpadStyle object, which contains two images, both stored as Drawable objects , as is standard for UI elements in LibGDX; you encountered this situation before when creating the image for the Restart button object. As before, you will load each image into a Texture object then convert it to a TextureRegion and then a TextureRegionDrawable.

To begin these additions, in the LevelScreen class, change the class declaration so that it extends your newly created BaseTouchScreen class instead of BaseScreen as follows:

Also, add the following variable declaration:

Then, in the initialize method , add the following code to change the size of the window, activate the function that sets up the control stage and table, and add a background image :

After this, add the following code to set up the Touchpad object, with a deadzone radius of 5 pixels:

Next, add the touchpad and the Restart button to controlTable as follows. Note the addition of an empty row with height 600, which is used to keep the controls in the lower 200 pixels of the window (which has height 800).

Now, in order to make use of the touchpad data, in the update method, add the following code, which stores the touchpad knob displacement data in a vector, using the length of the vector to set the turtle’s speed to a percentage of its maximum speed (100 pixels/second) and the angle of the vector to set the turtle’s direction of motion. This code is similar to the code from the earlier section on gamepad controllers, except that the Touchpad class itself handles the deadzone calculation, so it does not appear in the comparison here:

Finally, since you are using the touchpad to control the turtle’s motion, you can delete the lines of code in the Turtle class act method that check for keyboard input and set the acceleration of the turtle. At this point, the Starfish Collector game should now render as shown in Figure 13-4, and you are ready to test your program, using the mouse to control the touchpad that now moves the turtle.