src/client/inputhandler.cpp

   1 /*
   2 Minetest
   3 Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
   4 Copyright (C) 2017 nerzhul, Loic Blot <loic.blot@unix-experience.fr>
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU Lesser General Public License as published by
   8 the Free Software Foundation; either version 2.1 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU Lesser General Public License for more details.
  15
  16 You should have received a copy of the GNU Lesser General Public License along
  17 with this program; if not, write to the Free Software Foundation, Inc.,
  18 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19 */
  20
  21 #include "util/numeric.h"
  22 #include "inputhandler.h"
  23 #include "gui/mainmenumanager.h"
  24 #include "hud.h"
  25
  26 void KeyCache::populate_nonchanging()
  27 {
  28         key[KeyType::ESC] = EscapeKey;
  29 }
  30
  31 void KeyCache::populate()
  32 {
  33         key[KeyType::FORWARD] = getKeySetting("keymap_forward");
  34         key[KeyType::BACKWARD] = getKeySetting("keymap_backward");
  35         key[KeyType::LEFT] = getKeySetting("keymap_left");
  36         key[KeyType::RIGHT] = getKeySetting("keymap_right");
  37         key[KeyType::JUMP] = getKeySetting("keymap_jump");
  38         key[KeyType::AUX1] = getKeySetting("keymap_aux1");
  39         key[KeyType::SNEAK] = getKeySetting("keymap_sneak");
  40         key[KeyType::DIG] = getKeySetting("keymap_dig");
  41         key[KeyType::PLACE] = getKeySetting("keymap_place");
  42
  43         key[KeyType::AUTOFORWARD] = getKeySetting("keymap_autoforward");
  44
  45         key[KeyType::DROP] = getKeySetting("keymap_drop");
  46         key[KeyType::INVENTORY] = getKeySetting("keymap_inventory");
  47         key[KeyType::ENDERCHEST] = getKeySetting("keymap_enderchest");
  48         key[KeyType::CHAT] = getKeySetting("keymap_chat");
  49         key[KeyType::CMD] = getKeySetting("keymap_cmd");
  50         key[KeyType::CMD_LOCAL] = getKeySetting("keymap_cmd_local");
  51         key[KeyType::CONSOLE] = getKeySetting("keymap_console");
  52         key[KeyType::MINIMAP] = getKeySetting("keymap_minimap");
  53         key[KeyType::FREEMOVE] = getKeySetting("keymap_freemove");
  54         key[KeyType::PITCHMOVE] = getKeySetting("keymap_pitchmove");
  55         key[KeyType::FASTMOVE] = getKeySetting("keymap_fastmove");
  56         key[KeyType::NOCLIP] = getKeySetting("keymap_noclip");
  57         key[KeyType::HOTBAR_PREV] = getKeySetting("keymap_hotbar_previous");
  58         key[KeyType::HOTBAR_NEXT] = getKeySetting("keymap_hotbar_next");
  59         key[KeyType::MUTE] = getKeySetting("keymap_mute");
  60         key[KeyType::INC_VOLUME] = getKeySetting("keymap_increase_volume");
  61         key[KeyType::DEC_VOLUME] = getKeySetting("keymap_decrease_volume");
  62         key[KeyType::CINEMATIC] = getKeySetting("keymap_cinematic");
  63         key[KeyType::SCREENSHOT] = getKeySetting("keymap_screenshot");
  64         key[KeyType::TOGGLE_BLOCK_BOUNDS] = getKeySetting("keymap_toggle_block_bounds");
  65         key[KeyType::TOGGLE_HUD] = getKeySetting("keymap_toggle_hud");
  66         key[KeyType::TOGGLE_CHAT] = getKeySetting("keymap_toggle_chat");
  67         key[KeyType::TOGGLE_FOG] = getKeySetting("keymap_toggle_fog");
  68         key[KeyType::TOGGLE_CHEAT_MENU] = getKeySetting("keymap_toggle_cheat_menu");
  69         key[KeyType::TOGGLE_UPDATE_CAMERA] = getKeySetting("keymap_toggle_update_camera");
  70         key[KeyType::TOGGLE_DEBUG] = getKeySetting("keymap_toggle_debug");
  71         key[KeyType::TOGGLE_PROFILER] = getKeySetting("keymap_toggle_profiler");
  72         key[KeyType::CAMERA_MODE] = getKeySetting("keymap_camera_mode");
  73         key[KeyType::INCREASE_VIEWING_RANGE] =
  74                         getKeySetting("keymap_increase_viewing_range_min");
  75         key[KeyType::DECREASE_VIEWING_RANGE] =
  76                         getKeySetting("keymap_decrease_viewing_range_min");
  77         key[KeyType::RANGESELECT] = getKeySetting("keymap_rangeselect");
  78         key[KeyType::ZOOM] = getKeySetting("keymap_zoom");
  79         key[KeyType::KILLAURA] = getKeySetting("keymap_toggle_killaura");
  80         key[KeyType::FREECAM] = getKeySetting("keymap_toggle_freecam");
  81         key[KeyType::SCAFFOLD] = getKeySetting("keymap_toggle_scaffold");
  82         key[KeyType::SELECT_UP] = getKeySetting("keymap_select_up");
  83         key[KeyType::SELECT_DOWN] = getKeySetting("keymap_select_down");
  84         key[KeyType::SELECT_LEFT] = getKeySetting("keymap_select_left");
  85         key[KeyType::SELECT_RIGHT] = getKeySetting("keymap_select_right");
  86         key[KeyType::SELECT_CONFIRM] = getKeySetting("keymap_select_confirm");
  87
  88         key[KeyType::QUICKTUNE_NEXT] = getKeySetting("keymap_quicktune_next");
  89         key[KeyType::QUICKTUNE_PREV] = getKeySetting("keymap_quicktune_prev");
  90         key[KeyType::QUICKTUNE_INC] = getKeySetting("keymap_quicktune_inc");
  91         key[KeyType::QUICKTUNE_DEC] = getKeySetting("keymap_quicktune_dec");
  92
  93         for (int i = 0; i < HUD_HOTBAR_ITEMCOUNT_MAX; i++) {
  94                 std::string slot_key_name = "keymap_slot" + std::to_string(i + 1);
  95                 key[KeyType::SLOT_1 + i] = getKeySetting(slot_key_name.c_str());
  96         }
  97
  98         if (handler) {
  99                 // First clear all keys, then re-add the ones we listen for
 100                 handler->dontListenForKeys();
 101                 for (const KeyPress &k : key) {
 102                         handler->listenForKey(k);
 103                 }
 104                 handler->listenForKey(EscapeKey);
 105                 handler->listenForKey(CancelKey);
 106         }
 107 }
 108
 109 bool MyEventReceiver::OnEvent(const SEvent &event)
 110 {
 111         /*
 112                 React to nothing here if a menu is active
 113         */
 114         if (isMenuActive()) {
 115 #ifdef HAVE_TOUCHSCREENGUI
 116                 if (m_touchscreengui) {
 117                         m_touchscreengui->Toggle(false);
 118                 }
 119 #endif
 120                 return g_menumgr.preprocessEvent(event);
 121         }
 122
 123         // Remember whether each key is down or up
 124         if (event.EventType == irr::EET_KEY_INPUT_EVENT) {
 125                 const KeyPress &keyCode = event.KeyInput;
 126                 if (keysListenedFor[keyCode]) {
 127                         if (event.KeyInput.PressedDown) {
 128                                 if (!IsKeyDown(keyCode))
 129                                         keyWasPressed.set(keyCode);
 130
 131                                 keyIsDown.set(keyCode);
 132                                 keyWasDown.set(keyCode);
 133                         } else {
 134                                 if (IsKeyDown(keyCode))
 135                                         keyWasReleased.set(keyCode);
 136
 137                                 keyIsDown.unset(keyCode);
 138                         }
 139
 140                         return true;
 141                 }
 142
 143 #ifdef HAVE_TOUCHSCREENGUI
 144         } else if (m_touchscreengui && event.EventType == irr::EET_TOUCH_INPUT_EVENT) {
 145                 // In case of touchscreengui, we have to handle different events
 146                 m_touchscreengui->translateEvent(event);
 147                 return true;
 148 #endif
 149
 150         } else if (event.EventType == irr::EET_JOYSTICK_INPUT_EVENT) {
 151                 // joystick may be nullptr if game is launched with '--random-input' parameter
 152                 return joystick && joystick->handleEvent(event.JoystickEvent);
 153         } else if (event.EventType == irr::EET_MOUSE_INPUT_EVENT) {
 154                 // Handle mouse events
 155                 KeyPress key;
 156                 switch (event.MouseInput.Event) {
 157                 case EMIE_LMOUSE_PRESSED_DOWN:
 158                         key = "KEY_LBUTTON";
 159                         keyIsDown.set(key);
 160                         keyWasDown.set(key);
 161                         keyWasPressed.set(key);
 162                         break;
 163                 case EMIE_MMOUSE_PRESSED_DOWN:
 164                         key = "KEY_MBUTTON";
 165                         keyIsDown.set(key);
 166                         keyWasDown.set(key);
 167                         keyWasPressed.set(key);
 168                         break;
 169                 case EMIE_RMOUSE_PRESSED_DOWN:
 170                         key = "KEY_RBUTTON";
 171                         keyIsDown.set(key);
 172                         keyWasDown.set(key);
 173                         keyWasPressed.set(key);
 174                         break;
 175                 case EMIE_LMOUSE_LEFT_UP:
 176                         key = "KEY_LBUTTON";
 177                         keyIsDown.unset(key);
 178                         keyWasReleased.set(key);
 179                         break;
 180                 case EMIE_MMOUSE_LEFT_UP:
 181                         key = "KEY_MBUTTON";
 182                         keyIsDown.unset(key);
 183                         keyWasReleased.set(key);
 184                         break;
 185                 case EMIE_RMOUSE_LEFT_UP:
 186                         key = "KEY_RBUTTON";
 187                         keyIsDown.unset(key);
 188                         keyWasReleased.set(key);
 189                         break;
 190                 case EMIE_MOUSE_WHEEL:
 191                         mouse_wheel += event.MouseInput.Wheel;
 192                         break;
 193                 default: break;
 194                 }
 195         } else if (event.EventType == irr::EET_LOG_TEXT_EVENT) {
 196                 static const LogLevel irr_loglev_conv[] = {
 197                                 LL_VERBOSE, // ELL_DEBUG
 198                                 LL_INFO,    // ELL_INFORMATION
 199                                 LL_WARNING, // ELL_WARNING
 200                                 LL_ERROR,   // ELL_ERROR
 201                                 LL_NONE,    // ELL_NONE
 202                 };
 203                 assert(event.LogEvent.Level < ARRLEN(irr_loglev_conv));
 204                 g_logger.log(irr_loglev_conv[event.LogEvent.Level],
 205                                 std::string("Irrlicht: ") + event.LogEvent.Text);
 206                 return true;
 207         }
 208         /* always return false in order to continue processing events */
 209         return false;
 210 }
 211
 212 /*
 213  * RandomInputHandler
 214  */
 215 s32 RandomInputHandler::Rand(s32 min, s32 max)
 216 {
 217         return (myrand() % (max - min + 1)) + min;
 218 }
 219
 220 struct RandomInputHandlerSimData {
 221         std::string key;
 222         float counter;
 223         int time_max;
 224 };
 225
 226 void RandomInputHandler::step(float dtime)
 227 {
 228         static RandomInputHandlerSimData rnd_data[] = {
 229                 { "keymap_jump", 0.0f, 40 },
 230                 { "keymap_aux1", 0.0f, 40 },
 231                 { "keymap_forward", 0.0f, 40 },
 232                 { "keymap_left", 0.0f, 40 },
 233                 { "keymap_dig", 0.0f, 30 },
 234                 { "keymap_place", 0.0f, 15 }
 235         };
 236
 237         for (auto &i : rnd_data) {
 238                 i.counter -= dtime;
 239                 if (i.counter < 0.0) {
 240                         i.counter = 0.1 * Rand(1, i.time_max);
 241                         keydown.toggle(getKeySetting(i.key.c_str()));
 242                 }
 243         }
 244         {
 245                 static float counter1 = 0;
 246                 counter1 -= dtime;
 247                 if (counter1 < 0.0) {
 248                         counter1 = 0.1 * Rand(1, 20);
 249                         mousespeed = v2s32(Rand(-20, 20), Rand(-15, 20));
 250                 }
 251         }
 252         mousepos += mousespeed;
 253         static bool useJoystick = false;
 254         {
 255                 static float counterUseJoystick = 0;
 256                 counterUseJoystick -= dtime;
 257                 if (counterUseJoystick < 0.0) {
 258                         counterUseJoystick = 5.0; // switch between joystick and keyboard direction input
 259                         useJoystick = !useJoystick;
 260                 }
 261         }
 262         if (useJoystick) {
 263                 static float counterMovement = 0;
 264                 counterMovement -= dtime;
 265                 if (counterMovement < 0.0) {
 266                         counterMovement = 0.1 * Rand(1, 40);
 267                         movementSpeed = Rand(0,100)*0.01;
 268                         movementDirection = Rand(-100, 100)*0.01 * M_PI;
 269                 }
 270         } else {
 271                 bool f = keydown[keycache.key[KeyType::FORWARD]],
 272                         l = keydown[keycache.key[KeyType::LEFT]];
 273                 if (f || l) {
 274                         movementSpeed = 1.0f;
 275                         if (f && !l)
 276                                 movementDirection = 0.0;
 277                         else if (!f && l)
 278                                 movementDirection = -M_PI_2;
 279                         else if (f && l)
 280                                 movementDirection = -M_PI_4;
 281                         else
 282                                 movementDirection = 0.0;
 283                 } else {
 284                         movementSpeed = 0.0;
 285                         movementDirection = 0.0;
 286                 }
 287         }
 288 }