Many small fixes

include/Config.h.in

 #define VERSION "OpenRaider-@OpenRaider_VERSION_MAJOR@.@OpenRaider_VERSION_MINOR@.@OpenRaider_VERSION_MICRO@@OpenRaider_VERSION_RELEASE@ (@CMAKE_BUILD_TYPE@)"
 #define BUILD_HOST "@OpenRaider_BUILD_HOST@ @OpenRaider_HOSTNAME@"
 
-#define DEFAULT_CONFIG_PATH "~/.OpenRaider/"
+#define DEFAULT_CONFIG_PATH "~/.OpenRaider"
 #define DEFAULT_CONFIG_FILE "OpenRaider.ini"
 #define DEFAULT_WIDTH 640
 #define DEFAULT_HEIGHT 480

include/Window.h

 
 #include "global.h"
 
+typedef struct {
+    char *text;
+    unsigned int x;
+    unsigned int y;
+    int w;
+    int h;
+    float scale;
+    float color[4];
+} WindowString;
+
 /*!
  * \brief Windowing interface
  */

include/global.h

 } ActionEvents;
 
 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,
-    leftmouse, middlemouse, rightmouse,
-    unknown
+    zeroKey = '0', oneKey = '1', twoKey = '2',
+    threeKey = '3', fourKey = '4', fiveKey = '5',
+    sixKey = '6', sevenKey = '7', eightKey = '8',
+    nineKey = '9', aKey = 'a', bKey = 'b',
+    cKey = 'c', dKey = 'd', eKey = 'e', fKey = 'f',
+    gKey = 'g', hKey = 'h', iKey = 'i', jKey = 'j',
+    kKey = 'k', lKey = 'l', mKey = 'm', nKey = 'n',
+    oKey = 'o', pKey = 'p', qKey = 'q', rKey = 'r',
+    sKey = 's', tKey = 't', uKey = 'u', vKey = 'v',
+    wKey = 'w', xKey = 'x', yKey = 'y', zKey = 'z',
+    quoteKey, backslashKey, backspaceKey, capslockKey,
+    commaKey, delKey, upKey, downKey, leftKey, rightKey,
+    endKey, equalsKey, escapeKey, f1Key, f2Key, f3Key, f4Key, f5Key,
+    f6Key, f7Key, f8Key, f9Key, f10Key, f11Key, f12Key, backquoteKey,
+    homeKey, insertKey, leftaltKey, leftctrlKey, leftbracketKey,
+    leftguiKey, leftshiftKey, minusKey, numlockKey, pagedownKey,
+    pageupKey, pauseKey, dotKey, rightaltKey, rightctrlKey, enterKey,
+    rightguiKey, rightbracketKey, rightshiftKey, scrolllockKey,
+    semicolonKey, slashKey, spaceKey, tabKey,
+    leftmouseKey, middlemouseKey, rightmouseKey,
+    unknownKey
 } KeyboardButton;
 
-typedef struct {
-    char *text;
-    unsigned int x;
-    unsigned int y;
-    int w;
-    int h;
-    float scale;
-    float color[4];
-} WindowString;
-
 #endif
 

