[A5] multiple key events

NiteHackr

I am working on my Allegro 5 game, which is coming along nicely, I am really loving the library.

I do have one "problem" which I am not sure there is a solution to, but I thought I would throw this out there and see if anyone has any ideas.

I had the same "problem" with Allegro 4. It's not a library problem really though, at least I don't think so.

What happens in my Pacman style game is that a player can be moving along, say to the right in the maze. They wish to turn up. They get so wrapped up in the game and the ghosts chasing them that they forget to let go of the right cursor key and press UP key, so they have both keys pressed at the same time. This is fairly common. To their dismay, their character keeps going right and doesn't turn up at all and they end up dying and cursing the programmer.

I have tried to change how I code this, by clearing the key_pressed[] array when a new key is pressed and the player will then turn as expected, even with a new key pressed, but then the game won't respond to the right keypress until that key is released. Now obviously they should have released it and I have advised against holding keys down as you don't need to hold a key down at all in my game, just tap the direction you wish to go then let go of the key and your character will happily travel in that direction unless told otherwise. But is there a better solution to this do you think? I haven't tested if this happens in other games yet. Just thought I would throw this out there just in case there is something I am missing.

Thanks in advance.

Example code I use (edited to keep things brief)

#SelectExpand
  1while(!done && !pacman.dead) {
 al_wait_for_event(event_queue, &event);
  3
 if(event.type == ALLEGRO_EVENT_DISPLAY_CLOSE) {
    done = true;
 }
  7
 // check for key input and process it
 else if(event.type == ALLEGRO_EVENT_KEY_DOWN) {
    al_get_keyboard_state(&keys);
    switch(event.keyboard.keycode) {
       case ALLEGRO_KEY_ESCAPE:
          // Do stuff for ESCAPE (removed for brevity)
          break;
       default:
          pressed_key[event.keyboard.keycode] = true;
    }
 }
 else if(event.type == ALLEGRO_EVENT_KEY_UP) {
    al_get_keyboard_state(&keys);
    pressed_key[event.keyboard.keycode] = false;
 }
 23
 else if(event.type == ALLEGRO_EVENT_TIMER) {
    if(event.timer.source == pacman.timer) {
       redraw = true;
       redraw_timer = al_get_timer_count(setting.redraw_timer);
 28
       if(pressed_key[ALLEGRO_KEY_UP]) {
          // do stuff for up
       }
       else if(pressed_key[ALLEGRO_KEY_DOWN]) {
          // do stuff for down
       }
       if(pressed_key[ALLEGRO_KEY_LEFT]) {
          // do stuff for left
       }
       else if(pressed_key[ALLEGRO_KEY_RIGHT]) {
          // do stuff for right
       }
       if(pressed_key[ALLEGRO_KEY_LCTRL] || pressed_key[ALLEGRO_KEY_RCTRL]) {
          // do stuff for CTRL
       }
       else {
          // do other stuff
       }
       /*** CHEAT KEYS ***
          You don't want to know these :)
       */
       if(setting.cheat_mode) {
       }
 52
       // etc... 

Arthur Kalliokoski

I'd probably have a variable that can only hold 4 states, and the last direction key would set that state. Otherwise, you might check out the keyboard.timestamp field to see which was pressed last.

ph03nix

I modified your code to reflect Arthur's suggestion.

If you want to make it more advanced, you would check which directions are available, and if that key is pressed you allow pacman to move that direction (so if you press left and up and he can only move up, he still moves up)

#SelectExpand
  1//store the direction pacman is moving in
  2int direction = 0;
  3
  4while(!done && !pacman.dead) {
 al_wait_for_event(event_queue, &event);
  6
 if(event.type == ALLEGRO_EVENT_DISPLAY_CLOSE) {
    done = true;
 }
 10
 // check for key input and process it
 else if(event.type == ALLEGRO_EVENT_KEY_DOWN) {
    al_get_keyboard_state(&keys);
    switch(event.keyboard.keycode) {
       case ALLEGRO_KEY_ESCAPE:
          // Do stuff for ESCAPE (removed for brevity)
          break;
       default:
          pressed_key[event.keyboard.keycode] = true;
    }
 }
 else if(event.type == ALLEGRO_EVENT_KEY_UP) {
    al_get_keyboard_state(&keys);
    pressed_key[event.keyboard.keycode] = false;
 }
 26
 else if(event.type == ALLEGRO_EVENT_TIMER) {
    if(event.timer.source == pacman.timer) {
       redraw = true;
       redraw_timer = al_get_timer_count(setting.redraw_timer);
 31
       if(pressed_key[ALLEGRO_KEY_UP){
          direction = 0;
       }else if(pressed_key[ALLEGRO_KEY_DOWN){
          direction = 1;
       }else if(pressed_key[ALLEGRO_KEY_LEFT){
          direction = 2;
       }else if(pressed_key[ALLEGRO_KEY_RIGHT){
          direction = 3;
       }
 41
       //changed to direction instead of key inputs
       if(direction==0) {
          // do stuff for up
       }
       else if(direction==1) {
          // do stuff for down
       }
       else if(direction==2) {
          // do stuff for left
       }
       else if(direction==3) {
          // do stuff for right
       }
       if(pressed_key[ALLEGRO_KEY_LCTRL] || pressed_key[ALLEGRO_KEY_RCTRL]) {
          // do stuff for CTRL
       }
       else {
          // do other stuff
       }
       /*** CHEAT KEYS ***
          You don't want to know these :)
       */
       if(setting.cheat_mode) {
       }
 66
       // etc... 

NiteHackr

Arthur Kalliokoski said:

I'd probably have a variable that can only hold 4 states, and the last direction key would set that state. Otherwise, you might check out the keyboard.timestamp field to see which was pressed last.

Oooh... that looks interesting. I'm just not exactly sure how I would implement it. Make a struct for the key_pressed[] array perhaps which would include a member to store the time it was pressed perhaps...

Edit: ph03nix, I don't see how your code changes anything.

Edit2: Okay, fixed the problem! Thanks for the great idea with the timestamp! I remade my key_pressed[] array so that it used a struct which included a bool for whether or not it was pressed and a double for the timestamp.

I then check the time for each direction and set a direction variable based on which key was pressed most recently and act accordingly...

#SelectExpand
                double timest = 0.0;
                short dir = -1;
  3
                if(pressed_key[ALLEGRO_KEY_UP].down) {
                   timest = pressed_key[ALLEGRO_KEY_UP].time;
                   dir = 0;
                }
                else if(pressed_key[ALLEGRO_KEY_DOWN].down) {
                   if(timest==0) {
                      timest = pressed_key[ALLEGRO_KEY_DOWN].time;
                      dir = 1;
                   }
                   else {
                      if(pressed_key[ALLEGRO_KEY_DOWN].time > timest) {
                         timest = pressed_key[ALLEGRO_KEY_DOWN].time;
                         dir = 1;
                      }
                   }
                }
                if(pressed_key[ALLEGRO_KEY_LEFT].down) {
                   if(timest==0) {
                      timest = pressed_key[ALLEGRO_KEY_LEFT].time;
                      dir = 3;
                   }
                   else {
                      if(pressed_key[ALLEGRO_KEY_LEFT].time > timest) {
                         timest = pressed_key[ALLEGRO_KEY_LEFT].time;
                         dir = 3;
                      }
                   }
                }
                else if(pressed_key[ALLEGRO_KEY_RIGHT].down) {
                   if(timest==0) {
                      timest = pressed_key[ALLEGRO_KEY_RIGHT].time;
                      dir = 4;
                   }
                   else {
                      if(pressed_key[ALLEGRO_KEY_RIGHT].time > timest) {
                         timest = pressed_key[ALLEGRO_KEY_RIGHT].time;
                         dir = 4;
                      }
                   }
                }
 44
                if(dir == 0) {
                   // UP
                }
                else if(dir == 1) {
                   // DOWN
                }
                if(dir == 3) {
                   // LEFT
                }
                else if(dir == 4) {
                   // RIGHT
                }

Thanks for the ideas.

Winfield

Sounds like these gentlemen have you sorted out, but do keep in mind that some keyboards won't correctly report multiple keypresses on the hardware level - I've actually had one or two that report completely incorrect keys when the left and up arrows are pressed - so if anyone reports problems, make sure to rule out the keyboard they're using before you stress too much over your code.

Thomas Fjellstrom

could also just have a direction variable.. as Arthur was aluding to. With an enum for DIR_NORTH, DIR_SOUTH, etc.

NiteHackr

Actually, the direction code won't make a lick of difference because if I am pressing UP and LEFT at the same time, and it hits the code that tests for UP and finds it is pressed, it will set the direction to UP and ignore the other tests, which is what it is doing already.

With the timestamp it sets the time the key was pressed and then can respond to the most recent keypress. I set a direction variable with the new code based on the most recent timestamp.

As for the keyboard problem, I'll keep that in mind, thanks.

Thomas Fjellstrom

You'd set the direction variable when you get the key_down event, so it has the "last key pressed" functionality built in. no need to check a key array or key state.

Arthur Kalliokoski

#SelectExpand
      case ALLEGRO_EVENT_KEY_DOWN:
      {
        int k = event.keyboard.keycode;
  4
        if (k == ALLEGRO_KEY_ESCAPE)
        {
          quit = true;
        }
  9
        else
        if( (k == ALLEGRO_KEY_UP) || (k == ALLEGRO_KEY_PAD_8) )
        {
          direction = NORTH;
        }
 15
        else
        if( (k == ALLEGRO_KEY_LEFT) || (k == ALLEGRO_KEY_PAD_4) )
        {
          direction = WEST;
        }
 21
        else
        if( (k == ALLEGRO_KEY_RIGHT) || (k == ALLEGRO_KEY_PAD_6) )
        {
          direction = EAST;
        }
 27
        else
        if( (k == ALLEGRO_KEY_DOWN) || (k == ALLEGRO_KEY_PAD_2) )
        {
          direction = SOUTH;
        }
 33
        key_array[k] = true;
        break;
      }
 37
      case ALLEGRO_EVENT_KEY_UP:
      {
        key_array[event.keyboard.keycode] = false;
        break;
      }

Bear in mind that you can have several different event loops, based on what you're doing (selecting from menus vs. playing the game, etc.).

NiteHackr

Thomas Fjellstrom said:

You'd set the direction variable when you get the key_down event, so it has the "last key pressed" functionality built in. no need to check a key array or key state.

Ah, okay, I see what you mean now. The key array will hold the fact that both keys are pressed, where as the direction variable is a result of only the last key pressed.

I guess it's a result of rewriting old Allegro 4 code that brought this problem on in the first place.

I'll give that a go then. I suppose had I started programming with Allegro 5 in the first place and never even seen Allegro 4 or earlier this is probably the way I would have went now that I think about it.

Thanks.
It looked the same to me when you first mentioned it, I couldn't understand where there was a difference until now. D'OH

Arthur Kalliokoski said:

Bear in mind that you can have several different event loops, based on what you're doing (selecting from menus vs. playing the game, etc.).

Thanks for that. And I like your idea of adding the keypad, I think I'll add that as well, nice idea.

Thread #613062. Printed from Allegro.cc