Find out which key was pressed.

Hello, I am trying to find out which key the player pressed.
So something like Input.inputString, except for all keys, not just for letters and numbers. So for example if the player presses F1 i want the key number, or some unique hash or something.

And i'm NOT trying to find out if he pressed some specific key like R or something, i want to get the number (or something) of any key he pressed.

Thanks

 

This is actually harder than you'd think it'd be. You can do it with the immediate mode GUI by using this: http://docs.unity3d.com/ScriptReference/Event-keyCode.html

 

Damn, that is pretty unfortunate. I tried it and the OnGui gets executed twice for every update and not only that, in half of them the keycode is returned as None even though i am holding the key down. Luckily i can work easily around that, but still it is pretty hacky and i can't believe they don't give us Input.keyCode

 

Not efficient code, but, this will get you the current KeyCode pressed

Code (CSharp):

1. foreach(KeyCode kcode in Enum.GetValues(typeof(KeyCode)))
2. {
3.     if (Input.GetKey(kcode))
4.         Debug.Log("KeyCode down: " + kcode);
5. }

EDIT: by "not efficient", I mean this should not be run within the game loop to detect input. There are 321 KeyCodes to loop through. If you were maybe doing user control remapping in an options menu, this could be useable. If we knew your use case, there may be a more elegant solution to what you are trying to do

 

Yeah I'd definitely not go that route.

You'll probably have to combine it with checks to make sure the current event is actually a keyboard event

Code (csharp):

1.  
2. void OnGUI()
3. {
4.     if (Event.current.isKey && Event.current.type == EventType.KeyDown)
5.     {
6.         Debug.Log(Event.current.keyCode);
7.     }
8. }
9.  

 

Actually, if you do some testing, looping through all the keycodes is far more efficient than the OnGUI route. Just having an OnGUI call in your scripts will cause memory allocations every frame which will eventually need to be collected by the garbage collector causing periodic slowdowns. Checking 321 keycodes takes next to no time in comparison.

But do not get your keycode list every update. That will generate allocations as well. Call Enum.GetValues(typeof(KeyCode)) once on start and store those values for the duratiton.

 

Except there are keycodes that can map to the same key so you have the potential for multiple "true" scenarios. And you could pick up mouse/joystick events.

I doubt this very much. How did you prove this and what's your definition of "far more efficient"?

 

Simply filter them out with your own keycode list that excludes these.

From another post of mine from last year:

Just for fun I profiled it:

Code (csharp):

1. // Keyboard polling: 9.504352E-06 s / frame
2. // (as timed, avg of 1000 frames, profiler reports 0.00 ms)
3.  
4. private int[] values;
5. private bool[] keys;
6.  
7. void Awake() {
8.     values = (int[])System.Enum.GetValues(typeof(KeyCode));
9.     keys = new bool[values.Length];
10. }
11.  
12. void Update() {
13.     for(int i = 0; i < values.Length; i++) {
14.         keys[i] = Input.GetKey((KeyCode)values[i]);
15.     }
16. }

Code (csharp):

1. // OnGUI: 0.02 ms (as reported by profiler), 336 bytes GC / frame
2. void OnGUI() {
3.     // there is no code in here
4. }

Keyboard polling is more efficient.

 

Interesting - and certainly a concern if you're not targeting desktop platforms.

 

if you want to know what character key is pressed
you can go for a textinput
an invisible textinput that detects wich key you pressed
you simply add a on value changed mathod
then you read whats in textfield and empty it again
but you should make sure that you keep the input text selected and focused

 

Please don't necropost a 3-year-old thread just to post a solution that's significantly inferior to @guavaman 's solution that was posted up above.

 

Literally the worst possible solution to that problem.....

 

Far from ideal, but a very clever dirty hack indeed ^^

 

See my comment above about not posting an inferior solution to an old thread. Your solution was already posted in this thread verbatim and then proven to be inferior.

See @guavaman's comment above for information about why your solution is inferior.

I mean, basically, just read the thread before you reply to it.

 

Has just loggind to say that you are my hero, thanks, glad to you i have found name of button which i have searching for a day! Thanks

 

I would add an Input.anyKeyDown check around the for loop, so the for loop would only be called when there actually is a key pressed down and not with every Update call, like so:

