How do I respond to keyboard events which occur between polling?

Question

In my games update loop, which happens on a fixed timestep of 30 times per second, I am checking the current state of several keys to determine how to move the player. For example:

if(Keyboard.down(KEY_LEFT) { /* move character left */ }

This works fine in situations where I expect the player to hold the key down for extended periods (such as movement), but for things like shooting, where the player just taps the key quickly, it doesn't always pick up the key being down.

This is due to the key being both pressed and released in the gap between polling.

Now obviously I don't want to trigger my shooting code 30 times a second like I do my moving code, so the solution needs to incorporate some kind of buffering/delay mechanism to make sure each shot is still x milliseconds apart, but I need the first one to register immediately and with certainty.

I am using Javascript, so I can easily use event driven functions linked to keypresses (in fact I am doing this already in order to keep track of which keys are down), but I didn't want to have game logic outside of the fixed timestep update.

Can anyone suggest a solution? I'm not looking for code, more an idea of how to design/structure the code around the problem.

Answer 1

Use the event driven API already provided for you, but instead of executing the events immediatly, queue and batch them to be executed in the next update iteration.

Here's an example in C# which I suppose you'll be capable of adapting to Javascript. In this case all events will be executed during the next frame after they were created:

var keyEventQueue = new List<Pair<object, KeyEventArgs>>();

private void OnKeyPress(object sender, KeyEventArgs e)
{
    keyEventQueue.Add(new Pair(sender, e));
}

public void Update(float elapsed)
{
    foreach(var evt in keyEventQueue) 
    {
        // Handle evt
    }
    eventQueue.Clear();
}

But if you'd like to ensure that there's at least one frame of delay between each event being handled, you simply need to change the Update method to:

public void Update(float elapsed)
{
    if(keyEventQueue.Count > 0)
    {
        var evt = keyEventQueue[0];
        // Handle evt
        keyEventQueue.RemoveAt(0);
    }
}

Answer 2

That's the reason why APIs usually export things like KeyDown and KeyUp (or KeyPressed / KeyReleased). That way you don't check if a key is currently pressed, but its derivative. You then bind the action "Fire" to "KeyPressed", and the problem doesn't even exist.

Answer 3

What's you problem with having that little firing code not being in you timestep update? I'd model my gamestate object to have a firePressed function that I call from the keyPressed event handler, that firePressed will create a new bullet or whatever it is and in the game's timesteop update I'd only do stuff like expiring bullets wether the hit something or went outside the viewfield.

Answer 4

to get a pattern like that:

if (keyDown[KEYCODE_ENTER]) ...

you should attach event handlers for keydown and keyup. the event handlers respectively set/unset a property on an object (keyDown in the following example):

var keyDown = {};
document.attachEventHandler('keydown', function(event) {
    keyDown[ev.keyCode || ev.which] = true;
}, false);
document.attachEventHandler('keyup', function(event) {
    keyDown[ev.keyCode || ev.which] = false;
}, false);