src/Console.cpp

 }
 
 void Console::handleKeyboard(KeyboardButton key, bool pressed) {
-    if (pressed && (key == enter)) {
+    if (pressed && (key == enterKey)) {
         // Execute entered command
         if ((mInputBufferPointer > 0) && (mInputBuffer[0] != '\0')) {
             print("> %s", mInputBuffer);
     }
 
     //! \fixme only deleting the last byte is not valid for non-ASCII UTF-8 strings
-    if (pressed && (key == backspace)) {
+    if (pressed && (key == backspaceKey)) {
         if (mInputBufferPointer > 0) {
             mInputBufferPointer--;
             mInputBuffer[mInputBufferPointer] = '\0';
         }
     }
 
-    if (pressed && ((key == up) || (key == down))) {
-        moveInHistory(key == up);
+    if (pressed && ((key == upKey) || (key == downKey))) {
+        moveInHistory(key == upKey);
     }
 }
 

src/Game.cpp

     if (a < 0)
     {
         //continue;
+        getConsole().print("Invalid animation data for model %d", index);
+        delete r_model;
         return;
     }
 

src/Menu.cpp

     if (!pressed)
         return;
 
-    if (key == up) {
+    if (key == upKey) {
         if (mCursor > 0)
             mCursor--;
         else
             mCursor = getOpenRaider().mMapList.size() - 1;
-    } else if (key == down) {
+    } else if (key == downKey) {
         if (mCursor < (getOpenRaider().mMapList.size() - 1))
             mCursor++;
         else
             mCursor = 0;
-    } else if (key == right) {
+    } else if (key == rightKey) {
         int i = 10;
         if (mCursor > (getOpenRaider().mMapList.size() - 11))
             i = getOpenRaider().mMapList.size() - 1 - mCursor;
         while (i-- > 0)
-            handleKeyboard(down, true);
-    } else if (key == left) {
+            handleKeyboard(downKey, true);
+    } else if (key == leftKey) {
         int i = 10;
         if (mCursor < 10)
             i = mCursor;
         while (i-- > 0)
-            handleKeyboard(up, true);
-    } else if (key == enter) {
+            handleKeyboard(upKey, true);
+    } else if (key == enterKey) {
         char *tmp = bufferString("load %s", getOpenRaider().mMapList[mCursor]);
         if (getOpenRaider().command(tmp) == 0) {
             setVisible(false);
 void Menu::handleMouseClick(unsigned int x, unsigned int y, KeyboardButton button, bool released) {
     int items = (getWindow().mHeight - 110) / 25;
 
-    if ((!released) || (button != leftmouse))
+    if ((!released) || (button != leftmouseKey))
         return;
 
     if ((y >= 100) && (y <= (unsigned int)(100 + (25 * items)))) {

src/OpenRaider.cpp

     mMapListFilled = false;
 
     for (int i = 0; i < ActionEventCount; i++)
-        keyBindings[i] = unknown;
+        keyBindings[i] = unknownKey;
 }
 
 OpenRaider::~OpenRaider() {
         }
     }
 
-    char *token = strtok(cmd, " \t");
+    char *strtokState;
+    char *token = strtok_r(cmd, " \t", &strtokState);
     if (token != NULL) {
         // token is the command to execute
         // get arguments
         std::vector<char *> args;
         char *next;
-        while ((next = strtok(NULL, " \t")) != NULL) {
+        while ((next = strtok_r(NULL, " \t", &strtokState)) != NULL) {
             args.push_back(next);
         }
 
 }
 
 char *OpenRaider::expandDirectoryNames(const char *s) {
-    const char *base = "$(basedir)";
-    const char *pak = "$(pakdir)";
-    const char *audio = "$(audiodir)";
-    const char *data = "$(datadir)";
-
     assert(s != NULL);
     assert(s[0] != '\0');
 
     if (mBaseDir != NULL) {
+        const char *base = "$(basedir)";
         if (strstr(s, base) != NULL) {
             return stringReplace(s, base, mBaseDir);
         }
     }
 
     if (mPakDir != NULL) {
+        const char *pak = "$(pakdir)";
         if (strstr(s, pak) != NULL) {
             return stringReplace(s, pak, mPakDir);
         }
     }
 
     if (mAudioDir != NULL) {
+        const char *audio = "$(audiodir)";
         if (strstr(s, audio) != NULL) {
             return stringReplace(s, audio, mAudioDir);
         }
     }
 
     if (mDataDir != NULL) {
+        const char *data = "$(datadir)";
         if (strstr(s, data) != NULL) {
             return stringReplace(s, data, mDataDir);
         }
     if (strcmp(var, "size") == 0) {
         // value has format like "\"1024x768\""
         unsigned int w = DEFAULT_WIDTH, h = DEFAULT_HEIGHT;
-        if (sscanf(value, "\"%dx%d\"", &w, &h) != 2) {
+        if (sscanf(value, "\"%5dx%5d\"", &w, &h) != 2) {
             getConsole().print("set-size-Error: Invalid value (%s)", value);
             return -2;
         }
         getSound().setEnabled(audio);
     } else if (strcmp(var, "volume") == 0) {
         float vol = 1.0f;
-        if (sscanf(value, "%f", &vol) != 1) {
+        if (sscanf(value, "%5f", &vol) != 1) {
             getConsole().print("set-volume-Error: Invalid value (%s)", value);
             return -5;
         }
         getSound().setVolume(vol);
     } else if (strcmp(var, "mouse_x") == 0) {
         float sense = 1.0f;
-        if (sscanf(value, "%f", &sense) != 1) {
+        if (sscanf(value, "%5f", &sense) != 1) {
             getConsole().print("set-mouse_x-Error: Invalid value (%s)", value);
             return -6;
         }
         getCamera().setSensitivityX(OR_DEG_TO_RAD(sense));
     } else if (strcmp(var, "mouse_y") == 0) {
         float sense = 1.0f;
-        if (sscanf(value, "%f", &sense) != 1) {
+        if (sscanf(value, "%5f", &sense) != 1) {
             getConsole().print("set-mouse_y-Error: Invalid value (%s)", value);
             return -7;
         }
         // Special characters like tilde, esc, quote...
         char *tmp = stringRemoveQuotes(key);
         if (strcmp(tmp, "quote") == 0) {
-            keyBindings[action] = quote;
+            keyBindings[action] = quoteKey;
         } else if (strcmp(tmp, "backslash") == 0) {
-            keyBindings[action] = quote;
+            keyBindings[action] = backslashKey;
         } else if (strcmp(tmp, "backspace") == 0) {
-            keyBindings[action] = backspace;
+            keyBindings[action] = backspaceKey;
         } else if (strcmp(tmp, "capslock") == 0) {
-            keyBindings[action] = capslock;
+            keyBindings[action] = capslockKey;
         } else if (strcmp(tmp, "comma") == 0) {
-            keyBindings[action] = comma;
+            keyBindings[action] = commaKey;
         } else if (strcmp(tmp, "del") == 0) {
-            keyBindings[action] = del;
+            keyBindings[action] = delKey;
         } else if (strcmp(tmp, "up") == 0) {
-            keyBindings[action] = up;
+            keyBindings[action] = upKey;
         } else if (strcmp(tmp, "down") == 0) {
-            keyBindings[action] = down;
+            keyBindings[action] = downKey;
         } else if (strcmp(tmp, "left") == 0) {
-            keyBindings[action] = left;
+            keyBindings[action] = leftKey;
         } else if (strcmp(tmp, "right") == 0) {
-            keyBindings[action] = right;
+            keyBindings[action] = rightKey;
         } else if (strcmp(tmp, "end") == 0) {
-            keyBindings[action] = end;
+            keyBindings[action] = endKey;
         } else if (strcmp(tmp, "equals") == 0) {
-            keyBindings[action] = equals;
+            keyBindings[action] = equalsKey;
         } else if (strcmp(tmp, "escape") == 0) {
-            keyBindings[action] = escape;
+            keyBindings[action] = escapeKey;
         } else if (strcmp(tmp, "f1") == 0) {
-            keyBindings[action] = f1;
+            keyBindings[action] = f1Key;
         } else if (strcmp(tmp, "f2") == 0) {
-            keyBindings[action] = f2;
+            keyBindings[action] = f2Key;
         } else if (strcmp(tmp, "f3") == 0) {
-            keyBindings[action] = f3;
+            keyBindings[action] = f3Key;
         } else if (strcmp(tmp, "f4") == 0) {
-            keyBindings[action] = f4;
+            keyBindings[action] = f4Key;
         } else if (strcmp(tmp, "f5") == 0) {
-            keyBindings[action] = f5;
+            keyBindings[action] = f5Key;
         } else if (strcmp(tmp, "f6") == 0) {
-            keyBindings[action] = f6;
+            keyBindings[action] = f6Key;
         } else if (strcmp(tmp, "f7") == 0) {
-            keyBindings[action] = f7;
+            keyBindings[action] = f7Key;
         } else if (strcmp(tmp, "f8") == 0) {
-            keyBindings[action] = f8;
+            keyBindings[action] = f8Key;
         } else if (strcmp(tmp, "f9") == 0) {
-            keyBindings[action] = f9;
+            keyBindings[action] = f9Key;
         } else if (strcmp(tmp, "f10") == 0) {
-            keyBindings[action] = f10;
+            keyBindings[action] = f10Key;
         } else if (strcmp(tmp, "f11") == 0) {
-            keyBindings[action] = f11;
+            keyBindings[action] = f11Key;
         } else if (strcmp(tmp, "f12") == 0) {
-            keyBindings[action] = f12;
+            keyBindings[action] = f12Key;
         } else if (strcmp(tmp, "backquote") == 0) {
-            keyBindings[action] = backquote;
+            keyBindings[action] = backquoteKey;
         } else if (strcmp(tmp, "home") == 0) {
-            keyBindings[action] = home;
+            keyBindings[action] = homeKey;
         } else if (strcmp(tmp, "insert") == 0) {
-            keyBindings[action] = insert;
+            keyBindings[action] = insertKey;
         } else if (strcmp(tmp, "leftalt") == 0) {
-            keyBindings[action] = leftalt;
+            keyBindings[action] = leftaltKey;
         } else if (strcmp(tmp, "leftctrl") == 0) {
-            keyBindings[action] = leftctrl;
+            keyBindings[action] = leftctrlKey;
         } else if (strcmp(tmp, "leftbracket") == 0) {
-            keyBindings[action] = leftbracket;
+            keyBindings[action] = leftbracketKey;
         } else if (strcmp(tmp, "leftgui") == 0) {
-            keyBindings[action] = leftgui;
+            keyBindings[action] = leftguiKey;
         } else if (strcmp(tmp, "leftshift") == 0) {
-            keyBindings[action] = leftshift;
+            keyBindings[action] = leftshiftKey;
         } else if (strcmp(tmp, "minus") == 0) {
-            keyBindings[action] = minus;
+            keyBindings[action] = minusKey;
         } else if (strcmp(tmp, "numlock") == 0) {
-            keyBindings[action] = numlock;
+            keyBindings[action] = numlockKey;
         } else if (strcmp(tmp, "pagedown") == 0) {
-            keyBindings[action] = pagedown;
+            keyBindings[action] = pagedownKey;
         } else if (strcmp(tmp, "pageup") == 0) {
-            keyBindings[action] = pageup;
+            keyBindings[action] = pageupKey;
         } else if (strcmp(tmp, "pause") == 0) {
-            keyBindings[action] = pause;
+            keyBindings[action] = pauseKey;
         } else if (strcmp(tmp, "dot") == 0) {
-            keyBindings[action] = dot;
+            keyBindings[action] = dotKey;
         } else if (strcmp(tmp, "rightalt") == 0) {
-            keyBindings[action] = rightalt;
+            keyBindings[action] = rightaltKey;
         } else if (strcmp(tmp, "rightctrl") == 0) {
-            keyBindings[action] = rightctrl;
+            keyBindings[action] = rightctrlKey;
         } else if (strcmp(tmp, "enter") == 0) {
-            keyBindings[action] = enter;
+            keyBindings[action] = enterKey;
         } else if (strcmp(tmp, "rightgui") == 0) {
-            keyBindings[action] = rightgui;
+            keyBindings[action] = rightguiKey;
         } else if (strcmp(tmp, "rightbracket") == 0) {
-            keyBindings[action] = rightbracket;
+            keyBindings[action] = rightbracketKey;
         } else if (strcmp(tmp, "rightshift") == 0) {
-            keyBindings[action] = rightshift;
+            keyBindings[action] = rightshiftKey;
         } else if (strcmp(tmp, "scrolllock") == 0) {
-            keyBindings[action] = scrolllock;
+            keyBindings[action] = scrolllockKey;
         } else if (strcmp(tmp, "semicolon") == 0) {
-            keyBindings[action] = semicolon;
+            keyBindings[action] = semicolonKey;
         } else if (strcmp(tmp, "slash") == 0) {
-            keyBindings[action] = slash;
+            keyBindings[action] = slashKey;
         } else if (strcmp(tmp, "space") == 0) {
-            keyBindings[action] = space;
+            keyBindings[action] = spaceKey;
         } else if (strcmp(tmp, "tab") == 0) {
-            keyBindings[action] = tab;
+            keyBindings[action] = tabKey;
         } else if (strcmp(tmp, "leftmouse") == 0) {
-            keyBindings[action] = leftmouse;
+            keyBindings[action] = leftmouseKey;
         } else if (strcmp(tmp, "middlemouse") == 0) {
-            keyBindings[action] = middlemouse;
+            keyBindings[action] = middlemouseKey;
         } else if (strcmp(tmp, "rightmouse") == 0) {
-            keyBindings[action] = rightmouse;
+            keyBindings[action] = rightmouseKey;
         } else {
             getConsole().print("bind-\"\"-Error: Unknown key (%s)", key);
             delete [] tmp;
 }
 
 void OpenRaider::loadPakFolderRecursive(const char *dir) {
-    struct dirent *ep;
+    struct dirent entry;
+    struct dirent *ep = NULL;
     DIR *pakDir;
 
     assert(dir != NULL);
 
     pakDir = opendir(dir);
     if (pakDir != NULL) {
-        while ((ep = readdir(pakDir)) != NULL) {
+        readdir_r(pakDir, &entry, &ep);
+        while (ep != NULL) {
             if (ep->d_type == DT_DIR) {
                 if ((strcmp(".", ep->d_name) != 0)
                  && (strcmp("..", ep->d_name) != 0)) {
                 delete [] lowerPath;
                 delete [] fullPathMap;
             }
+            readdir_r(pakDir, &entry, &ep);
         }
         closedir(pakDir);
     } else {
 }
 
 void OpenRaider::handleKeyboard(KeyboardButton key, bool pressed) {
-    assert(key < unknown);
+    assert(key < unknownKey);
     assert(mRunning == true);
 
     if ((keyBindings[menuAction] == key) && pressed) {
 }
 
 void OpenRaider::handleMouseClick(unsigned int x, unsigned int y, KeyboardButton button, bool released) {
-    assert(button < unknown);
+    assert(button < unknownKey);
     assert(mRunning == true);
 
     if (getMenu().isVisible()) {

src/Render.cpp

     glTranslatef(0.0f, 0.0f, -2000.0f);
     glRotatef(180.0f, 1.0f, 0.0f, 0.0f);
 
-    glBindTexture(GL_TEXTURE_2D, 3); //! \fixme store texture id somewhere
+    mTexture.bindTextureId(1); //! \fixme store texture id somewhere
 
     glBegin(GL_TRIANGLE_STRIP);
     glTexCoord2f(1.0, 1.0);
     glPushMatrix();
     //LightingSetup();
 
-    glBindTexture(GL_TEXTURE_2D, 1);  // WHITE texture
+    mTexture.bindTextureId(0); // WHITE texture
 
     if (!draw_alpha &&
             (mFlags & Render::fPortals || mMode == Render::modeWireframe))

src/Texture.cpp

 
 void Texture::bindTextureId(unsigned int n) {
     assert(mTextureIds != NULL);
-    assert((int)n != mTextureId);
     assert(n <= mTextureCount);
 
     mTextureId = n;

src/TombRaider.cpp

     mTexelScale = 256.0f;
     mRiffDataSz = 0;
 
+    for (int i = 0; i < 256; i++) {
+        _palette8[i].r = 0;
+        _palette8[i].g = 0;
+        _palette8[i].b = 0;
+        _palette16[i] = 0;
+    }
+
     reset();
 }
 

src/WindowSDL.cpp

             case SDL_MOUSEBUTTONUP:
                 KeyboardButton button;
                 if (event.button.button == SDL_BUTTON_LEFT)
-                    button = leftmouse;
+                    button = leftmouseKey;
                 else if (event.button.button == SDL_BUTTON_RIGHT)
-                    button = rightmouse;
+                    button = rightmouseKey;
                 else
-                    button = middlemouse;
+                    button = middlemouseKey;
                 getOpenRaider().handleMouseClick(event.button.x, event.button.y, button, (event.type == SDL_MOUSEBUTTONUP));
                 break;
 
                 KeyboardButton key;
                 switch (event.key.keysym.sym) {
                     case SDLK_0:
-                        key = zero;
+                        key = zeroKey;
                         break;
                     case SDLK_1:
-                        key = one;
+                        key = oneKey;
                         break;
                     case SDLK_2:
-                        key = two;
+                        key = twoKey;
                         break;
                     case SDLK_3:
-                        key = three;
+                        key = threeKey;
                         break;
                     case SDLK_4:
-                        key = four;
+                        key = fourKey;
                         break;
                     case SDLK_5:
-                        key = five;
+                        key = fiveKey;
                         break;
                     case SDLK_6:
-                        key = six;
+                        key = sixKey;
                         break;
                     case SDLK_7:
-                        key = seven;
+                        key = sevenKey;
                         break;
                     case SDLK_8:
-                        key = eight;
+                        key = eightKey;
                         break;
                     case SDLK_9:
-                        key = nine;
+                        key = nineKey;
                         break;
                     case SDLK_a:
-                        key = a;
+                        key = aKey;
                         break;
                     case SDLK_b:
-                        key = b;
+                        key = bKey;
                         break;
                     case SDLK_c:
-                        key = c;
+                        key = cKey;
                         break;
                     case SDLK_d:
-                        key = d;
+                        key = dKey;
                         break;
                     case SDLK_e:
-                        key = e;
+                        key = eKey;
                         break;
                     case SDLK_f:
-                        key = f;
+                        key = fKey;
                         break;
                     case SDLK_g:
-                        key = g;
+                        key = gKey;
                         break;
                     case SDLK_h:
-                        key = h;
+                        key = hKey;
                         break;
                     case SDLK_i:
-                        key = i;
+                        key = iKey;
                         break;
                     case SDLK_j:
-                        key = j;
+                        key = jKey;
                         break;
                     case SDLK_k:
-                        key = k;
+                        key = kKey;
                         break;
                     case SDLK_l:
-                        key = l;
+                        key = lKey;
                         break;
                     case SDLK_m:
-                        key = m;
+                        key = mKey;
                         break;
                     case SDLK_n:
-                        key = n;
+                        key = nKey;
                         break;
                     case SDLK_o:
-                        key = o;
+                        key = oKey;
                         break;
                     case SDLK_p:
-                        key = p;
+                        key = pKey;
                         break;
                     case SDLK_q:
-                        key = q;
+                        key = qKey;
                         break;
                     case SDLK_r:
-                        key = r;
+                        key = rKey;
                         break;
                     case SDLK_s:
-                        key = s;
+                        key = sKey;
                         break;
                     case SDLK_t:
-                        key = t;
+                        key = tKey;
                         break;
                     case SDLK_u:
-                        key = u;
+                        key = uKey;
                         break;
                     case SDLK_v:
-                        key = v;
+                        key = vKey;
                         break;
                     case SDLK_w:
-                        key = w;
+                        key = wKey;
                         break;
                     case SDLK_x:
-                        key = x;
+                        key = xKey;
                         break;
                     case SDLK_y:
-                        key = y;
+                        key = yKey;
                         break;
                     case SDLK_z:
-                        key = z;
+                        key = zKey;
                         break;
                     case SDLK_QUOTE:
-                        key = quote;
+                        key = quoteKey;
                         break;
                     case SDLK_BACKSLASH:
-                        key = backslash;
+                        key = backslashKey;
                         break;
                     case SDLK_BACKSPACE:
-                        key = backspace;
+                        key = backspaceKey;
                         break;
                     case SDLK_CAPSLOCK:
-                        key = capslock;
+                        key = capslockKey;
                         break;
                     case SDLK_COMMA:
-                        key = comma;
+                        key = commaKey;
                         break;
                     case SDLK_DELETE:
-                        key = del;
+                        key = delKey;
                         break;
                     case SDLK_UP:
-                        key = up;
+                        key = upKey;
                         break;
                     case SDLK_DOWN:
-                        key = down;
+                        key = downKey;
                         break;
                     case SDLK_LEFT:
-                        key = left;
+                        key = leftKey;
                         break;
                     case SDLK_RIGHT:
-                        key = right;
+                        key = rightKey;
                         break;
                     case SDLK_END:
-                        key = end;
+                        key = endKey;
                         break;
                     case SDLK_EQUALS:
-                        key = equals;
+                        key = equalsKey;
                         break;
                     case SDLK_ESCAPE:
-                        key = escape;
+                        key = escapeKey;
                         break;
                     case SDLK_F1:
-                        key = f1;
+                        key = f1Key;
                         break;
                     case SDLK_F2:
-                        key = f2;
+                        key = f2Key;
                         break;
                     case SDLK_F3:
-                        key = f3;
+                        key = f3Key;
                         break;
                     case SDLK_F4:
-                        key = f4;
+                        key = f4Key;
                         break;
                     case SDLK_F5:
-                        key = f5;
+                        key = f5Key;
                         break;
                     case SDLK_F6:
-                        key = f6;
+                        key = f6Key;
                         break;
                     case SDLK_F7:
-                        key = f7;
+                        key = f7Key;
                         break;
                     case SDLK_F8:
-                        key = f8;
+                        key = f8Key;
                         break;
                     case SDLK_F9:
-                        key = f9;
+                        key = f9Key;
                         break;
                     case SDLK_F10:
-                        key = f10;
+                        key = f10Key;
                         break;
                     case SDLK_F11:
-                        key = f11;
+                        key = f11Key;
                         break;
                     case SDLK_F12:
-                        key = f12;
+                        key = f12Key;
                         break;
                     case SDLK_BACKQUOTE:
-                        key = backquote;
+                        key = backquoteKey;
                         break;
                     case SDLK_HOME:
-                        key = home;
+                        key = homeKey;
                         break;
                     case SDLK_INSERT:
-                        key = insert;
+                        key = insertKey;
                         break;
                     case SDLK_LALT:
-                        key = leftalt;
+                        key = leftaltKey;
                         break;
                     case SDLK_LCTRL:
-                        key = leftctrl;
+                        key = leftctrlKey;
                         break;
                     case SDLK_LEFTBRACKET:
-                        key = leftbracket;
+                        key = leftbracketKey;
                         break;
                     case SDLK_LGUI:
-                        key = leftgui;
+                        key = leftguiKey;
                         break;
                     case SDLK_LSHIFT:
-                        key = leftshift;
+                        key = leftshiftKey;
                         break;
                     case SDLK_MINUS:
-                        key = minus;
+                        key = minusKey;
                         break;
                     case SDLK_NUMLOCKCLEAR:
-                        key = numlock;
+                        key = numlockKey;
                         break;
                     case SDLK_PAGEDOWN:
-                        key = pagedown;
+                        key = pagedownKey;
                         break;
                     case SDLK_PAGEUP:
-                        key = pageup;
+                        key = pageupKey;
                         break;
                     case SDLK_PAUSE:
-                        key = pause;
+                        key = pauseKey;
                         break;
                     case SDLK_PERIOD:
-                        key = dot;
+                        key = dotKey;
                         break;
                     case SDLK_RALT:
-                        key = rightalt;
+                        key = rightaltKey;
                         break;
                     case SDLK_RCTRL:
-                        key = rightctrl;
+                        key = rightctrlKey;
                         break;
                     case SDLK_RETURN:
                     case SDLK_RETURN2:
-                        key = enter;
+                        key = enterKey;
                         break;
                     case SDLK_RGUI:
-                        key = rightgui;
+                        key = rightguiKey;
                         break;
                     case SDLK_RIGHTBRACKET:
-                        key = rightbracket;
+                        key = rightbracketKey;
                         break;
                     case SDLK_RSHIFT:
-                        key = rightshift;
+                        key = rightshiftKey;
                         break;
                     case SDLK_SCROLLLOCK:
-                        key = scrolllock;
+                        key = scrolllockKey;
                         break;
                     case SDLK_SEMICOLON:
-                        key = semicolon;
+                        key = semicolonKey;
                         break;
                     case SDLK_SLASH:
-                        key = slash;
+                        key = slashKey;
                         break;
                     case SDLK_SPACE:
-                        key = space;
+                        key = spaceKey;
                         break;
                     case SDLK_TAB:
-                        key = tab;
+                        key = tabKey;
                         break;
                     default:
-                        key = unknown;
+                        key = unknownKey;
                         break;
 
                 }

src/main.cpp

     if (gWindow)
         delete gWindow;
 
+#ifdef DEBUG
     printf("\nThanks for testing %s\n", VERSION);
     printf("Build date: %s @ %s\n", __DATE__, __TIME__);
     printf("Build host: %s\n", BUILD_HOST);
     printf("Web site  : http://github.com/xythobuz/OpenRaider\n");
     printf("Contact   : xythobuz@xythobuz.de\n");
+#endif
 }
 
 int main(int argc, char *argv[]) {
     // Handle arguments
     if (argc == 1) {
         // Use default rc file path
-        config = DEFAULT_CONFIG_PATH DEFAULT_CONFIG_FILE;
+        config = DEFAULT_CONFIG_PATH "/" DEFAULT_CONFIG_FILE;
     } else if (argc == 2) {
         // Check for command line switches
         if ((strcmp("-h", argv[1]) == 0)
                     "\t--help\n\t-h\tDisplay this help text\n"
                     "\t--version\n\t-v\tDisplay version information\n"
                     "If no options are given, the default config will be loaded from:\n"
-                    "\t" DEFAULT_CONFIG_PATH DEFAULT_CONFIG_FILE "\n", argv[0]);
+                    "\t" DEFAULT_CONFIG_PATH "/" DEFAULT_CONFIG_FILE "\n", argv[0]);
             return 0;
         } else if ((strcmp("-v", argv[1]) == 0)
                 || (strcmp("--version", argv[1]) == 0)) {
         return 1;
     }
 
-    // Create globals
+#ifdef DEBUG
     printf("Initializing %s\n", VERSION);
+#endif
+
+    // Create globals
     atexit(cleanupHandler);
     gOpenRaider = new OpenRaider();
     gWindow = new WindowSDL();
 
     // Try to load a configuration
     if (gOpenRaider->loadConfig(config) != 0) {
-        if (gOpenRaider->loadConfig(DEFAULT_CONFIG_PATH DEFAULT_CONFIG_FILE) != 0) {
+        if (gOpenRaider->loadConfig(DEFAULT_CONFIG_PATH "/" DEFAULT_CONFIG_FILE) != 0) {
             if (gOpenRaider->loadConfig(DEFAULT_CONFIG_FILE) != 0) {
                 printf("Could not find a config file. Aborting...\n");
                 return 2;

src/utils/strings.cpp

         delete [] text;
         text = new char[sz + 1];
         va_copy(tmp, args);
-        n = vsnprintf(text, sz, string, tmp);
+        vsnprintf(text, sz, string, tmp);
         va_end(tmp);
     }
 
 }
 
 char *fullPath(const char *path, char end) {
-    unsigned int lenPath, offset;
+    unsigned int lenPath;
     wordexp_t word;
     char *dir;
 
         dir = new char[lenPath + 2]; // space for end char
 
         // Copy segments into new string
-        offset = 0;
+        unsigned int offset = 0;
         for (unsigned int i = 0; i < word.we_wordc; i++) {
             unsigned int len = strlen(word.we_wordv[i]);
             strncpy(dir + offset, word.we_wordv[i], len);