Code (csharp):

1. private int[] values;
2. private bool[] keys;
3.  
4. void Awake() {
5.     values = (int[])System.Enum.GetValues(typeof(KeyCode));
6.     keys = new bool[values.Length];
7. }
8.  
9. void Update() {
10.     if (Input.anyKeyDown)
11.     {
12.         for(int i = 0; i < values.Length; i++) {
13.             keys[i] = Input.GetKey((KeyCode)values[i]);
14.         }
15.     }
16. }

 

My current solution after reading all the comments would be:

Code (csharp):

1. private readonly Array keyCodes = Enum.GetValues(typeof(KeyCode));
2.  
3. void Update()
4. {
5.     if (Input.anyKeyDown)
6.     {
7.         foreach (KeyCode keyCode in keyCodes)
8.         {
9.             if (Input.GetKey(keyCode)) {
10.                 Debug.Log("KeyCode down: " + keyCode);
11.                 break;
12.             }
13.         }
14.     }
15. }

 

Dirty, yes. Ideal, no. Clever, also no. There's an input system for a reason...

Have you benchmarked that this has any considerable gain on performance?

 

to be fair that input system should allow a function like Input.getKeyUp, I have to say that danesh is at least showing more insight with that neat hack that the unity team forcing the user to go through a 3-year quest to get to a solution that doesn't use OnGUI, you know, like getKeyDown

 

I was wrong, it's still not working properly, maybe in 3 more years

 

It's not considerable (didn't know that was a requirement???), but there is a gain yes.
I don't need to do a benchmark to know it will be quicker (though not considerably), because the for loop will not be called on every update, and it will not continue to go through all possible key codes, once a key code has been matched.
Common sense.

 

Oh? You know how Input.anyKeyDown works internally, do you? Are you certain that Input.anyKeyDown doesn't do a loop through all the possible keys exactly like this does, essentially meaning that your suggestion would just do the exact same thing twice? Are you certain that Input.anyKeyDown is well-optimized? Did you write it yourself?

I'm not saying that that's how Input.anyKeyDown works, but it's certainly possible that it is. It's possible that your method is faster; it's possible that it isn't. And you can't know which is the case without profiling.

Quit trying to act like you know it all, because you don't. I'm not saying that to you specifically, but rather as a general point about programming.... and knowledge in general I suppose. You don't know it all, and you never will. Neither will I. Always consider the possibility that your "common sense" is wrong, especially when it comes to efficiency, because CPUs are not intuitive.

 

Wow ... this is exactly why I usually stay clear from forums! What an emotional reaction on just some code! And the comment I made had nothing to do with the Input.anyKeyDown. Read my response properly, before starting to attack and offend people.

I am going to play with the new Input system now and stop trying to help people ... *sigh*

 

@AnnePostma, ignore StarManta, I thought your suggestion was on the money and profiled it myself, it did make things faster.

It's a pity someone with 7000+ posts didn't actually contribute any new ideas or constructive input to this thread yet managed to scare off a literal 1st poster (daneshvar1998) who seems to have never come back and yourself who had all of 6 posts at the time.

If we had more posts by people like you and less from people like StarManta I think this forum would be a much better community. I'd certainly visit and contribute more often.

Here's my revision, it also removes mouse and joystick keycodes and casts to a typed array so the look doesn't have to have a cast in it:

Code (CSharp):

1.  
2. private static readonly KeyCode[] keyCodes = Enum.GetValues(typeof(KeyCode))
3.                                                  .Cast<KeyCode>()
4.                                                  .Where(k => ((int)k < (int)KeyCode.Mouse0))
5.                                                  .ToArray();
6.  
7. private static KeyCode? GetCurrentKeyDown()
8. {
9.     if (!Input.anyKey)
10.     {
11.         return null;
12.     }
13.  
14.     for (int i = 0; i < keyCodes.Length; i++)
15.     {
16.         if (Input.GetKey(keyCodes[i]))
17.         {
18.             return keyCodes[i];
19.         }
20.     }
21.     return null;
22. }
23.  

This also trims about 170 keycodes from the list for mouse and joystick codes which might return false positives and casts the list to the correct type to avoid having the foreach do the cast. The

