]> de.git.xonotic.org Git - xonotic/darkplaces.git/blobdiff - keys.c
changed keydown[] from unsigned int holding key repeat count to qbyte holding status...
[xonotic/darkplaces.git] / keys.c
diff --git a/keys.c b/keys.c
index 4c21425401786ea1fcab87029acd47f8f9df81b3..da4320e0ba311169feb8b90f5c77aecede172160 100644 (file)
--- a/keys.c
+++ b/keys.c
@@ -44,8 +44,7 @@ static qboolean               consolekeys[1024];      // if true, can't be rebound while in
                                                                                // console
 static qboolean                menubound[1024];                // if true, can't be rebound while in
                                                                                // menu
-static unsigned int    key_repeats[1024];      // if > 1, it is autorepeating
-static qboolean                keydown[1024];
+static qbyte keydown[1024];    // 0 = up, 1 = down, 2 = repeating
 
 typedef struct {
        const char      *name;
@@ -830,13 +829,10 @@ Should NOT be called during an interrupt!
 void
 Key_Event (int key, char ascii, qboolean down)
 {
-#if 1
+#if 0
 #define USERPLAYING()  ( !key_consoleactive && key_dest == key_game && (cls.state == ca_connected && cls.signon == SIGNONS) )
        const char *bind;
 
-       // set key state
-       keydown[ key ] = down;
-
        // get key binding
        bind = keybindings[ key_bmap ][ key ];
        if( !bind ) {
@@ -845,13 +841,13 @@ Key_Event (int key, char ascii, qboolean down)
 
        // update key repeats
        if( down ) {
-               key_repeats[ key ]++;
-               if( key_repeats[ key ] > 1 ) {
+               keydown[ key ] = min(keydown[ key ] + 1, 2);
+               if( keydown[ key ] > 1 ) {
                        if( (key_consoleactive && !consolekeys[key]) || USERPLAYING() )
                                return;                                         // ignore most autorepeats
                }
        } else {
-               key_repeats[ key ] = 0;
+               keydown[ key ] = 0;
        }
 
        if( !down ) {
@@ -934,14 +930,150 @@ Key_Event (int key, char ascii, qboolean down)
                        }
                }
        }
+#elif 1
+#define USERPLAYING()  ( !key_consoleactive && key_dest == key_game && (cls.state == ca_connected && cls.signon == SIGNONS) )
+       const char *bind;
+
+       // get key binding
+       bind = keybindings[key_bmap][key];
+       if (!bind)
+               bind = keybindings[key_bmap2][key];
+
+       if (!down)
+       {
+               // clear repeat count now that the key is released
+               keydown[key] = 0;
+               // key up events only generate commands if the game key binding is a button
+               // command (leading + sign).  These will occur even in console mode, to
+               // keep the character from continuing an action started before a console
+               // switch.  Button commands include the kenum as a parameter, so multiple
+               // downs can be matched with ups
+               if (bind && bind[0] == '+')
+                       Cbuf_AddText(va("-%s %i\n", bind + 1, key));
+               return;
+       }
+
+       // from here on we know this is a down event
+
+       // increment key repeat count each time a down is received so that things
+       // which want to ignore key repeat can ignore it
+       keydown[key] = min(keydown[key] + 1, 2);
+
+       // key_consoleactive is a flag not a key_dest because the console is a
+       // high priority overlay ontop of the normal screen (designed as a safety
+       // feature so that developers and users can rescue themselves from a bad
+       // situation).
+       //
+       // this also means that toggling the console on/off does not lose the old
+       // key_dest state
+
+       // specially handle escape (togglemenu) and shift-escape (toggleconsole)
+       // engine bindings, these are not handled as normal binds so that the user
+       // can recover from a completely empty bindmap
+       if (key == K_ESCAPE)
+       {
+               // ignore key repeats on escape
+               if (keydown[key] > 1)
+                       return;
+               // escape does these things:
+               // key_consoleactive - close console
+               // key_message - abort messagemode
+               // key_menu - go to parent menu (or key_game)
+               // key_game - open menu
+               // in all modes shift-escape toggles console
+               if (key_consoleactive || keydown[K_SHIFT])
+               {
+                       Con_ToggleConsole_f ();
+                       return;
+               }
+               switch (key_dest)
+               {
+                       case key_message:
+                               Key_Message (key, ascii);
+                               break;
+                       case key_menu:
+                               MR_Keydown (key, ascii);
+                               break;
+                       case key_game:
+                               MR_ToggleMenu_f ();
+                               break;
+                       default:
+                               if(UI_Callback_IsSlotUsed(key_dest - 3))
+                                       UI_Callback_KeyDown (key, ascii);
+                               else
+                                       Sys_Error ("Bad key_dest");
+               }
+               return;
+       }
+
+       // send function keydowns to interpreter no matter what mode is
+       if (key >= K_F1 && key <= K_F12)
+       {
+               // ignore key repeats on F1-F12 binds
+               if (keydown[key] > 1)
+                       return;
+               if (bind)
+               {
+                       // button commands add keynum as a parm
+                       if (bind[0] == '+')
+                               Cbuf_AddText (va("%s %i\n", bind, key));
+                       else
+                       {
+                               Cbuf_AddText (bind);
+                               Cbuf_AddText ("\n");
+                       }
+               }
+               return;
+       }
+
+#if 1
+       // ignore binds (other than the above escape/F1-F12 keys) while in console
+       if (key_consoleactive)
+#else
+       // respond to toggleconsole binds while in console unless the pressed key
+       // happens to be the color prefix character (such as on German keyboards)
+       if (key_consoleactive && (strncmp(bind, "toggleconsole", strlen("toggleconsole")) || ascii == STRING_COLOR_TAG))
+#endif
+       {
+               Key_Console (key, ascii);
+               return;
+       }
+
+       // anything else is a key press into the game, chat line, or menu
+       switch (key_dest)
+       {
+               case key_message:
+                       Key_Message (key, ascii);
+                       break;
+               case key_menu:
+                       MR_Keydown (key, ascii);
+                       break;
+               case key_game:
+                       // ignore key repeats on binds
+                       if (bind && keydown[key] == 1)
+                       {
+                               // button commands add keynum as a parm
+                               if (bind[0] == '+')
+                                       Cbuf_AddText (va("%s %i\n", bind, key));
+                               else
+                               {
+                                       Cbuf_AddText (bind);
+                                       Cbuf_AddText ("\n");
+                               }
+                       }
+                       break;
+               default:
+                       if(UI_Callback_IsSlotUsed(key_dest - 3))
+                               UI_Callback_KeyDown (key, ascii);
+                       else
+                               Sys_Error ("Bad key_dest");
+       }
 #else
        const char      *kb;
        char            cmd[1024];
 
-       keydown[key] = down;
-
        if (!down)
-               key_repeats[key] = 0;
+               keydown[key] = 0;
 
        key_lastpress = key;
        key_count++;
@@ -951,8 +1083,8 @@ Key_Event (int key, char ascii, qboolean down)
 
        // update auto-repeat status
        if (down) {
-               key_repeats[key]++;
-               if (key_repeats[key] > 1) {
+               keydown[key] = min(keydown[key] + 1, 2);
+               if (keydown[key] > 1) {
                        if ((key_consoleactive && !consolekeys[key]) ||
                                        (!key_consoleactive && key_dest == key_game &&
                                         (cls.state == ca_connected && cls.signon == SIGNONS)))
@@ -1089,11 +1221,5 @@ Key_ClearStates
 void
 Key_ClearStates (void)
 {
-       int i;
-
-       for (i = 0; i < (int)(sizeof(keydown)/sizeof(keydown[0])); i++)
-       {
-               keydown[i] = false;
-               key_repeats[i] = 0;
-       }
+       memset(keydown, 0, sizeof(keydown));
 }