Java game: Key Bindings and the EDT

Question

I'm working on a game in Java. In the game, the player will be able to control a tank that moves on the screen using Key Bindings. Each arrow-button moves the tank in a different direction.

I'd like to know, if the way I used Key Bindings in the program, is correct and isn't supposed to cause problems with the EDT or with anything else later on.

I will explain in short the structure of the program, and how I used Key Bindings.

• There's a Board class, a class that extends JPanel and has most of the game logic. It also displays the graphics.

• There's a KeyBindingsRunnabel class, a class that implements Runnable. This class has all the KeyBindings code.

• Board contains the game-loop. The game loop happens inside a thread. In the thread, but before the game loop, a new thread is created and started, that thread runs KeyBindingsRunnabel.

(There's also a Main class that extends JFrame and creates an instance of Board, but that's irrelevant).

I'll demonstrate all of this in short:

Here is the code for the KeyBindingsRunnabel class:

public class KeyBindingsRunnable implements Runnable {

    Board b;

    Action upAction,leftAction;
    InputMap inputMap;
    ActionMap actionMap;

    public KeyBindingsRunnable (Board b){

        this.b = b;
        inputMap = b.getInputMap();
        actionMap = b.getActionMap();

    public void run() {

        leftAction = new AbstractAction(){
            public void actionPerformed(ActionEvent e){
                // Code to move tank left.
            }
        };

        rightAction = new AbstractAction(){
            public void actionPerformed(ActionEvent e){
                // Code to move tank right.
            }
        };

        inputMap.put(KeyStroke.getKeyStroke("LEFT"),"leftAction");
        inputMap.put(KeyStroke.getKeyStroke("RIGHT"),"rightAction");

        actionMap.put("leftAction",leftAction);
        actionMap.put("rightAction",rightAction);

    }

}

The way the Board class uses KeyBindingsRunnable is as follows:

The Board class also implements Runnable. It contains a thread declaration in it's constructor:

Thread gameloop = new Thread(this);
gameloop.start();

In Board's run() method, there are two thing: a game-loop, and before the loop, the creation of a new thread that runs KeyBindingRunnable.

The run() method of Board looks like this:

public void run(){

    Thread keyBindingsThread = new Thread(new KeyBindingRunnable(this));
    keyBindingsThread.start();

         while(gameIsRunning){
         // The loop.
         // .....
         }

}

My question is: Is this the correct way to use Key Bindings without interupting with the EDT, and in general the correct way?

Is there a more effecient/safer/shorter way of using Key Bindings in a 2D game?

Thanks a lot :)

Answer 1

Too many comments for me to read so I don't know if I'm saying anything new or just repeating something.

The way I see it. KeyBindings are just used to indicate the state of keys on the keyboard.

Take a look at KeyboardAnimtion.java from Motion Using the Keyboard. In that example wen the key is pressed the key is added to the Map and when the key is released the key is removed from the map. That is the sole function of the key bindings, to track the keys that are pressed and the associated movement of that key.

The example then uses a Timer to schedule the animation of the object. When the Timer fires the move() method is invoked and the object is moved based on the keys in the Map.

Swing Timer doesn't allow me to use a type of game-loop that has proven to run the game at constant speed without problems.

There is no reason to use the Timer. If your game does its own looping then you should be able to invoke the move() method directly. However, all this does is control that the repaint request is made at a constant time, it does not guarantee that the painting is done immediately, although normally painting requests should be handled right away unless the system is really busy.

I would start by using the Timer an see what happens.