< (int)KeyCode.Mouse0

but trims the mouse and joystick codes as they're all at the end of the enumeration (323 to 509). A little hacky but I think that usage is ok because keyboards aren't likely to grow new keys and unity would not risk breaking changes in re-numbering such an often used enumeration.

Note this will run every frame when held down, change line 9 anyKey to anyKeyDown for it to only return once then null every other frame till the next time a key is pressed.

Profiling results (4.7 GHz i7 8700K):
My solution - Key held down - 0.2 microseconds to 4.8 microseconds (1000 microseconds = 1 millisecond).
My solution - No keys down - 0.06 microseconds.
Previous Solution - 6.9 microseconds every frame, key down or not.

Splitting hairs on a my desktop rig but you want every last cycle on some form factors - I've seen similar micro optimizations effecting constant time performance add measurable minutes in battery life.

I also think necroing threads, no matter how old, is actually really important because threads like this tend to have high google rankings so keeping them current and fresh is vital to keeping the number of repeat questions to a minimum.

 

No. A big no. This is like shooting your self on the foot on purpose.

 

I agree. I sometimes found interesting answers on very old posts that get refreshed years after years.

I was not ready for this amount of arrogance today, i have to say this thread brought me some fun.

 

Couldn't agree more. We need more kindess in the world nowadays. Especially nowadays. StarManta should certainly work on their attitude...

Thank you for your contribution. I actually decided to improve on your solution as well, although it's more cosmetic I think. Basically I decided to create a class out of it that contains your solution, albeit modified. I noticed you only return the first key. However slight the possibility of hitting two keys on the same frame is, it is not zero. For GetKey() it shouldn't matter that much, although for GetKeyDown() it will make program omit the key entirely. My solution is to yield return the key instead, making it an IEnumerable. If someone wants the first one anyway, they can always call FirstOrDefault() on the result.

To my surprise, UnityEngine.Input seems to lack anyKeyUp flag. So for checking list of just released keys - no speed up, sorry. Unless I'm missing something heavily Hope this will help someone.

Code (CSharp):

1. public static class UltiInput
2. {
3.     static readonly KeyCode[] _keyCodes =
4.         System.Enum.GetValues(typeof(KeyCode))
5.             .Cast<KeyCode>()
6.             .Where(k => ((int)k < (int)KeyCode.Mouse0))
7.             .ToArray();
8.  
9.     public static IEnumerable<KeyCode> GetCurrentKeysDown()
10.     {
11.         if (Input.anyKeyDown)
12.             for (int i = 0; i < _keyCodes.Length; i++)
13.                 if (Input.GetKeyDown(_keyCodes[i]))
14.                     yield return _keyCodes[i];
15.     }
16.  
17.     public static IEnumerable<KeyCode> GetCurrentKeys()
18.     {
19.         if (Input.anyKey)
20.             for (int i = 0; i < _keyCodes.Length; i++)
21.                 if (Input.GetKey(_keyCodes[i]))
22.                     yield return _keyCodes[i];
23.     }
24.  
25.     public static IEnumerable<KeyCode> GetCurrentKeysUp()
26.     {
27.         for (int i = 0; i < _keyCodes.Length; i++)
28.             if (Input.GetKeyUp(_keyCodes[i]))
29.                 yield return _keyCodes[i];
30.     }
31. }

EDIT: What's more interesting, KeyCode with int representation 0, is actually... KeyCode.None! which makes it being returned by FirstOrDefault() if the enumeration is empty. Also this looks like a better candidate for your function result, if there's no key pressed, instead of null. Therefore nullable return type is not really necessary.

 

With thanks to: @DeloitteCam @AnnePostma and of course @guavaman ... here's what I believe should have been built-in to Unity 10 years ago: KeyUp, KeyDown, and KeyPress, all working nicely:

Code (CSharp):

