Keyboard Mapping

Newbie & Debugging Questions
#1

I may be doing this in a completely horrible way, but my idea for my game engine is to create a list that a user can add a KeyMap object to. So, I have a KeyMap class and a KeyMaps class, as shown:
KeyMap

public class KeyMap implements KeyListener 
{
	public void keyPressed(KeyEvent arg0) {}

	public void keyReleased(KeyEvent arg0) {}

	public void keyTyped(KeyEvent arg0) {}
	
	
}

KeyMaps

public class KeyMaps extends JComponent 
{

	// Contains this object
	private static KeyMaps listOfKeyMaps;
	
	// Contains a list of KeyMap objects linked by a 
	// KeyMap title
	private HashMap<String, KeyMap> keyMaps;
	
	// Contains the current KeyMap to use
	private KeyMap activeKeyMap;
	
	private KeyMaps()
	{
		keyMaps = new HashMap<String, KeyMap>();
		activeKeyMap = new SystemKeyMap();
		addKeyMap ("System", activeKeyMap);
		setActiveKeyMap ("System");
	}
	
	public static KeyMaps getInstance()
	{
		if (listOfKeyMaps == null) {
			synchronized (KeyMap.class) {
				if (listOfKeyMaps == null)
					listOfKeyMaps = new KeyMaps();
			}
		}
		
		return listOfKeyMaps;
	}
	
	public void setActiveKeyMap(String newKeyMap)
	{
		if (keyMaps.containsKey(newKeyMap)) {
			removeKeyListener (activeKeyMap);
			activeKeyMap = keyMaps.get (newKeyMap);
			addKeyListener (activeKeyMap);
		}
	}
	
	public boolean addKeyMap(String keymapName, KeyMap km)
	{
		if (keyMaps.containsKey (keymapName))
			return false;
		else {
			keyMaps.put (keymapName, km);
			return true;
		}
	}
	
	public boolean removeKeymap(String keymapName)
	{
		if (keyMaps.containsKey (keymapName))
			return false;
		else {
			keyMaps.remove (keymapName);
			return true;
		}
	}
}

As you can see, my idea is for the user to be able to create a set of KeyListeners to handle KeyEvents. The KeyMaps class would hold this list while maintaining a single active KeyMap, and the ability to easily switch between them (So, you can have a different KeyMap for gameplay, the main menu, mini-games, etc.) My issue is that, I don’t think this works for a reason I’m not aware of. I created a simple KeyMap that exits the program if the use presses esc:

public class SystemKeyMap extends KeyMap
{
	public void keyReleased(KeyEvent ke) {
		if (ke.getKeyCode() == KeyEvent.VK_ESCAPE)
			System.exit (0);
	}
}

You can see in the KeyMaps class that this is automatically created and activated upon starting the program. This is how I’ve implemented it into the actual game:

public abstract class Game
{

	// The game window
	private Screen screen;
	
	// The container for all graphics
	private Canvas canvas;
	
	// Contains a list of KeyMaps
	private KeyMaps keymaps;
	
	/**
	 * Initializes the game window
	 */
	public Game()
	{
		super();
		screen = new Screen();
		canvas = new Canvas();
		screen.add (canvas);
		
		keymaps = KeyMaps.getInstance();
	}

Nothing happens when I press the ESC button. Could I get some insight on why that is?

#2

You need to do this after instantiating your KeyMap:


canvas.addKeyListener(keymaps.getActiveKeyMap());

EDITED: It’s a bit of a weird build you’ve done, and you’ll have to keep changing the keymap associated with your canvas, but that should work, assuming you make a getter for the currently active keymap.

#3

Thanks for the reply!

Your solution worked, though, I needed to add the listener to the screen, not the canvas. Though, that is trivial.
So, is there not a way to add the listeners to the KeyMaps object? Like my code shows? Or is it necessary that the Screen object have it? Due to the focus, I suppose.

#4

Here’s a simple Keyboard class


public class Keyboard implements KeyListener {

    private static HashMap<Integer, Boolean> keyPresses = new HashMap<Integer, Boolean>();
    private static HashMap<Integer, Boolean> keyReleases = new HashMap<Integer, Boolean>();

    public void keyPressed(KeyEvent e){
        keyPresses.put(e.getKeyCode(), true);
        keyReleases.put(e.getKeyCode(), false);
    }

    public void keyReleased(KeyEvent e){
        keyReleases.put(e.getKeyCode(), true);
    }

    public void keyTyped(KeyEvent e){}

    public static boolean isPressed(int keyCode, boolean initialPress){
        if (keyPresses.containsKey(keyCode)){
            boolean bool = keyPresses.get(keyCode);
            if (initialPress){
                bool = bool && !keyReleases.get(keyCode);
                keyPresses.put(keyCode, false);
            }
            return bool;
        }
        return false;
    }

}

See https://code.google.com/p/game-engine-for-java/source/browse/#git%2Fsrc%2Fcom%2Fgej%2Finput for the classes I use in my engine.

#5

Exactly, the focus is controlled by the actual “surface” you’re using, and it is the KeyListener on that, which is activated.

EDIT2: Wow, now I read it again. You’re assigning a new KeyListener for each key you want bound, if I’m reading this correctly. You shouldn’t do that. A KeyListener can report to you which keys are pressed on the entire keyboard, not just for a single key.

Check this and the 2 next videos out. He explains it quite slowly, and the videos can’t be followed as such because they assume you’ve followed the 27 preceeding videos, but just looking at what he does, should get you the right idea about how this works.
Key elements are:

  • He has a class that implements the KeyListener.
  • He makes an instance of this class, and sets it to be the KeyListener on his canvas, window or frame, depending on what you’re doing.
  • Then he can use his KeyListener class to check whether some key is down
  • You should not have your game-class implement KeyListener like he does in this example. You can, but it is easier to abstract it from the code.

I did it like this in my first game, where my Game-class implemented KeyListener:


if(mainPlayerMenu!=null){
	if(abilitiesPanel!=null){
		if(keys[KeyEvent.VK_UP] && playerActivationDelay == 0){
			playerActivationDelay = 12;
			abilitiesPanel.moveUpThroughChoices();
		}
		if(keys[KeyEvent.VK_DOWN] && playerActivationDelay == 0){
			playerActivationDelay = 12;
			abilitiesPanel.moveDownThroughChoices();
		}
}

This is obviously very ugly, so for the next game, I made a class like this:


import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;

public class KeyboardController implements KeyListener {
    private boolean[] keys;

    public KeyboardController(boolean[] keys) {
               this.keys = keys;
    }

    public void keyPressed(KeyEvent e) {
		int status = e.getID(), key = e.getKeyCode();
		if(status == KeyEvent.KEY_PRESSED) {
			if(!keys[key]){
				System.out.println(""+KeyEvent.getKeyText(key));
				keys[key] = true;
			}
		}
		e.consume();
    }

    public void keyReleased(KeyEvent e) {
    	int status = e.getID(), key = e.getKeyCode();
		if(status == KeyEvent.KEY_RELEASED) {
			keys[key] = false;
		}
		e.consume();
    }

	@Override
	public void keyTyped(KeyEvent e) {
		e.consume();
	}
}

The code in my Game-class becomes something like this:


private boolean[] keys = new boolean[256];
private KeyboardController kc;
private int downKey, leftKey, rightKey, jumpKey, ammoKey, switchKey, reloadKey, shootKey, meleeKey;

...

// in init(), I do this
kc = new KeyboardController(keys);

//		initialize controls from player settings
		leftKey = playerSettings.getKeys().get("Left");
		rightKey = playerSettings.getKeys().get("Right");
		downKey = playerSettings.getKeys().get("Down");
		jumpKey = playerSettings.getKeys().get("Jump");
		ammoKey = playerSettings.getKeys().get("ChangeAmmo");
		switchKey = playerSettings.getKeys().get("ChangeWeapon");
		reloadKey = playerSettings.getKeys().get("Reload");
		shootKey = playerSettings.getKeys().get("Shoot");
		meleeKey = playerSettings.getKeys().get("Melee");

...

	        w.addKeyListener(kc);
		w.setFocusTraversalKeysEnabled(false);

// then I have a method called actuateControls() which I call every game-update,
// which does something like this, depending on which state it is in at the time

private void actuateControls() {
		if(state==GAME){
			if(keys[shootKey]){
				game.shoot();
			}
			if(keys[KeyEvent.VK_ESCAPE]){
				stop();
			}
//			............blablabla
		}else if(state == MENU)
//			............blablabla

}
#6

SHC’s listener is very nice too. I just never had the need to know when something was released; only if it is currently pressed.

#7

That’s not correct. Each KeyMap is designed to layout the functionality of the entire keyboard. The reason for a list of them is to easily switch between interfaces while changing what the keys do. Like in my example before, you could have your keys mapped for the game play, and then have a different mapping for when you are navigating menus. Stuff like that.

I’m trying to design the engine in a way where that option is available, but not necessary. Like, the SysemKeyMap that is applied by default could be overwritten and used as the only Listener for the whole game.

#8

I was hoping that was the case :slight_smile: I really shouldn’t read through other people’s code at 5 in the morning ^^

#9

If there is no need to check key releases, then the code is much more simplified.


public class Keyboard implements KeyListener {

    boolean[] keys = new boolean[600]; // 600 keys are defined in the KeyEvent

    public void keyPressed(KeyEvent e){
        keys[e.getKeyCode()] = true;
    }

    public void keyReleased(KeyEvent e){
        keys[e.getKeyCode()] = false;
    }

    public static boolean isPressed(int keyCode){
        return keys[keyCode];
    }

}
#10

You’re right. Actually I don’t see why I ever used the eventID. Must be a remnant of some system I used once.

I was told it was good practice to consume the KeyEvent once you had processed it, though. Is this false?

#11

That does seem a lot simpler. I know my implementation is kind of crude, as far as the actual key presses go. My main concern at the moment was properly implementing my KeyMapping system. Though, I’ll likely be using this method for my actual KeyMap class. Thanks for that!