keys.cc

Go to the documentation of this file.

/*
 *  Copyright (C) 2001 The Exult Team
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif

#include "SDL_keyboard.h"

#include "actors.h"
#include "keys.h"
#include "exult.h"
#include "game.h"
#include "cheat.h"
#include "U7file.h"
#include "Scroll_gump.h"
#include "mouse.h"
#include "gamewin.h"
#include "utils.h"
#include "keyactions.h"

#ifndef UNDER_CE
using std::pair;
using std::atoi;
using std::cerr;
using std::cout;
using std::clog;
using std::endl;
using std::ifstream;
using std::isspace;
using std::strchr;
using std::string;
using std::strlen;
using std::vector;
#endif

static  class Chardata  // ctype-like character lists
  {
  public:
  std::string whitespace;
  Chardata()
    {
    for(size_t i=0;i<256;i++)
      if(isspace(i))
        whitespace+=static_cast<char>(i);
    }
  } chardata;

typedef void(*ActionFunc)(int*);

const struct Action {
  const char *s;
  ActionFunc func;
  ActionFunc func_release;
  const char* desc;
  bool show;
  bool cheat;
  Exult_Game game;
    bool allow_during_dont_move;
} ExultActions[] = {
  { "QUIT", ActionQuit, 0, "Quit", true, false, NONE, true },
  { "SAVE_RESTORE", ActionFileGump, 0, "Save/restore", true, false, NONE, true },
  { "QUICKSAVE", ActionQuicksave, 0, "Quick-save", true, false, NONE, false },
  { "QUICKRESTORE", 
    ActionQuickrestore, 0, "Quick-restore", true, false, NONE, true },
  { "ABOUT", ActionAbout, 0, "About Exult", true, false, NONE, false },
  { "HELP", ActionHelp, 0, "List keys", true, false, NONE, false },
  { "CLOSE_GUMPS", ActionCloseGumps, 0, "Close gumps", false, false, NONE, false},
  { "CLOSE_OR_MENU", ActionCloseOrMenu, 0, "Game menu", true, false, NONE, true },
  { "SCREENSHOT",
    ActionScreenshot, 0, "Take screenshot", true, false, NONE, true },
  { "GAME_MENU", ActionMenuGump, 0, "Game Menu", true, false, NONE, true },
  { "OLD_FILE_GUMP",
    ActionOldFileGump, 0, "Save/restore", true, false, NONE, true },
  
  { "REPAINT", ActionRepaint, 0, "Repaint screen", false, false, NONE, true },
  { "RESOLUTION_INCREASE", 
    ActionResIncrease, 0, "Increase resolution", true, true, NONE, true },
  { "RESOLUTION_DECREASE", 
    ActionResDecrease, 0, "Decrease resolution", true, true, NONE, true },
  { "BRIGHTER", 
    ActionBrighter, 0, "Increase brightness", true, false, NONE, true },
  { "DARKER", ActionDarker, 0, "Decrease brightness", true, false, NONE, true },
  { "TOGGLE_FULLSCREEN", 
    ActionFullscreen, 0, "Toggle fullscreen", true, false, NONE, true },
  
  { "USEITEM", ActionUseItem, 0, "Use item", false, false, NONE, false },
  { "USEFOOD", ActionUseFood, 0, "Use food", false, false, NONE, false },
  { "TOGGLE_COMBAT", ActionCombat, 0, "Toggle combat", true, false, NONE, false },
  { "PAUSE_COMBAT", ActionCombatPause, 0, "Pause combat", true, false, NONE, false },
  { "TARGET_MODE", ActionTarget, 0, "Target mode", true, false, NONE, false },
  { "INVENTORY", ActionInventory, 0, "Show inventory", true, false, NONE, false },
  { "TRY_KEYS", ActionTryKeys, 0, "Try keys", true, false, NONE, false },
  { "STATS", ActionStats, 0, "Show stats", true, false, NONE, false },
  { "COMBAT_STATS",
    ActionCombatStats, 0, "Show combat stats", true, false, SERPENT_ISLE, false },
  { "FACE_STATS",
    ActionFaceStats, 0, "Change Face Stats State", true, false, NONE, false },
  
  { "SHOW_SI_INTRO",
    ActionSIIntro, 0, "Show Alternate SI intro", true, true, SERPENT_ISLE, false },
  { "SHOW_ENDGAME", ActionEndgame, 0, "Show endgame", true, true, NONE, false },
  { "SCROLL_LEFT", ActionScrollLeft, 0, "Scroll left", true, true, NONE, false },
  { "SCROLL_RIGHT", ActionScrollRight, 0, "Scroll right", true, true, NONE, false },
  { "SCROLL_UP", ActionScrollUp, 0, "Scroll up", true, true, NONE, false },
  { "SCROLL_DOWN", ActionScrollDown, 0, "Scroll down", true, true, NONE, false },
  { "WALK_WEST", ActionWalkWest, ActionStopWalking, "Walk west", true, false, NONE, false },
  { "WALK_EAST", ActionWalkEast, ActionStopWalking, "Walk east", true, false, NONE, false },
  { "WALK_NORTH", ActionWalkNorth, ActionStopWalking, "Walk north", true, false, NONE, false },
  { "WALK_SOUTH", ActionWalkSouth, ActionStopWalking, "Walk south", true, false, NONE, false },
  { "WALK_NORTH_EAST", ActionWalkNorthEast, ActionStopWalking, "Walk north-east", true, false, NONE, false },
  { "WALK_SOUTH_EAST", ActionWalkSouthEast, ActionStopWalking, "Walk south-east", true, false, NONE, false },
  { "WALK_NORTH_WEST", ActionWalkNorthWest, ActionStopWalking, "Walk north-west", true, false, NONE, false },
  { "WALK_SOUTH_WEST", ActionWalkSouthWest, ActionStopWalking, "Walk south-west", true, false, NONE, false },
  { "CENTER_SCREEN", ActionCenter, 0, "Center screen", true, true, NONE, false },
  { "SHAPE_BROWSER",
    ActionShapeBrowser, 0, "Shape browser", true, true, NONE, false },
  { "CREATE_ITEM",
    ActionCreateShape, 0, "Create last shape", true, true, NONE, false },
  { "DELETE_OBJECT", 
    ActionDeleteObject, 0, "Delete object", true, true, NONE, false },
  { "DELETE_SELECTED",
    ActionDeleteSelected, 0, "Delete selected", true, true, NONE, true },
  { "MOVE_SELECTED",
    ActionMoveSelected, 0, "Move selected", true, true, NONE, true },
  { "TOGGLE_EGGS",
    ActionToggleEggs, 0, "Toggle egg display", true, true, NONE, false },
  { "TOGGLE_GOD_MODE",
    ActionGodMode, 0, "Toggle god mode", true, true, NONE, false },
    { "CHANGE_GENDER", 
    ActionGender, 0, "Change gender", true, true, NONE, false },
  { "CHEAT_HELP", ActionCheatHelp, 0, "List cheat keys", true, true, NONE, false },
  { "TOGGLE_INFRAVISION",
    ActionInfravision, 0, "Toggle infravision", true, true, NONE, false },
  { "SKIPLIFT_DECREMENT",
    ActionSkipLift, 0, "Decrement skiplift", true, true, NONE, false },
  { "TOGGLE_MAP_EDITOR",
    ActionMapEditor, 0, "Toggle map-editor mode", true, true, NONE, true },
  { "TOGGLE_HACK_MOVER",
    ActionHackMover, 0, "Toggle hack-mover mode", true, true, NONE, false },
  { "MAP_TELEPORT", ActionMapTeleport, 0, "Map teleport", true, true, NONE, false },
  { "CURSOR_TELEPORT",
    ActionTeleport, 0, "Teleport to cursor", true, true, NONE, false },
  { "NEXT_TIME_PERIOD",
    ActionTime, 0, "Next time period", true, true, NONE, false },
  { "TOGGLE_WIZARD_MODE",
    ActionWizard, 0, "Toggle archwizard mode", true, true, NONE, false },
  { "PARTY_HEAL", ActionHeal, 0, "Heal party", true, true, NONE, false },
  { "PARTY_INCREASE_LEVEL",
    ActionLevelup, 0, "Level-up party", true, true, NONE, false },
  { "CHEAT_SCREEN", ActionCheatScreen, 0, "Cheat Screen", true, true, NONE, true },
  { "PICK_POCKET",
    ActionPickPocket, 0, "Toggle Pick Pocket", true, true, NONE, false },
  { "NPC_NUMBERS",
    ActionNPCNumbers, 0, "Toggle NPC Numbers", true, true, NONE, false },
  { "GRAB_ACTOR",
    ActionGrabActor, 0, "Grab NPC for Cheat Screen", true, true, NONE, false },
  { "CUT",
    ActionCut, 0, "Cut Selected Objects", true, false, NONE, true},
  { "COPY",
    ActionCopy, 0, "Copy Selected Objects", true, false, NONE, true},
  { "PASTE",
    ActionPaste, 0, "Paste Selected Objects", true, false, NONE, true},
  
  { "PLAY_MUSIC", ActionPlayMusic, 0, "Play song", false, true, NONE, false },
  { "TOGGLE_NAKED",
    ActionNaked, 0, "Toggle naked mode", true, true, SERPENT_ISLE, false },
  { "TOGGLE_PETRA",
    ActionPetra, 0, "Toggle Petra mode", true, true, SERPENT_ISLE, false },
  { "CHANGE_SKIN",
    ActionSkinColour, 0, "Change skin colour", true, true, NONE, false },
  { "SOUND_TESTER",
    ActionSoundTester, 0, "Sound tester", false, true, NONE, false },
  { "TEST", ActionTest, 0, "Test", false, false, NONE, false },
  { "", 0, 0, "", false, false, NONE, false } //terminator
};

const struct {
  const char *s;
  SDLKey k;
} SDLKeyStringTable[] = {
  {"BACKSPACE", SDLK_BACKSPACE},
  {"TAB",       SDLK_TAB}, 
  {"ENTER",     SDLK_RETURN}, 
  {"PAUSE",     SDLK_PAUSE}, 
  {"ESC",       SDLK_ESCAPE}, 
  {"SPACE",     SDLK_SPACE}, 
  {"DEL",       SDLK_DELETE}, 
  {"KP0",       SDLK_KP0}, 
  {"KP1",       SDLK_KP1}, 
  {"KP2",       SDLK_KP2}, 
  {"KP3",       SDLK_KP3}, 
  {"KP4",       SDLK_KP4}, 
  {"KP5",       SDLK_KP5}, 
  {"KP6",       SDLK_KP6}, 
  {"KP7",       SDLK_KP7}, 
  {"KP8",       SDLK_KP8}, 
  {"KP9",       SDLK_KP9}, 
  {"KP.",       SDLK_KP_PERIOD}, 
  {"KP/",       SDLK_KP_DIVIDE}, 
  {"KP*",       SDLK_KP_MULTIPLY}, 
  {"KP-",       SDLK_KP_MINUS}, 
  {"KP+",       SDLK_KP_PLUS}, 
  {"KP_ENTER",  SDLK_KP_ENTER}, 
  {"UP",        SDLK_UP}, 
  {"DOWN",      SDLK_DOWN}, 
  {"RIGHT",     SDLK_RIGHT}, 
  {"LEFT",      SDLK_LEFT}, 
  {"INSERT",    SDLK_INSERT}, 
  {"HOME",      SDLK_HOME}, 
  {"END",       SDLK_END}, 
  {"PAGEUP",    SDLK_PAGEUP}, 
  {"PAGEDOWN",  SDLK_PAGEDOWN}, 
  {"F1",        SDLK_F1}, 
  {"F2",        SDLK_F2}, 
  {"F3",        SDLK_F3}, 
  {"F4",        SDLK_F4}, 
  {"F5",        SDLK_F5}, 
  {"F6",        SDLK_F6}, 
  {"F7",        SDLK_F7}, 
  {"F8",        SDLK_F8}, 
  {"F9",        SDLK_F9}, 
  {"F10",       SDLK_F10}, 
  {"F11",       SDLK_F11}, 
  {"F12",       SDLK_F12}, 
  {"F13",       SDLK_F13}, 
  {"F14",       SDLK_F14}, 
  {"F15",       SDLK_F15},
  {"", SDLK_UNKNOWN} // terminator
};


typedef std::map<std::string, SDLKey> ParseKeyMap;
typedef std::map<std::string, const Action*> ParseActionMap;

static ParseKeyMap keys;
static ParseActionMap actions;


KeyBinder::KeyBinder()
{
  FillParseMaps();
}

KeyBinder::~KeyBinder()
{
}

void KeyBinder::AddKeyBinding( SDLKey key, int mod, const Action* action, 
         int nparams, int* params)
{
  SDL_keysym k;
  ActionType a;
  
  k.scancode = 0;
  k.sym      = key;
  k.mod      = (SDLMod) mod;
  k.unicode  = 0;
  a.action    = action;
  int i;  // For MSVC
  for (i = 0; i < c_maxparams && i < nparams; i++)
    a.params[i] = params[i];
  for (i = nparams; i < c_maxparams; i++)
    a.params[i] = -1;
  
  bindings[k] = a;
}

bool KeyBinder::DoAction(ActionType a, bool press)
{
  if (a.action->cheat && !cheat())
    return true;
  if (a.action->game != NONE && a.action->game != Game::get_game_type())
    return true;
  
       // Restrict key actions in dont_move mode
  if (a.action->allow_during_dont_move
        || !Game_window::get_instance()->main_actor_dont_move()
  || cheat.in_map_editor()) // But not if map-editing.
    {
        if (press)
            a.action->func(a.params);
        else 
        {
            if(a.action->func_release != NULL)
                a.action->func_release(a.params);
        }
    }
  
  return true;
}

bool KeyBinder::HandleEvent(SDL_Event &ev)
{
  SDL_keysym key = ev.key.keysym;
  KeyMap::iterator sdlkey_index;
  
  if (ev.type != SDL_KEYDOWN && ev.type != SDL_KEYUP)
    return false;
  
  key.mod = KMOD_NONE;
  if (ev.key.keysym.mod & KMOD_SHIFT)
    key.mod = (SDLMod)(key.mod | KMOD_SHIFT);
  if (ev.key.keysym.mod & KMOD_CTRL)
    key.mod = (SDLMod)(key.mod | KMOD_CTRL);
#if defined(MACOS) || defined(MACOSX)
  // map Meta to Alt on MacOS
  if (ev.key.keysym.mod & KMOD_META)
    key.mod = (SDLMod)(key.mod | KMOD_ALT);
#else
  if (ev.key.keysym.mod & KMOD_ALT)
    key.mod = (SDLMod)(key.mod | KMOD_ALT);
#endif
  
  sdlkey_index = bindings.find(key);
  if (sdlkey_index != bindings.end())
    return DoAction((*sdlkey_index).second, ev.type==SDL_KEYDOWN);
  
  return false;
}

void KeyBinder::ShowHelp()
{
  Scroll_gump *scroll;
  scroll = new Scroll_gump();
  
  std::vector<string>::iterator iter;
  
  for (iter = keyhelp.begin(); iter != keyhelp.end(); iter++)
    scroll->add_text(iter->c_str());
  
  scroll->paint();
  do
  {
    int x, y;
    Get_click(x,y, Mouse::hand);
  } while (scroll->show_next_page());
  Game_window::get_instance()->paint();
  delete scroll;
}

void KeyBinder::ShowCheatHelp()
{
  Scroll_gump *scroll;
  scroll = new Scroll_gump();
  
  std::vector<string>::iterator iter;
  
  for (iter = cheathelp.begin(); iter != cheathelp.end(); iter++)
    scroll->add_text(iter->c_str());
  
  scroll->paint();
  do
  {
    int x, y;
    Get_click(x,y, Mouse::hand);
  } while (scroll->show_next_page());
  Game_window::get_instance()->paint();
  delete scroll;
}

void KeyBinder::ParseText(char *text, int len)
{
  char *ptr, *end;
  const char LF = '\n';
  
  ptr = text;
  
  // last (useful) line must end with LF
  while ((ptr - text) < len && (end = strchr(ptr, LF)) != 0) {
    *end = '\0';
    ParseLine(ptr);
    ptr = end + 1;
  }  
}

static void skipspace(string &s) {
  size_t i=s.find_first_not_of(chardata.whitespace);
  if(i&&i!=string::npos)
    s.erase(0,i);
}


void KeyBinder::ParseLine(char *line)
{
  size_t i;
  SDL_keysym k;
  ActionType a;
  k.sym      = SDLK_UNKNOWN;
  k.mod      = KMOD_NONE;
  string s = line, u;
  string d, desc, keycode;
  bool show;
  
  skipspace(s);
  
  // comments and empty lines
  if (s.length() == 0 || s[0] == '#')
    return;
  
  u = s;
  to_uppercase(u);
  
  // get key
  while (s.length() && !isspace(s[0])) {
    // check modifiers
    //    if (u.compare("ALT-",0,4) == 0) {
    if (u.substr(0,4) == "ALT-") {
      k.mod = (SDLMod)(k.mod | KMOD_ALT);
      s.erase(0,4); u.erase(0,4);
      //    } else if (u.compare("CTRL-",0,5) == 0) {
    } else if (u.substr(0,5) == "CTRL-") {
      k.mod = (SDLMod)(k.mod | KMOD_CTRL);
      s.erase(0,5); u.erase(0,5);
      //    } else if (u.compare("SHIFT-",0,6) == 0) {
    } else if (u.substr(0,6) == "SHIFT-") {
      k.mod = (SDLMod)(k.mod | KMOD_SHIFT);
      s.erase(0,6); u.erase(0,6);
    } else {
      
      i=s.find_first_of(chardata.whitespace);

      keycode = s.substr(0, i); s.erase(0, i);
      string t(keycode);
      to_uppercase(t);
      
      if (t.length() == 0) {
        cerr << "Keybinder: parse error in line: " << s << endl;
        return;
      } else if (t.length() == 1) {
        // translate 1-letter keys straight to SDLKey
        char c = t[0];
        if (c >= 33 && c <= 122 && c != 37) {
          if (c >= 'A' && c <= 'Z')
            c += 32; // need lowercase
          k.sym = static_cast<SDLKey>(c);
        } else {
          cerr << "Keybinder: unsupported key: " << keycode << endl;
        }
      } else {
        // lookup in table
        ParseKeyMap::iterator key_index;
        key_index = keys.find(t);
        if (key_index != keys.end()) {
          k.sym = (*key_index).second;
        } else {
          cerr << "Keybinder: unsupported key: " << keycode << endl;
          return;
        }
      }
    }
  }
  
  if (k.sym == SDLK_UNKNOWN) {
    cerr << "Keybinder: parse error in line: " << s << endl;
    return;
  }
  
  // get function
  skipspace(s);
  
  i=s.find_first_of(chardata.whitespace);
  string t = s.substr(0, i); s.erase(0, i);
  to_uppercase(t);
  
  ParseActionMap::iterator action_index;
  action_index = actions.find(t);
  if (action_index != actions.end()) {
    a.action = (*action_index).second;
  } else {
    cerr << "Keybinder: unsupported action: " << t << endl;
    return;
  }
  
  // get params
  skipspace(s);
  
  int np = 0;
  while (s.length() && s[0] != '#' && np < c_maxparams) {
    i=s.find_first_of(chardata.whitespace);
    string t = s.substr(0, i);
    s.erase(0, i);
    skipspace(s);
    
    int p = atoi(t.c_str());
    a.params[np++] = p;
  }
  
  // read optional help comment
  if (s.length() >= 1 && s[0] == '#') {
    if (s.length() >= 2 && s[1] == '-') {
      show = false;
    } else {
      s.erase(0,1);
      skipspace(s);
      d = s;
      show = true;
    }
  } else {
    d = a.action->desc;
    show = a.action->show;
  }
  
  if (show) {
    desc = "";
    if (k.mod & KMOD_CTRL)
      desc += "Ctrl-";
#if defined(MACOS) || defined(MACOSX)
    if (k.mod & KMOD_ALT)
      desc += "Cmd-";
#else
    if (k.mod & KMOD_ALT)
      desc += "Alt-";
#endif
    if (k.mod & KMOD_SHIFT)
      desc += "Shift-";
    desc += keycode;
    
    desc += " - " + d;
    
    // add to help list
    if (a.action->cheat)
      cheathelp.push_back(desc);
    else
      keyhelp.push_back(desc);
  }
  
  // bind key
  AddKeyBinding(k.sym, k.mod, a.action, np, a.params);
}

void KeyBinder::LoadFromFile(const char* filename)
{
  ifstream keyfile;
  
  Flush();
  
  cout << "Loading keybindings from file " << filename << endl;
  
  U7open(keyfile, filename, true);
  char temp[1024]; // 1024 should be long enough
  while(!keyfile.eof()) {
    keyfile.getline(temp, 1024);
    if (keyfile.gcount() >= 1023) {
      cerr << "Keybinder: parse error: line too long. Skipping rest of file." 
         << endl;
      return;
    }
    ParseLine(temp);
  }
  keyfile.close();
}

void KeyBinder::LoadDefaults()
{
  Flush();
  
  cout << "Loading default keybindings" << endl;
  
  str_int_pair resource = game->get_resource("config/defaultkeys");

  U7object txtobj(resource.str, resource.num);
  size_t len;
  char *txt = txtobj.retrieve(len);
  ParseText(txt, len);
  
  delete [] txt;
}

// codes used in keybindings-files. (use uppercase here)
void KeyBinder::FillParseMaps()
{
  int i;  // For MSVC
  for (i = 0; strlen(SDLKeyStringTable[i].s) > 0; i++)
    keys[SDLKeyStringTable[i].s] = SDLKeyStringTable[i].k;
  
  for (i = 0; strlen(ExultActions[i].s) > 0; i++)
    actions[ExultActions[i].s] = &(ExultActions[i]);
}

---