1. using System;
2. using UnityEngine;
3. using System.Collections;
4. using System.Collections.Generic;
5. using System.Linq;
6. using UnityEngine.Events;
7.  
8. /**
9. * Because Unity refused to fix their bugs in Input.*, didn't fix the missing methods in UI.* text-input classes,
10. * and instead started work on a new InputSystem that still isn't complete and live :).
11. *
12. * c.f. https://forum.unity.com/threads/find-out-which-key-was-pressed.385250/
13. */
14. public class UnityBugInputFieldKeypressListener : MonoBehaviour
15. {
16.     [Serializable]
17.     public class KeyCodeEvent : UnityEvent<KeyCode>
18.     {
19.     }
20.  
21.     public KeyCodeEvent keyDownListener,keyUpListener,keyPressListener;
22.  
23.     private static readonly KeyCode[] keyCodes = Enum.GetValues(typeof(KeyCode))
24.         .Cast<KeyCode>()
25.         .Where(k => ((int)k < (int)KeyCode.Mouse0))
26.         .ToArray();
27.  
28.     private List<KeyCode> _keysDown;
29.  
30.     public void OnEnable()
31.     {
32.         _keysDown = new List<KeyCode>();
33.     }
34.     public void OnDisable()
35.     {
36.         _keysDown = null;
37.     }
38.  
39.     public void Update()
40.     {
41.         if( Input.anyKeyDown )
42.         {
43.             for (int i = 0; i < keyCodes.Length; i++)
44.             {
45.                 KeyCode kc = keyCodes[i];
46.                 if (Input.GetKeyDown(kc))
47.                 {
48.                     _keysDown.Add(kc);
49.                     keyDownListener?.Invoke( kc );
50.                 }
51.             }          
52.         }
53.  
54.         if( _keysDown.Count > 0 )
55.         {
56.             for( int i=0; i<_keysDown.Count; i++ )
57.             {
58.                 KeyCode kc = _keysDown[i];
59.                 if( Input.GetKeyUp(kc) )
60.                 {
61.                     _keysDown.RemoveAt(i);
62.                     i--;
63.                     keyUpListener?.Invoke(kc);
64.                     keyPressListener?.Invoke(kc);
65.                 }
66.             }
67.         }
68.     }
69. }

With this, you can simply subscribe (both in Editor GUI/Inspector, and in code), to whichever callback you wanted:

KeyDownListener
KeyUpListener
KeyPressListener

...and you'll get the callbacks correctly.

 

You should note that you need to make sure you include "using System.Linq;" at the top of your code (or where ever you put your "using" statements) in order for the ".Cast<KeyCode>()" on line 3 to be recognized. Otherwise you will get an error saying that "Array does not contain a definition for "Cast"...".

 

Well, I mean, you might be right, apart from in the documentation where it explicitly states that anyKeyDown is a property with type bool and not a method.

But do tell how you think

.loop
cmp;
cmp;
cmp;
jmp .loop;

is going to be more efficient than

cmp;
jge .loop;

 

Why do you bump this thread? You know that a property is a method / set of methods, right? So I don't get your point.

While I'm pretty sure that anyKeyDown most likely will just check a flag on the native side, we don't know the implemenation of the get method. It's often not clear what a property does behind the scenes. Like the touches property which explicitly allocates a new array each time it's read. So here it's better to use touchCount and GetTouch in a loop.

So even StarManta might have overreacted a little bit, I'm more on his side. If you don't know the exact implementation of a method you have to profile / benchmark your code in order to know what is faster. Keep in mind that StarManta mainly objected the statement:

 

I responded because I wanted to? Actually, I wanted to figure out how Unity is handling keybindings which brought me here. Anne shared sound advice and instead of thanking her for that dude decided he was going to try to trip them up and then berated them for being a "know it all" because they're smart enough to know they don't need to benchmark every thing in the world.

And I'm aware, but you shouldn't use properties like that, and it's irrelevant either way because literally two lines later the docs say "You should be polling this variable from the Update function, since the state gets reset each frame." which tells us pretty clearly how it's being used and how we should use it.

You don't need to profile everything to know what's good code and what's bad, you CAN use logic and common sense, and you SHOULD use logic and common sense first before wasting your time benchmarking.

Let's say there are 325 possible keys, and now we KNOW from the docs that there isn't any crazy stuff going with the anyKeyDown function, it's simply cmp and jmp if true. Let's say that's 2 instructions and we'll be generous and say that every instruction takes the same amount of time.

If I run a loop that tests every single key, I have to perform at minimum those same 2 instructions x 325 = 650 instructions every single frame. If I have 30 fps that means every second I have to perform 19,500 instructions.

