Either deprecate or re-think IsValidGameKey

[davidjoffe]

See comments I added in the code:

// dj2022-11 A few off-the-cuff thoughts on "IsGameKey()" and "std::vector g_anValidGameKeys": // (1) I don't remember exactly the thinking behind having some specific closed list of so-called 'valid game keys' and I wonder if it's really a // good idea to have this 'restriction' in the code as it may make porting to special platforms (e.g. maybe consoles with special custom scancodes // for keys) a bit more difficult? But maybe there was some good reason - I don't know remember this was written long ago. // I guess some keys we may want to avoid using but not sure what's the best way (though maybe porters to other platforms could have a configurable file with custom scancodes or something they could add somewhere etc.) // (2) A vector is 'std::vector g_anValidGameKeys' is a bad performance choice, but, it seems it's "only" used in redefining the keys so not a priority

//! Return true if given key is an allowable game-play key extern bool IsGameKey(int nKeyCode); // Is there really a good reason for this function to exist? [dj2023-11] // I don't remember exactly why/what etc. but it looks like it's used during redefining keys // But, looks like a good way to possibly exclude potentially important (and maybe new) keycodes for niche platforms e.g. retro handhelds // Why not just accept any keycode during redefining? This could at best be used to check for supported ones to display correctly or something // and then have some fallback code e.g. if some platform returns a new 'unknown' keycode just show the keycode and allow it to be defined and used in the game? // but // I mean, then instead of a vector, maybe an unordered_map (unordered for faster lookups) that just map keycode to name // and then we don't exclude any key accepted during redefining OR playing, but just do something like: // if (map.find(nkeyCode)!=map.end()) // sKeyName = map[nKeyCode]; // else // sKeyName = std::string("<") + std::to_string(nkeyCode) + ">"; // e.g. if you press Up then it displays "Up" but if an unknown keycode comes in from some future or niche device still accept it // but just display e.g. "<143>" or whatever the internal code is. // Or am I remembering wrong why this is here? I wrote this really long ago // The above would also be more 'future-proof' e.g. say in a few years new keyboards come out with lots of new keycode, or // different languages or something - or odd joysticks or mice that map arbitrary keycodes - make this 'future-proof' so // it automatically supports anything, and not have a moving target we have to chase to keep adding so-called 'valid' keys. // If SDL_input stuff sends a keycode it's surely "valid" whether we have it this list // If there are keycodes we should explicitly not allow redefining in a game (are there? I don't think so) then rather // have an 'IsInvalidGameKey' with an exclusion list (or just take this out entirely and allow anything, unless it causes problems)