Hi,

I'm just making a litlle Tetris game using Allegro. You'll agree with me : it' easier to play with the keyboard

Thats how I tried to use the keyboard with my program ( apparently, it fail ) :

Firs of all, I installed the keyboard with : al_install_keyboard()
I initilize a "state pointer" : ALLEGRO_KEYBOARD_STATE *etat = NULL;

And I control if LEFT is pressed to output a sentence :

if (al_key_down(state,ALLEGRO_KEY_LEFT)){
cout << "GAUCHE";
}

But last one throw me an error message, telling me that I violate something T_T

Thanks for your future support !

And completely aside from whether you use _STATE or events, you didn't initialize the state to anything useful, you just left it null...

You must do this:

ALLEGRO_KEYBOARD_STATE state;
al_get_keyboard_state(&state);

At that point, you can use the al_key_down function. You need to update (get) the state anytime you want to see if a key has changed, so you would need to call it at least once per logic loop.

Events have the advantage of not losing key strokes if you don't poll enough. Also, it's simple to build key state on top of events, but not the other way around.

The key state is more useful when you want to know if some key is currently held down. The events are more useful if you just want to know when a key was pressed. (e.g., Entering a name in a high score.)

In A4 terms, the events are more like keypressed with readkey, and the state is more like the key array.

Do you get a key up event in that case?

Why can't Allegro 5 just refresh the key states when it regains focus? Allegro 4 did it. And by the way, I immensely prefer reading the key states as opposed to reading the key events. Why should I have to pass a key event to every object that listens for key presses when I could have them just check the global state instead? I mention this because I have an input library for A4 that checks the key states and produces key press/release/held/open states based on them.

One could argue either way on that, with the argument that if you don't you will think that keys that were once pressed are never released perhaps deciding in favour of saying that you should.
But my question was actually much more down-to-earth than that. Assuming the Windows port is the same as the OS X port, we simply pass along events that we receive from the operating system. If the OS never tells us that the key is no longer held down, then we need to do something special. If it does, there is a bug in the recording of the key state (I doubt that, if it's done the same as on OS X anyway, since the keyboard state should be updated as soon as the event is received, but worth checking anyway).
For what it's worth, the behaviour on OS X (with ex_keyboard_events) seems to be that a KEY_UP event is generated the next time the same key is pressed after we regain keyboard focus, which is also weird. Haven't looked into this.

Who says it can't? But the way it currently works is that Allegro keeps track of key up/down events for you. The keyboard state is updated incrementally.
The problem is actually not straightforward. When should Allegro send up/down events (and update the keyboard state)? Probably when the program re-gains focus. In that case you need to compare the keyboard states before and after the switch and then generate events that will make up the differences.

You are free to do that.
After getting used to it, I vastly prefer using the events rather than the state, mostly because with A4, I was converting that into up/down events anyway.

So did I and it now updates them based on the keyboard event it gets passed. It really doesn't make that much of a difference and has the aesthetic advantage of only updating stuff when it knows that there is stuff to update (or we wouldn't have received a keyboard event in the first place). The rest of the time we can idle/sleep.

Right; that's why the update should be done when keyboard focus is returned to the application, not when keyboard focus is lost. Probably.

Ok, thanks to all of you

PS : OMAGAD IT'S WORKIN'
:dance: :dance: :dance:

( Back to a more serious face )