Key bindings working

data/OpenRaider.ini

@@ -22,12 +22,13 @@ set volume     0.5
 set mouse_x    1.0
 set mouse_y    1.0
 
-bind menu     "esc"
-bind console  '`'
+bind menu     "escape"
+bind console  "backquote"
 bind forward  'w'
 bind backward 's'
-bind jump     ' '
-bind crouch   "ctrl"
 bind left     'a'
 bind right    'd'
-bind attack   "mouse_l"
+bind jump     "space"
+bind crouch   "leftctrl"
+bind use      "leftmouse"
+bind holster  "rightmouse"

include/OpenRaider.h

@@ -20,6 +20,21 @@
 class OpenRaider {
 public:
 
+    typedef enum {
+        menu = 0,
+        console,
+        forward,
+        backward,
+        left,
+        right,
+        jump,
+        crouch,
+        use,
+        holster,
+
+        ActionEventCount // Should always be at the end
+    } ActionEvents;
+
     /*!
      * \brief Constructs an object of OpenRaider
      */
@@ -46,10 +61,16 @@ public:
 
     int bind(const char *action, const char *key);
 
+    int bind(ActionEvents action, const char *key);
+
     int initialize();
 
     void run();
 
+    void handleKeyboard(KeyboardButton key, bool pressed);
+
+    void handleText(char *text, bool notFinished);
+
     Window *mWindow;
     Sound *mSound;
     Menu *mMenu;
@@ -62,6 +83,8 @@ private:
     char *mPakDir;
     char *mAudioDir;
     char *mDataDir;
+
+    KeyboardButton keyBindings[ActionEventCount];
 };
 
 #endif

include/Window.h

@@ -10,6 +10,36 @@
 
 #include <ctime>
 
+typedef enum {
+    zero = '0', one = '1',
+    two = '2', three = '3',
+    four = '4', five = '5',
+    six = '6', seven = '7',
+    eight = '8', nine = '9',
+    a = 'a', b = 'b',
+    c = 'c', d = 'd',
+    e = 'e', f = 'f',
+    g = 'g', h = 'h',
+    i = 'i', j = 'j',
+    k = 'k', l = 'l',
+    m = 'm', n = 'n',
+    o = 'o', p = 'p',
+    q = 'q', r = 'r',
+    s = 's', t = 't',
+    u = 'u', v = 'v',
+    w = 'w', x = 'x',
+    y = 'y', z = 'z',
+    quote, backslash, backspace, capslock,
+    comma, del, up, down, left, right,
+    end, equals, escape, f1, f2, f3, f4, f5,
+    f6, f7, f8, f9, f10, f11, f12, backquote,
+    home, insert, leftalt, leftctrl, leftbracket,
+    leftgui, leftshift, minus, numlock, pagedown,
+    pageup, pause, dot, rightalt, rightctrl, enter,
+    rightgui, rightbracket, rightshift, scrolllock,
+    semicolon, slash, space, tab, unknown
+} KeyboardButton;
+
 typedef struct {
     char *text;
     unsigned int x;
@@ -43,6 +73,8 @@ public:
 
     virtual void eventHandling() = 0;
 
+    virtual void setTextInput(bool on) = 0;
+
     virtual void delay(clock_t ms) = 0;
 
     virtual void swapBuffersGL() = 0;

include/WindowSDL.h

@@ -49,6 +49,8 @@ public:
 
     virtual void eventHandling();
 
+    virtual void setTextInput(bool on);
+
     virtual void delay(clock_t ms);
 
     virtual void swapBuffersGL();
@@ -66,6 +68,8 @@ private:
 
     TTF_Font *mFont;
     GLuint mFontTexture;
+
+    bool mTextInput;
 };
 
 #endif

src/OpenRaider.cpp