If instead I'm using the code that the dude freaked out about, the worst case scenario is that I will need to do (2x325+2)*30 instructions per second, or 19,560 instructions. This worst case scenario would be when the user is holding down a key, I lose 60 instructions.

If there is even ONE frame in a second where the user was not pressing a key however, rather than using 19,500 instructions we will only use 18,910 instructions. I.E. if you take your finger off the keyboard for even a fraction of a second to pick your nose, we have already reduced the number of instructions hundreds of times more than it would have been and that's even before we start accounting for other inefficiencies in the code.

 

So...this example doesn't make a ton of sense. If anyKeyDown enumerates every key code to check (which, I agree with you, it probably doesn't) then a frame with no input is going to use the same number of instructions whether or not you check first or enumerate directly yourself. You're basically saying "If I check the property that enumerates before enumerating and it returns false then I only have to do 1 enumeration." which - yeah, you'd only do 1 enumeration if you did it yourself directly in the first place.

StarManta probably could have worded his response better but I do agree with the general sentiment. If you say "Do this because it's faster" and I ask "how much faster" and you can't tell me or even worse say "I don't have to see how much faster because I just know" then I'm going to push back on your assertion.

With all that said, this example is a bit contrived and there are better contributions in the thread about polling input.

 

I know it's an old thread, but if anyone is still looking for a solution:

Code (CSharp):

1.  
2. private void Update()
3. {
4.     checkInput();
5. }
6.  
7. private void checkInput(){
8.         if (!Input.anyKeyDown)
9.             return;
10.  
11.         foreach (KeyCode key in listOfMinigameInput)
12.             if (Input.GetKeyDown(key))
13.                 switch (key)
14.                 {
15.                     case KeyCode.W:
16.                         Debug.Log($"Pressed {key}");
17.                         break;
18.                     case KeyCode.A:
19.                         Debug.Log($"Pressed {key}");
20.                         break;
21.                     case KeyCode.S:
22.                         Debug.Log($"Pressed {key}");
23.                         break;
24.                     case KeyCode.D:
25.                         Debug.Log($"Pressed {key}");
26.                         break;
27.                     default:
28.                         Debug.Log("No key was pressed");
29.                         break;
30.                 }
31. }
32.                 }

listOfMinigameInput being an array of KeyCode, in my case like so:

Code (CSharp):

1. private KeyCode[] listOfMinigameInput = new KeyCode[4]
2.     {
3.         KeyCode.W,
4.         KeyCode.A,
5.         KeyCode.S,
6.         KeyCode.D
7.     };

extend on this as you need

 

I'm sure you intended well, but ... as far as I can see you've taken the already-posted solution, removed all the good bits, and you're presenting something that cannot solve the original problem in any way?

Please don't post stuff that adds nothing and drives the solution backwards.

 

Yes it works but i have a question why are their 2 messages printed to the console, the first being "the key code" and the second being the message "none". Although this second message appears only for a few keys.

 

There is a valid None keycode - https://docs.unity3d.com/ScriptReference/KeyCode.None.html

Maybe you have a weird keyboard and Unity doesn't understand what key you're pressing.

 

The None keycode is used when you get an additional "character event". There is no seperate event type for characters. If you get a KeyDown event and the keycode is None, it's probably a character event and you should check the character property if you're interested in the character. If not, just ignore None keycodes.

 

This is what happens when the space key is pressed twice. So i just don't get wat the problem is and also
my keyboard is a standard Ansi Keyboard with a window's OS.

 

Ok...Thank you will do

 

So I went ahead and slightly adjusted code from
Sushi271 answer:

Code (CSharp):

