A keypress is "consumed" by the call to getKey(). If it wasn't, then once you had pressed a key, getKey() would forever after return that same key. If you want to check if a key is being held down, use isKeyDown(...) instead of getKey().

You can only use 'getKey' one each act-cycle. I think of it like the 'getKey' is like a variable which is set at the beginning of an act-cycle. If you call the method from different classes in the same act-cycle, it can't have a different value. (As I said, that's how I think how it could be, doesn't mean it actually is like that). Try to use the 'Greenfoot.isKeyDown' method.

The solution with the Greenfoot.isKeiyDown() works without problems! Thank you. #davmac and #Super_Hippo: In spite of your explanations I can't apprehend the reason for the fail of Greenfoot.getKey(). The two Actor-Instances are be created in the contructor of a World-Subclass. Here the code-snippet: If I only struck (for example) the "left"-key with the duration of 1 second and no other key I think the getKey()-method had to return this key. In the first act-cycle it returns probably "left", in the second act-cycle (for the second instance) it should return also "left". But it doesn't obviously. If the keypress is consumed by the call to getKey(), the method should also return "left" because I struck the key so long (1 second) that the getKey()-method should read and return "left" again. But in the praxis it doesn't works so.

The 'getKey' method only registers keys that are being, or have been, released. When a key is released, that is the instance that a keystroke is placed into a keyboard buffer. When a key is 'fetched' from the buffer (using 'getKey'), the buffer pointer is automatically advanced to the location where the next keystroke is/will be stored. If no keys are in the buffer, 'getKey' will return a 'null' value. The 'isKeyDown' method registers keys that are being held down (in the 'pressed' state).

Before posting this, I thought the getKey-method would only work once for a keystroke right after it was pressed (not released as described by danpost). However, if you put the following in the world's act method, you will see that it starts printing right when you press and it does not stop. It doesn't print every act cycle (unless the speed of the scenario is reduced), but it doesn't only print it out once.

Tested and confirmed. Thanks for the correction, Super_Hippo.

In fact, getKey() will return a key whenever it is typed according to the system. Normally that means once when the key is pressed, but because of "autorepeat" functionality you can hold down a key and have it reported continuously at some particular rate (after an initial delay). This "autorepeat" is not part of Greenfoot, but of your operating system.

I distinctly remember early scenarios I wrote where actors would not move until the key was released when using 'getKey'. It ruined the 'feel' of the game. I think they were in gridded worlds where a keystroke would move you one cell in some direction. Maybe that was a glitch in a version of Windows that was updated and fixed. I do not know.

Okay: Greenfoot.getKey() reacts when a key is pressed down except for the 4 cursor control keys, which react when released. But even if I press a key down several times, the getKey()-method registers it only in the first Actor-Instance ("leftPlayer"). The getKey()-method in the second Actor-Instance ("rightPlayer") doesn't react. I think it should react regardless of whether it is triggered by pressing or releasing a key because I typed the key several times. I have exchanged the cursor control keys (up, down, left and right) with normal letter-keys but this didn't solved the problem. You helped me with your tip to use isKeyDown(...) instead of getKey(). But I still can't comprehend: Why reacts getKey() only in the first Actor-Instance.

It would be misleading if the 'getKey' method continued to return the same key each time it was called. You would not be able to tell how many times that key was actually pressed -- once? twice? ten times? The method, therefore will return an entered key once, and only once. Only the first actor, in your case, to call 'getKey' will actually get the key; all others will get a 'null' value return until the next act cycle begins. Suffice it to say that 'getKey' is more suited for text input and 'isKeyDown' is more suited for game play controls.

Thank you for your explanations. Now I think I understand the reason. 'getKey' checks the keys only once in every act cycle. An act cycle runs the act-methods of the both actor-instances. Hence the first instance gets the entered key. After the 'getKey' returns its value the return storage delets its content by replacing it with null. So if the second instance act-method calls 'getKey' it will return null.

To show in code, with a 'lastKeyTyped' field that is assigned the last key detected as pressed: These lines (without the comments) were taken directly from the 'getKey' method of the KeyboardManager class of the greenfoot source files.