@@ -29,6 +29,9 @@ OpenRaider::OpenRaider() {
     mMenu = new Menu();
     mSound = new Sound();
     mWindow = new WindowSDL();
+
+    for (int i = 0; i < ActionEventCount; i++)
+        keyBindings[i] = unknown;
 }
 
 OpenRaider::~OpenRaider() {
@@ -264,24 +267,161 @@ int OpenRaider::bind(const char *action, const char *key) {
     if (action[0] == '+')
         tmp++;
 
-    if (strcmp(tmp, "console") == 0) {
-
+    if (strcmp(tmp, "menu") == 0) {
+        return bind(menu, key);
+    } else if (strcmp(tmp, "console") == 0) {
+        return bind(console, key);
     } else if (strcmp(tmp, "forward") == 0) {
-
+        return bind(forward, key);
     } else if (strcmp(tmp, "backward") == 0) {
-
-    } else if (strcmp(tmp, "jump") == 0) {
-
-    } else if (strcmp(tmp, "crouch") == 0) {
-
+        return bind(backward, key);
     } else if (strcmp(tmp, "left") == 0) {
-
+        return bind(left, key);
     } else if (strcmp(tmp, "right") == 0) {
-
+        return bind(right, key);
+    } else if (strcmp(tmp, "jump") == 0) {
+        return bind(jump, key);
+    } else if (strcmp(tmp, "crouch") == 0) {
+        return bind(crouch, key);
+    } else if (strcmp(tmp, "use") == 0) {
+        return bind(use, key);
+    } else if (strcmp(tmp, "holster") == 0) {
+        return bind(holster, key);
     } else {
         printf("bind-Error: Unknown action (%s --> %s)\n", key, action);
         return -1;
     }
+}
+
+int OpenRaider::bind(ActionEvents action, const char *key) {
+    assert(action != ActionEventCount);
+    assert(key != NULL);
+    assert(key[0] != '\0');
+
+    size_t length = strlen(key);
+    if ((key[0] == '\'') && (key[length - 1] == '\'') && (length == 3)) {
+        // Literal character like w, a, s, d, 0, 1...
+        char c = key[1];
+        if (((c >= '0') && (c <= '9'))
+            || ((c >= 'a') && (c <= 'z'))) {
+            keyBindings[action] = (KeyboardButton)c;
+        } else {
+            printf("bind-\'\'-Error: Unknown key (%s)\n", key);
+            return -1;
+        }
+    } else if ((key[0] == '\"') && (key[length - 1] == '\"')) {
+        // Special characters like tilde, esc, quote...
+        char *tmp = stringRemoveQuotes(key);
+        if (strcmp(tmp, "quote") == 0) {
+            keyBindings[action] = quote;
+        } else if (strcmp(tmp, "backslash") == 0) {
+            keyBindings[action] = quote;
+        } else if (strcmp(tmp, "backspace") == 0) {
+            keyBindings[action] = backspace;
+        } else if (strcmp(tmp, "capslock") == 0) {
+            keyBindings[action] = capslock;
+        } else if (strcmp(tmp, "comma") == 0) {
+            keyBindings[action] = comma;
+        } else if (strcmp(tmp, "del") == 0) {
+            keyBindings[action] = del;
+        } else if (strcmp(tmp, "up") == 0) {
+            keyBindings[action] = up;
+        } else if (strcmp(tmp, "down") == 0) {
+            keyBindings[action] = down;
+        } else if (strcmp(tmp, "left") == 0) {
+            keyBindings[action] = KeyboardButton::left;
+        } else if (strcmp(tmp, "right") == 0) {
+            keyBindings[action] = KeyboardButton::right;
+        } else if (strcmp(tmp, "end") == 0) {
+            keyBindings[action] = end;
+        } else if (strcmp(tmp, "equals") == 0) {
+            keyBindings[action] = equals;
+        } else if (strcmp(tmp, "escape") == 0) {
+            keyBindings[action] = escape;
+        } else if (strcmp(tmp, "f1") == 0) {
+            keyBindings[action] = f1;
+        } else if (strcmp(tmp, "f2") == 0) {
+            keyBindings[action] = f2;
+        } else if (strcmp(tmp, "f3") == 0) {
+            keyBindings[action] = f3;
+        } else if (strcmp(tmp, "f4") == 0) {
+            keyBindings[action] = f4;
+        } else if (strcmp(tmp, "f5") == 0) {
+            keyBindings[action] = f5;
+        } else if (strcmp(tmp, "f6") == 0) {
+            keyBindings[action] = f6;
+        } else if (strcmp(tmp, "f7") == 0) {
+            keyBindings[action] = f7;
+        } else if (strcmp(tmp, "f8") == 0) {
+            keyBindings[action] = f8;
+        } else if (strcmp(tmp, "f9") == 0) {
+            keyBindings[action] = f9;
+        } else if (strcmp(tmp, "f10") == 0) {
+            keyBindings[action] = f10;
+        } else if (strcmp(tmp, "f11") == 0) {
+            keyBindings[action] = f11;
+        } else if (strcmp(tmp, "f12") == 0) {
+            keyBindings[action] = f12;
+        } else if (strcmp(tmp, "backquote") == 0) {
+            keyBindings[action] = backquote;
+        } else if (strcmp(tmp, "home") == 0) {
+            keyBindings[action] = home;
+        } else if (strcmp(tmp, "insert") == 0) {
+            keyBindings[action] = insert;
+        } else if (strcmp(tmp, "leftalt") == 0) {
+            keyBindings[action] = leftalt;
+        } else if (strcmp(tmp, "leftctrl") == 0) {
+            keyBindings[action] = leftctrl;
+        } else if (strcmp(tmp, "leftbracket") == 0) {
+            keyBindings[action] = leftbracket;
+        } else if (strcmp(tmp, "leftgui") == 0) {
+            keyBindings[action] = leftgui;
+        } else if (strcmp(tmp, "leftshift") == 0) {
+            keyBindings[action] = leftshift;
+        } else if (strcmp(tmp, "minus") == 0) {
+            keyBindings[action] = minus;
+        } else if (strcmp(tmp, "numlock") == 0) {
+            keyBindings[action] = numlock;
+        } else if (strcmp(tmp, "pagedown") == 0) {
+            keyBindings[action] = pagedown;
+        } else if (strcmp(tmp, "pageup") == 0) {
+            keyBindings[action] = pageup;
+        } else if (strcmp(tmp, "pause") == 0) {
+            keyBindings[action] = pause;
+        } else if (strcmp(tmp, "dot") == 0) {
+            keyBindings[action] = dot;
+        } else if (strcmp(tmp, "rightalt") == 0) {
+            keyBindings[action] = rightalt;
+        } else if (strcmp(tmp, "rightctrl") == 0) {
+            keyBindings[action] = rightctrl;
+        } else if (strcmp(tmp, "enter") == 0) {
+            keyBindings[action] = enter;
+        } else if (strcmp(tmp, "rightgui") == 0) {
+            keyBindings[action] = rightgui;
+        } else if (strcmp(tmp, "rightbracket") == 0) {
+            keyBindings[action] = rightbracket;
+        } else if (strcmp(tmp, "rightshift") == 0) {
+            keyBindings[action] = rightshift;
+        } else if (strcmp(tmp, "scrolllock") == 0) {
+            keyBindings[action] = scrolllock;
+        } else if (strcmp(tmp, "semicolon") == 0) {
+            keyBindings[action] = semicolon;
+        } else if (strcmp(tmp, "slash") == 0) {
+            keyBindings[action] = slash;
+        } else if (strcmp(tmp, "space") == 0) {
+            keyBindings[action] = space;
+        } else if (strcmp(tmp, "tab") == 0) {
+            keyBindings[action] = tab;
+        } else {
+            printf("bind-\"\"-Error: Unknown key (%s)\n", key);
+            delete [] tmp;
+            return -2;
+        }
+        delete [] tmp;
+    } else {
+        printf("bind-Error: Unknown key (%s)\n", key);
+        return -3;
+    }
     return 0;
 }
 
@@ -340,3 +480,33 @@ void OpenRaider::run() {
     }
 }
 
+void OpenRaider::handleKeyboard(KeyboardButton key, bool pressed) {
+    if ((keyBindings[menu] == key) && pressed) {
+        mMenu->setVisible(!mMenu->isVisible());
+    }
+
+    if (keyBindings[console] == key) {
+
+    } else if (keyBindings[forward] == key) {
+
+    } else if (keyBindings[backward] == key) {
+
+    } else if (keyBindings[left] == key) {
+
+    } else if (keyBindings[right] == key) {
+
+    } else if (keyBindings[jump] == key) {
+
+    } else if (keyBindings[crouch] == key) {
+
+    } else if (keyBindings[use] == key) {
+
+    } else if (keyBindings[holster] == key) {
+
+    }
+}
+
+void OpenRaider::handleText(char *text, bool notFinished) {
+
+}
+

src/WindowSDL.cpp

@@ -9,6 +9,7 @@
 #include <assert.h>
 
 #include "config.h"
+#include "main.h"
 #include "utils/strings.h"
 #include "WindowSDL.h"
 
@@ -21,6 +22,7 @@ WindowSDL::WindowSDL() {
     mHeight = DEFAULT_HEIGHT;
     mFullscreen = false;
     mMousegrab = false;
+    mTextInput = false;
     mWindow = NULL;
     mGLContext = NULL;
     mFontInit = false;
@@ -176,9 +178,280 @@ void WindowSDL::eventHandling() {
 
                 break;
 
+            case SDL_TEXTINPUT:
+            case SDL_TEXTEDITING:
+                gOpenRaider->handleText(event.text.text, (event.type == SDL_TEXTEDITING));
+                break;
+
             case SDL_KEYDOWN:
             case SDL_KEYUP:
-
+                KeyboardButton key;
+                switch (event.key.keysym.sym) {
+                    case SDLK_0:
+                        key = zero;
+                        break;
+                    case SDLK_1:
+                        key = one;
+                        break;
+                    case SDLK_2:
+                        key = two;
+                        break;
+                    case SDLK_3:
+                        key = three;
+                        break;
+                    case SDLK_4:
+                        key = four;
+                        break;
+                    case SDLK_5:
+                        key = five;
+                        break;
+                    case SDLK_6:
+                        key = six;
+                        break;
+                    case SDLK_7:
+                        key = seven;
+                        break;
+                    case SDLK_8:
+                        key = eight;
+                        break;
+                    case SDLK_9:
+                        key = nine;
+                        break;
+                    case SDLK_a:
+                        key = a;
+                        break;
+                    case SDLK_b:
+                        key = b;
+                        break;
+                    case SDLK_c:
+                        key = c;
+                        break;
+                    case SDLK_d:
+                        key = d;
+                        break;
+                    case SDLK_e:
+                        key = e;
+                        break;
+                    case SDLK_f:
+                        key = f;
+                        break;
+                    case SDLK_g:
+                        key = g;
+                        break;
+                    case SDLK_h:
+                        key = h;
+                        break;
+                    case SDLK_i:
+                        key = i;
+                        break;
+                    case SDLK_j:
+                        key = j;
+                        break;
+                    case SDLK_k:
+                        key = k;
+                        break;
+                    case SDLK_l:
+                        key = l;
+                        break;
+                    case SDLK_m:
+                        key = m;
+                        break;
+                    case SDLK_n:
+                        key = n;
+                        break;
+                    case SDLK_o:
+                        key = o;
+                        break;
+                    case SDLK_p:
+                        key = p;
+                        break;
+                    case SDLK_q:
+                        key = q;
+                        break;
+                    case SDLK_r:
+                        key = r;
+                        break;
+                    case SDLK_s:
+                        key = s;
+                        break;
+                    case SDLK_t:
+                        key = t;
+                        break;
+                    case SDLK_u:
+                        key = u;
+                        break;
+                    case SDLK_v:
+                        key = v;
+                        break;
+                    case SDLK_w:
+                        key = w;
+                        break;
+                    case SDLK_x:
+                        key = x;
+                        break;
+                    case SDLK_y:
+                        key = y;
+                        break;
+                    case SDLK_z:
+                        key = z;
+                        break;
+                    case SDLK_QUOTE:
+                        key = quote;
+                        break;
+                    case SDLK_BACKSLASH:
+                        key = backslash;
+                        break;
+                    case SDLK_BACKSPACE:
+                        key = backspace;
+                        break;
+                    case SDLK_CAPSLOCK:
+                        key = capslock;
+                        break;
+                    case SDLK_COMMA:
+                        key = comma;
+                        break;
+                    case SDLK_DELETE:
+                        key = del;
+                        break;
+                    case SDLK_UP:
+                        key = up;
+                        break;
+                    case SDLK_DOWN:
+                        key = down;
+                        break;
+                    case SDLK_LEFT:
+                        key = left;
+                        break;
+                    case SDLK_RIGHT:
+                        key = right;
+                        break;
+                    case SDLK_END:
+                        key = end;
+                        break;
+                    case SDLK_EQUALS:
+                        key = equals;
+                        break;
+                    case SDLK_ESCAPE:
+                        key = escape;
+                        break;
+                    case SDLK_F1:
+                        key = f1;
+                        break;
+                    case SDLK_F2:
+                        key = f2;
+                        break;
+                    case SDLK_F3:
+                        key = f3;
+                        break;
+                    case SDLK_F4:
+                        key = f4;
+                        break;
+                    case SDLK_F5:
+                        key = f5;
+                        break;
+                    case SDLK_F6:
+                        key = f6;
+                        break;
+                    case SDLK_F7:
+                        key = f7;
+                        break;
+                    case SDLK_F8:
+                        key = f8;
+                        break;
+                    case SDLK_F9:
+                        key = f9;
+                        break;
+                    case SDLK_F10:
+                        key = f10;
+                        break;
+                    case SDLK_F11:
+                        key = f11;
+                        break;
+                    case SDLK_F12:
+                        key = f12;
+                        break;
+                    case SDLK_BACKQUOTE:
+                        key = backquote;
+                        break;
+                    case SDLK_HOME:
+                        key = home;
+                        break;
+                    case SDLK_INSERT:
+                        key = insert;
+                        break;
+                    case SDLK_LALT:
+                        key = leftalt;
+                        break;
+                    case SDLK_LCTRL:
+                        key = leftctrl;
+                        break;
+                    case SDLK_LEFTBRACKET:
+                        key = leftbracket;
+                        break;
+                    case SDLK_LGUI:
+                        key = leftgui;
+                        break;
+                    case SDLK_LSHIFT:
+                        key = leftshift;
+                        break;
+                    case SDLK_MINUS:
+                        key = minus;
+                        break;
+                    case SDLK_NUMLOCKCLEAR:
+                        key = numlock;
+                        break;
+                    case SDLK_PAGEDOWN:
+                        key = pagedown;
+                        break;
+                    case SDLK_PAGEUP:
+                        key = pageup;
+                        break;
+                    case SDLK_PAUSE:
+                        key = pause;
+                        break;
+                    case SDLK_PERIOD:
+                        key = dot;
+                        break;
+                    case SDLK_RALT:
+                        key = rightalt;
+                        break;
+                    case SDLK_RCTRL:
+                        key = rightctrl;
+                        break;
+                    case SDLK_RETURN:
+                    case SDLK_RETURN2:
+                        key = enter;
+                        break;
+                    case SDLK_RGUI:
+                        key = rightgui;
+                        break;
+                    case SDLK_RIGHTBRACKET:
+                        key = rightbracket;
+                        break;
+                    case SDLK_RSHIFT:
+                        key = rightshift;
+                        break;
+                    case SDLK_SCROLLLOCK:
+                        key = scrolllock;
+                        break;
+                    case SDLK_SEMICOLON:
+                        key = semicolon;
+                        break;
+                    case SDLK_SLASH:
+                        key = slash;
+                        break;
+                    case SDLK_SPACE:
+                        key = space;
+                        break;
+                    case SDLK_TAB:
+                        key = tab;
+                        break;
+                    default:
+                        key = unknown;
+                        break;
+
+                }
+                gOpenRaider->handleKeyboard(key, (event.type == SDL_KEYDOWN));
                 break;
 
             case SDL_WINDOWEVENT:
@@ -192,6 +465,16 @@ void WindowSDL::eventHandling() {
     }
 }
 
+void WindowSDL::setTextInput(bool on) {
+    assert(mInit == true);
+
+    mTextInput = on;
+    if (mTextInput)
+        SDL_StartTextInput();
+    else
+        SDL_StopTextInput();
+}
+
 void WindowSDL::delay(clock_t ms) {
     assert(mInit == true);