1.  using System.Collections.Generic;
2.     using System.Linq;
3.     using UnityEngine;
4.  
5.     /// <summary>
6.     /// Util to help determine current keyboard keys pressed.
7.     /// Does not support mouse and joystick key codes
8.     /// </summary>
9.     public static class KeyboardInputHelper
10.     {
11.         static readonly KeyCode[] _keyCodes =
12.             System.Enum.GetValues(typeof(KeyCode))
13.                 .Cast<KeyCode>()
14.                 .Where(k => k < KeyCode.Mouse0)
15.                 .ToArray();
16.  
17.         /// <summary>
18.         /// Get information about interesting keys pressed
19.         /// </summary>
20.         /// <param name="interestingCodes"></param>
21.         /// <returns>True if any of provided keys is down</returns>
22.         public static bool IsAnyKeyDown(params KeyCode[] interestingCodes)
23.         {
24.             return Enumerable.Intersect(GetCurrentKeys(), interestingCodes).Any();
25.         }
26.  
27.         /// <summary>
28.         /// Get information about interesting keys pressed
29.         /// </summary>
30.         /// <param name="interestingCodes">Interesting key codes</param>
31.         /// <returns>True if all of provided keys is down</returns>
32.         public static bool IsAllKeyDown(params KeyCode[] interestingCodes)
33.         {
34.             return Enumerable.SequenceEqual(GetCurrentKeys(), interestingCodes);
35.         }
36.  
37.         /// <summary>
38.         /// Get current keys pressed on keyboard including special keys like <see cref="KeyCode.LeftControl"/>
39.         /// </summary>
40.         /// <returns>Iterator with pressed keys. If nothing is pressed, empty iterator is returned</returns>
41.         /// <remarks>Be careful with FirstOrDefault. It will return KeyCode.None if nothing is pressed because of its implementation</remarks>
42.         public static IEnumerable<KeyCode> GetCurrentKeys()
43.         {
44.             if (Input.anyKeyDown)
45.             {
46.                 for (int i = 0; i < _keyCodes.Length; i++)
47.                     if (Input.GetKey(_keyCodes[i]))
48.                         yield return _keyCodes[i];
49.             }
50.         }
51.  
52.         /// <summary>
53.         /// Get current keys unpressed on keyboard including special keys like <see cref="KeyCode.LeftControl"/>
54.         /// </summary>
55.         /// <returns>Iterator with unpressed keys. If nothing is pressed, empty iterator is returned</returns>
56.         /// <remarks>Be careful with FirstOrDefault. It will return KeyCode.None if nothing is pressed because of its implementation</remarks>
57.         public static IEnumerable<KeyCode> GetCurrentKeysUp()
58.         {
59.             for (int i = 0; i < _keyCodes.Length; i++)
60.                 if (Input.GetKeyUp(_keyCodes[i]))
61.                     yield return _keyCodes[i];
62.         }
63.     }

Now you can ask if any or all of interesting kodes are presented in input

 

Thank you very much! it works!!!

 

Just a minor optimization, also applicable to the other implementations. As the side of the array doesn't change within the loop you don't need to query its length in each single iteration. Just get the size once and iterate:

Code (csharp):

1. private int[] values;
2. private bool[] keys;
3.  
4. void Awake()
5.     {
6.     values = (int[])System.Enum.GetValues(typeof(KeyCode));
7.     keys = new bool[values.Length];
8.     }
9.  
10. void Update()
11.     {
12.     for (int i = 0, n = values.Length; i < n; i++)
13.         keys[i] = Input.GetKey((KeyCode)values[i]);
14.     }
15.  

 

For those who crave the convenience of UnityEvents, here is an another script that builds off of Sushi271's answer:

Code (CSharp):

1.     public class GetKey : MonoBehaviour
2.     {
3.         [SerializeField] KeyCodeEvent keyDown;
4.         [SerializeField] KeyCodeEvent keyHold;
5.         [SerializeField] KeyCodeEvent keyUp;
6.  
7.         bool useKeyDown;
8.         bool useKeyHold;
9.         bool useKeyUp;
10.        
11.         void OnValidate()
12.         {
13.             useKeyDown = keyDown.GetPersistentEventCount() > 0;
14.             useKeyHold = keyHold.GetPersistentEventCount() > 0;
15.             useKeyUp = keyUp.GetPersistentEventCount() > 0;
16.         }
17.        
18.         IEnumerable<KeyCode> keys;
19.  
20.         void Update()
21.         {
22.             if (useKeyDown) Output(UltiInput.GetCurrentKeysDown(), keyDown);
23.             if (useKeyHold) Output(UltiInput.GetCurrentKeys(), keyHold);
24.             if (useKeyUp) Output(UltiInput.GetCurrentKeysUp(), keyUp);
25.         }
26.        
27.         void Output(IEnumerable<KeyCode> keys, KeyCodeEvent output)
28.         {
29.             if (keys == null) return;
30.             foreach (var key in keys)
31.                 output.Invoke(key);
32.         }
33.     }

 

