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::SPECIAL1] = getKeySetting("keymap_special1");
  39         key[KeyType::SNEAK] = getKeySetting("keymap_sneak");
  40
  41         key[KeyType::AUTOFORWARD] = getKeySetting("keymap_autoforward");
  42
  43         key[KeyType::DROP] = getKeySetting("keymap_drop");
  44         key[KeyType::INVENTORY] = getKeySetting("keymap_inventory");
  45         key[KeyType::CHAT] = getKeySetting("keymap_chat");
  46         key[KeyType::CMD] = getKeySetting("keymap_cmd");
  47         key[KeyType::CMD_LOCAL] = getKeySetting("keymap_cmd_local");
  48         key[KeyType::CONSOLE] = getKeySetting("keymap_console");
  49         key[KeyType::MINIMAP] = getKeySetting("keymap_minimap");
  50         key[KeyType::FREEMOVE] = getKeySetting("keymap_freemove");
  51         key[KeyType::PITCHMOVE] = getKeySetting("keymap_pitchmove");
  52         key[KeyType::FASTMOVE] = getKeySetting("keymap_fastmove");
  53         key[KeyType::NOCLIP] = getKeySetting("keymap_noclip");
  54         key[KeyType::HOTBAR_PREV] = getKeySetting("keymap_hotbar_previous");
  55         key[KeyType::HOTBAR_NEXT] = getKeySetting("keymap_hotbar_next");
  56         key[KeyType::MUTE] = getKeySetting("keymap_mute");
  57         key[KeyType::INC_VOLUME] = getKeySetting("keymap_increase_volume");
  58         key[KeyType::DEC_VOLUME] = getKeySetting("keymap_decrease_volume");
  59         key[KeyType::CINEMATIC] = getKeySetting("keymap_cinematic");
  60         key[KeyType::SCREENSHOT] = getKeySetting("keymap_screenshot");
  61         key[KeyType::TOGGLE_HUD] = getKeySetting("keymap_toggle_hud");
  62         key[KeyType::TOGGLE_CHAT] = getKeySetting("keymap_toggle_chat");
  63         key[KeyType::TOGGLE_FOG] = getKeySetting("keymap_toggle_fog");
  64         key[KeyType::TOGGLE_UPDATE_CAMERA] = getKeySetting("keymap_toggle_update_camera");
  65         key[KeyType::TOGGLE_DEBUG] = getKeySetting("keymap_toggle_debug");
  66         key[KeyType::TOGGLE_PROFILER] = getKeySetting("keymap_toggle_profiler");
  67         key[KeyType::CAMERA_MODE] = getKeySetting("keymap_camera_mode");
  68         key[KeyType::INCREASE_VIEWING_RANGE] =
  69                         getKeySetting("keymap_increase_viewing_range_min");
  70         key[KeyType::DECREASE_VIEWING_RANGE] =
  71                         getKeySetting("keymap_decrease_viewing_range_min");
  72         key[KeyType::RANGESELECT] = getKeySetting("keymap_rangeselect");
  73         key[KeyType::ZOOM] = getKeySetting("keymap_zoom");
  74
  75         key[KeyType::QUICKTUNE_NEXT] = getKeySetting("keymap_quicktune_next");
  76         key[KeyType::QUICKTUNE_PREV] = getKeySetting("keymap_quicktune_prev");
  77         key[KeyType::QUICKTUNE_INC] = getKeySetting("keymap_quicktune_inc");
  78         key[KeyType::QUICKTUNE_DEC] = getKeySetting("keymap_quicktune_dec");
  79
  80         for (int i = 0; i < HUD_HOTBAR_ITEMCOUNT_MAX; i++) {
  81                 std::string slot_key_name = "keymap_slot" + std::to_string(i + 1);
  82                 key[KeyType::SLOT_1 + i] = getKeySetting(slot_key_name.c_str());
  83         }
  84
  85         if (handler) {
  86                 // First clear all keys, then re-add the ones we listen for
  87                 handler->dontListenForKeys();
  88                 for (const KeyPress &k : key) {
  89                         handler->listenForKey(k);
  90                 }
  91                 handler->listenForKey(EscapeKey);
  92                 handler->listenForKey(CancelKey);
  93         }
  94 }
  95
  96 bool MyEventReceiver::OnEvent(const SEvent &event)
  97 {
  98         /*
  99                 React to nothing here if a menu is active
 100         */
 101         if (isMenuActive()) {
 102 #ifdef HAVE_TOUCHSCREENGUI
 103                 if (m_touchscreengui) {
 104                         m_touchscreengui->Toggle(false);
 105                 }
 106 #endif
 107                 return g_menumgr.preprocessEvent(event);
 108         }
 109
 110         // Remember whether each key is down or up
 111         if (event.EventType == irr::EET_KEY_INPUT_EVENT) {
 112                 const KeyPress &keyCode = event.KeyInput;
 113                 if (keysListenedFor[keyCode]) {
 114                         if (event.KeyInput.PressedDown) {
 115                                 keyIsDown.set(keyCode);
 116                                 keyWasDown.set(keyCode);
 117                         } else {
 118                                 keyIsDown.unset(keyCode);
 119                         }
 120                         return true;
 121                 }
 122         }
 123
 124 #ifdef HAVE_TOUCHSCREENGUI
 125         // case of touchscreengui we have to handle different events
 126         if (m_touchscreengui && event.EventType == irr::EET_TOUCH_INPUT_EVENT) {
 127                 m_touchscreengui->translateEvent(event);
 128                 return true;
 129         }
 130 #endif
 131
 132         if (event.EventType == irr::EET_JOYSTICK_INPUT_EVENT) {
 133                 /* TODO add a check like:
 134                 if (event.JoystickEvent != joystick_we_listen_for)
 135                         return false;
 136                 */
 137                 return joystick->handleEvent(event.JoystickEvent);
 138         }
 139         // handle mouse events
 140         if (event.EventType == irr::EET_MOUSE_INPUT_EVENT) {
 141                 if (isMenuActive()) {
 142                         left_active = false;
 143                         middle_active = false;
 144                         right_active = false;
 145                 } else {
 146                         left_active = event.MouseInput.isLeftPressed();
 147                         middle_active = event.MouseInput.isMiddlePressed();
 148                         right_active = event.MouseInput.isRightPressed();
 149
 150                         if (event.MouseInput.Event == EMIE_LMOUSE_PRESSED_DOWN) {
 151                                 leftclicked = true;
 152                         }
 153                         if (event.MouseInput.Event == EMIE_RMOUSE_PRESSED_DOWN) {
 154                                 rightclicked = true;
 155                         }
 156                         if (event.MouseInput.Event == EMIE_LMOUSE_LEFT_UP) {
 157                                 leftreleased = true;
 158                         }
 159                         if (event.MouseInput.Event == EMIE_RMOUSE_LEFT_UP) {
 160                                 rightreleased = true;
 161                         }
 162                         if (event.MouseInput.Event == EMIE_MOUSE_WHEEL) {
 163                                 mouse_wheel += event.MouseInput.Wheel;
 164                         }
 165                 }
 166         } else if (event.EventType == irr::EET_LOG_TEXT_EVENT) {
 167                 static const LogLevel irr_loglev_conv[] = {
 168                                 LL_VERBOSE, // ELL_DEBUG
 169                                 LL_INFO,    // ELL_INFORMATION
 170                                 LL_WARNING, // ELL_WARNING
 171                                 LL_ERROR,   // ELL_ERROR
 172                                 LL_NONE,    // ELL_NONE
 173                 };
 174                 assert(event.LogEvent.Level < ARRLEN(irr_loglev_conv));
 175                 g_logger.log(irr_loglev_conv[event.LogEvent.Level],
 176                                 std::string("Irrlicht: ") + event.LogEvent.Text);
 177                 return true;
 178         }
 179         /* always return false in order to continue processing events */
 180         return false;
 181 }
 182
 183 /*
 184  * RandomInputHandler
 185  */
 186 s32 RandomInputHandler::Rand(s32 min, s32 max)
 187 {
 188         return (myrand() % (max - min + 1)) + min;
 189 }
 190
 191 void RandomInputHandler::step(float dtime)
 192 {
 193         {
 194                 static float counter1 = 0;
 195                 counter1 -= dtime;
 196                 if (counter1 < 0.0) {
 197                         counter1 = 0.1 * Rand(1, 40);
 198                         keydown.toggle(getKeySetting("keymap_jump"));
 199                 }
 200         }
 201         {
 202                 static float counter1 = 0;
 203                 counter1 -= dtime;
 204                 if (counter1 < 0.0) {
 205                         counter1 = 0.1 * Rand(1, 40);
 206                         keydown.toggle(getKeySetting("keymap_special1"));
 207                 }
 208         }
 209         {
 210                 static float counter1 = 0;
 211                 counter1 -= dtime;
 212                 if (counter1 < 0.0) {
 213                         counter1 = 0.1 * Rand(1, 40);
 214                         keydown.toggle(getKeySetting("keymap_forward"));
 215                 }
 216         }
 217         {
 218                 static float counter1 = 0;
 219                 counter1 -= dtime;
 220                 if (counter1 < 0.0) {
 221                         counter1 = 0.1 * Rand(1, 40);
 222                         keydown.toggle(getKeySetting("keymap_left"));
 223                 }
 224         }
 225         {
 226                 static float counter1 = 0;
 227                 counter1 -= dtime;
 228                 if (counter1 < 0.0) {
 229                         counter1 = 0.1 * Rand(1, 20);
 230                         mousespeed = v2s32(Rand(-20, 20), Rand(-15, 20));
 231                 }
 232         }
 233         {
 234                 static float counter1 = 0;
 235                 counter1 -= dtime;
 236                 if (counter1 < 0.0) {
 237                         counter1 = 0.1 * Rand(1, 30);
 238                         leftdown = !leftdown;
 239                         if (leftdown)
 240                                 leftclicked = true;
 241                         if (!leftdown)
 242                                 leftreleased = true;
 243                 }
 244         }
 245         {
 246                 static float counter1 = 0;
 247                 counter1 -= dtime;
 248                 if (counter1 < 0.0) {
 249                         counter1 = 0.1 * Rand(1, 15);
 250                         rightdown = !rightdown;
 251                         if (rightdown)
 252                                 rightclicked = true;
 253                         if (!rightdown)
 254                                 rightreleased = true;
 255                 }
 256         }
 257         mousepos += mousespeed;
 258 }