I love you, it worked with my implementation which I will say may not be professional or optimal but it works and I enjoyed your code. I searched this on google and I have to say after looking at 2010's forums I'm glad people wrote in this one to help learners like me.

I added this to your code

Code (CSharp):

1.  
2.  
3. [Serializable]
4.     public class KeyCodeListEvent : UnityEvent<List<KeyCode>>
5.     {
6.     }
7.  
8. public KeyCodeListEvent keyDownList;
9.  
10.  

and in your If statement for the _keysDown if the count is greater than 0, after the forloop

I did your invoke:

Code (CSharp):

1.  
2. keyDownList.Invoke(_keysDown);
3.  

then passed your list to my settings manager script

Code (CSharp):

1.  
2.  
3. public void WasKeyPressed(List<KeyCode> key)
4.     {
5.         eventkey = key;
6.     }
7.  
8.     public List<KeyCode> eventkey;
9.  
10.  

then with my controller script

Code (CSharp):

1.  
2.  
3. //a simple get keycode loop through the settings manager function to a serializable class with keycode and enum value pertaining to the GameObject Input Manager I'm implementing
4. if (SM.eventkey.Contains(SM.MyGetKey(MyKeyBindings.Forward)))
5.         {
6.         }
7.  

Like I said I'm learning this all by myself over the years and thank you again for bringing up this solution!

 

Hey all! If you are using the new input system this seems to work great and is more intuitive to me:

Code (CSharp):

1. using UnityEngine;
2. using UnityEngine.InputSystem;
3.  
4. public class Blah : MonoBehaviour
5. {
6.     protected void OnEnable()
7.     {
8.         Keyboard.current.onTextInput += OnTextInput;
9.     }
10.  
11.     protected void OnDisable()
12.     {
13.         Keyboard.current.onTextInput -= OnTextInput;
14.     }
15.  
16.     private void OnTextInput(char ch)
17.     {
18.         print(ch);
19.     }
20. }

This has some limitations but I think if you want more control you can use onEvent. There's some more stuff here:
https://docs.unity3d.com/Packages/com.unity.inputsystem@1.0/manual/Events.html

 

That doesn't actually work. What 'char' is "left shift key"? . You've missed half what's being provided here.

Anyway ... Doing it with the new input system is a very different problem (with a lot more power/options than if you're using old input) - I wouldn't do it the way you describe (there are a lot of other things to worry about when using new input).

 

Haha true .. hmm after playing around a bit this is what I came up with

Code (CSharp):

1. using UnityEngine;
2. using TMPro;
3. using UnityEngine.InputSystem;
4. using System;
5. using UnityEngine.InputSystem.Utilities;
6. using UnityEngine.InputSystem.LowLevel;
7.  
8. public class InputManager : MonoBehaviour
9. {
10.     private IDisposable _eventListener;
11.  
12.     private void OnEnable()
13.     {
14.         _eventListener = InputSystem.onEvent.ForDevice(Keyboard.current).Call(OnKeyPressed);
15.     }
16.  
17.     private void OnDisable()
18.     {
19.         _eventListener.Dispose();
20.     }
21.  
22.     private void OnKeyPressed(InputEventPtr eventPtr)
23.     {
24.         if (!eventPtr.IsA<StateEvent>() && !eventPtr.IsA<DeltaStateEvent>())
25.         {
26.             return;
27.         }
28.  
29.         foreach (var control in eventPtr.EnumerateChangedControls())
30.         {
31.             print(control.name);
32.         }
33.     }
34. }

You would have to do your own keyup key down stuff (perhaps theres something for this already but the docs are sparse) but this might be more what was asked for? What other problems with the new input system were you thinking about?

 

If you're going to do it using new input then there are much better dedicated API calls specifically for doing this - your code above is needlessly convoluted, I recommend reading the new input docs which have a lot of detail on how to capture input. I don't think it's difficult to do, and I don't think it needs a thread of its own. This thread was created because the old input system was missing a few API calls.