/* * The ManaPlus Client * Copyright (C) 2012-2017 The ManaPlus Developers * * This file is part of The ManaPlus Client. * * 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 * 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, see <http://www.gnu.org/licenses/>. */ #include "input/inputmanager.h" #include "configuration.h" #include "game.h" #include "settings.h" #include "being/localplayer.h" #include "being/playerinfo.h" #include "input/inputactionmap.h" #include "input/inputactionsortfunctor.h" #include "input/joystick.h" #include "input/keyboardconfig.h" #ifdef USE_SDL2 #include "input/touch/multitouchmanager.h" #endif // USE_SDL2 #include "input/touch/touchmanager.h" #include "gui/gui.h" #include "gui/sdlinput.h" #include "gui/widgets/selldialog.h" #include "gui/widgets/textfield.h" #include "gui/widgets/tabs/setup_input.h" #include "gui/windows/buydialog.h" #include "gui/windows/chatwindow.h" #include "gui/windows/inventorywindow.h" #include "gui/windows/npcdialog.h" #include "gui/windows/setupwindow.h" #include "gui/windows/textdialog.h" #include "gui/windows/tradewindow.h" #include "utils/checkutils.h" #include "utils/foreach.h" #include "utils/gettext.h" #include "utils/stdmove.h" #include "utils/timer.h" #include "gui/focushandler.h" #include <algorithm> #include "debug.h" InputManager inputManager; class QuitDialog; extern QuitDialog *quitDialog; namespace { InputActionSortFunctor inputActionDataSorter; } // namespace InputManager::InputManager() : mSetupInput(nullptr), mNewKeyIndex(InputAction::NO_VALUE), mMask(1), mNameMap(), mChatMap(), mKey() { } void InputManager::init() restrict2 { for (size_t i = 0; i < CAST_SIZE(InputAction::TOTAL); i ++) { InputFunction &kf = mKey[i]; mKeyStr[i].clear(); for (size_t f = 0; f < inputFunctionSize; f ++) { InputItem &ki = kf.values[f]; ki.type = InputType::UNKNOWN; ki.value = -1; } } mNewKeyIndex = InputAction::NO_VALUE; resetKeys(); retrieve(); update(); } void InputManager::update() { keyboard.update(); if (joystick != nullptr) joystick->update(); } void InputManager::retrieve() restrict2 { for (int i = 0; i < CAST_S32(InputAction::TOTAL); i ++) { const std::string &restrict cmd = inputActionData[i].chatCommand; if (!cmd.empty()) { StringVect tokens; splitToStringVector(tokens, cmd, '|'); FOR_EACH (StringVectCIter, it, tokens) mChatMap[*it] = i; } #ifdef USE_SDL2 const std::string cf = std::string("sdl2") + inputActionData[i].configField; #else // USE_SDL2 const std::string cf = inputActionData[i].configField; #endif // USE_SDL2 InputFunction &restrict kf = mKey[i]; if (!cf.empty()) { mNameMap[cf] = static_cast<InputActionT>(i); const std::string keyStr = config.getValue(cf, ""); const size_t keyStrSize = keyStr.size(); if (keyStr.empty()) { updateKeyString(kf, i); continue; } StringVect keys; splitToStringVector(keys, keyStr, ','); unsigned int i2 = 0; for (StringVectCIter it = keys.begin(), it_end = keys.end(); it != it_end && i2 < inputFunctionSize; ++ it) { std::string keyStr2 = *it; if (keyStrSize < 2) continue; InputTypeT type = InputType::KEYBOARD; if ((keyStr2[0] < '0' || keyStr2[0] > '9') && keyStr2[0] != '-') { switch (keyStr2[0]) { case 'm': type = InputType::MOUSE; break; case 'j': type = InputType::JOYSTICK; break; default: break; } keyStr2 = keyStr2.substr(1); } const int key = atoi(keyStr2.c_str()); if (key >= -255 && key < SDLK_LAST) { kf.values[i2] = InputItem(type, key); i2 ++; } } for (; i2 < inputFunctionSize; i2 ++) kf.values[i2] = InputItem(); } updateKeyString(kf, i); } } void InputManager::store() const restrict2 { for (int i = 0; i < CAST_S32(InputAction::TOTAL); i ++) { #ifdef USE_SDL2 const std::string cf = std::string("sdl2") + inputActionData[i].configField; #else // USE_SDL2 const std::string cf = inputActionData[i].configField; #endif // USE_SDL2 if (!cf.empty()) { std::string keyStr; const InputFunction &restrict kf = mKey[i]; for (size_t i2 = 0; i2 < inputFunctionSize; i2 ++) { const InputItem &restrict key = kf.values[i2]; if (key.type != InputType::UNKNOWN) { std::string tmp("k"); switch (key.type) { case InputType::MOUSE: tmp = "m"; break; case InputType::JOYSTICK: tmp = "j"; break; case InputType::KEYBOARD: case InputType::UNKNOWN: default: break; } if (key.value != -1) { if (keyStr.empty()) { keyStr.append(tmp).append(toString(key.value)); } else { keyStr.append(strprintf(",%s%d", tmp.c_str(), key.value)); } } } } if (keyStr.empty()) keyStr = "-1"; config.setValue(cf, keyStr); } } } void InputManager::resetKey(const InputActionT i) restrict2 { InputFunction &restrict key = mKey[CAST_SIZE(i)]; for (size_t i2 = 1; i2 < inputFunctionSize; i2 ++) { InputItem &restrict ki2 = key.values[i2]; ki2.type = InputType::UNKNOWN; ki2.value = -1; } const InputActionData &restrict kd = inputActionData[CAST_SIZE(i)]; InputItem &restrict val0 = key.values[0]; val0.type = kd.defaultType1; InputItem &restrict val1 = key.values[1]; val1.type = kd.defaultType2; #ifdef USE_SDL2 if (kd.defaultType1 == InputType::KEYBOARD) val0.value = SDL_GetScancodeFromKey(kd.defaultValue1); else val0.value = kd.defaultValue1; if (kd.defaultType2 == InputType::KEYBOARD) val1.value = SDL_GetScancodeFromKey(kd.defaultValue2); else val1.value = kd.defaultValue2; if (val0.value == SDL_SCANCODE_UNKNOWN) val0.value = -1; if (val1.value == SDL_SCANCODE_UNKNOWN) val1.value = -1; #else // USE_SDL2 val0.value = kd.defaultValue1; val1.value = kd.defaultValue2; #endif // USE_SDL2 updateKeyString(key, CAST_SIZE(i)); } void InputManager::resetKeys() restrict2 { for (int i = 0; i < CAST_S32(InputAction::TOTAL); i++) resetKey(static_cast<InputActionT>(i)); } void InputManager::makeDefault(const InputActionT i) restrict2 { if (i > InputAction::NO_VALUE && i < InputAction::TOTAL) { resetKey(i); update(); } } bool InputManager::hasConflicts(InputActionT &restrict key1, InputActionT &restrict key2) const restrict2 { /** * No need to parse the square matrix: only check one triangle * that's enough to detect conflicts */ for (int i = 0; i < CAST_S32(InputAction::TOTAL); i++) { const InputActionData &restrict kdi = inputActionData[i]; if (*kdi.configField == 0) continue; const InputFunction &restrict ki = mKey[i]; for (size_t i2 = 0; i2 < inputFunctionSize; i2 ++) { const InputItem &restrict vali2 = ki.values[i2]; if (vali2.value == -1) continue; size_t j; for (j = i, j++; j < CAST_S32(InputAction::TOTAL); j++) { if ((kdi.grp & inputActionData[j].grp) == 0 || (*kdi.configField == 0)) { continue; } for (size_t j2 = 0; j2 < inputFunctionSize; j2 ++) { const InputItem &restrict valj2 = mKey[j].values[j2]; // Allow for item shortcut and emote keys to overlap // as well as emote and ignore keys, but no other keys if (valj2.type != InputType::UNKNOWN && vali2.value == valj2.value && vali2.type == valj2.type) { key1 = static_cast<InputActionT>(i); key2 = static_cast<InputActionT>(j); return true; } } } } } return false; } void InputManager::callbackNewKey() restrict2 { #ifndef DYECMD mSetupInput->newKeyCallback(mNewKeyIndex); #endif // DYECMD } bool InputManager::isActionActive(const InputActionT index) const restrict2 { if (!isActionActive0(index)) return false; const InputActionData &restrict key = inputActionData[CAST_SIZE(index)]; // logger->log("isActionActive mask=%d, condition=%d, index=%d", // mMask, key.condition, index); if ((key.condition & mMask) != key.condition) return false; return true; } bool InputManager::isActionActive0(const InputActionT index) { if (keyboard.isActionActive(index)) return true; if ((joystick != nullptr) && joystick->isActionActive(index)) return true; return touchManager.isActionActive(index); } InputFunction &InputManager::getKey(InputActionT index) restrict2 { if (CAST_S32(index) < 0 || index >= InputAction::TOTAL) index = InputAction::MOVE_UP; return mKey[CAST_SIZE(index)]; } std::string InputManager::getKeyStringLong(const InputActionT index) const restrict2 { std::string keyStr; const InputFunction &restrict ki = mKey[CAST_SIZE(index)]; for (size_t i = 0; i < inputFunctionSize; i ++) { const InputItem &restrict key = ki.values[i]; std::string str; if (key.type == InputType::KEYBOARD) { if (key.value >= 0) { str = KeyboardConfig::getKeyName(key.value); } else if (key.value < -1) { // TRANSLATORS: long key name. must be short. str = strprintf(_("key_%d"), -key.value); } } else if (key.type == InputType::JOYSTICK) { // TRANSLATORS: long joystick button name. must be short. str = strprintf(_("JButton%d"), key.value + 1); } if (!str.empty()) { if (keyStr.empty()) keyStr = str; else keyStr.append(", ").append(str); } } if (keyStr.empty()) { // TRANSLATORS: unknown long key type return _("unknown key"); } return keyStr; } void InputManager::updateKeyString(const InputFunction &ki, const size_t actionIdx) restrict2 { std::string keyStr; for (size_t i = 0; i < inputFunctionSize; i ++) { const InputItem &restrict key = ki.values[i]; std::string str; if (key.type == InputType::KEYBOARD) { if (key.value >= 0) { str = KeyboardConfig::getKeyShortString( KeyboardConfig::getKeyName(key.value)); } else if (key.value < -1) { // TRANSLATORS: short key name. must be very short. str = strprintf(_("key_%d"), -key.value); } } else if (key.type == InputType::JOYSTICK) { // TRANSLATORS: short joystick button name. muse be very short str = strprintf(_("JB%d"), key.value + 1); } if (!str.empty()) { if (keyStr.empty()) keyStr = str; else keyStr.append(", ").append(str); } } if (keyStr.empty()) { // TRANSLATORS: unknown short key type. must be short mKeyStr[actionIdx] = _("u key"); } else { mKeyStr[actionIdx] = STD_MOVE(keyStr); } } std::string InputManager::getKeyValueString(const InputActionT index) const restrict2 { return mKeyStr[CAST_SIZE(index)]; } std::string InputManager::getKeyValueByName(const std::string &restrict keyName) restrict2 { const StringInpActionMapCIter it = mNameMap.find(keyName); if (it == mNameMap.end()) return std::string(); return getKeyValueString((*it).second); } std::string InputManager::getKeyValueByNameLong(const std::string &restrict keyName) restrict2 { const StringInpActionMapCIter it = mNameMap.find(keyName); if (it == mNameMap.end()) return std::string(); return getKeyStringLong((*it).second); } void InputManager::addActionKey(const InputActionT action, const InputTypeT type, const int val) restrict2 { if (CAST_S32(action) < 0 || action >= InputAction::TOTAL) return; int idx = -1; InputFunction &restrict key = mKey[CAST_SIZE(action)]; for (size_t i = 0; i < inputFunctionSize; i ++) { const InputItem &restrict val2 = key.values[i]; if (val2.type == InputType::UNKNOWN || (val2.type == type && val2.value == val)) { idx = CAST_S32(i); break; } } if (idx == -1) { for (size_t i = 1; i < inputFunctionSize; i ++) { InputItem &restrict val1 = key.values[i - 1]; InputItem &restrict val2 = key.values[i]; val1.type = val2.type; val1.value = val2.value; } idx = inputFunctionSize - 1; } key.values[idx] = InputItem(type, val); updateKeyString(key, CAST_SIZE(action)); } void InputManager::setNewKey(const SDL_Event &event, const InputTypeT type) restrict2 { int val = -1; if (type == InputType::KEYBOARD) val = KeyboardConfig::getKeyValueFromEvent(event); else if (type == InputType::JOYSTICK && (joystick != nullptr)) val = joystick->getButtonFromEvent(event); if (val != -1) { addActionKey(mNewKeyIndex, type, val); update(); } } void InputManager::unassignKey() restrict2 { InputFunction &restrict key = mKey[CAST_SIZE(mNewKeyIndex)]; for (size_t i = 0; i < inputFunctionSize; i ++) { InputItem &restrict val = key.values[i]; val.type = InputType::UNKNOWN; val.value = -1; } updateKeyString(key, CAST_SIZE(mNewKeyIndex)); update(); } #ifndef DYECMD bool InputManager::handleAssignKey(const SDL_Event &restrict event, const InputTypeT type) restrict2 { if ((setupWindow != nullptr) && setupWindow->isWindowVisible() && getNewKeyIndex() > InputAction::NO_VALUE) { setNewKey(event, type); callbackNewKey(); setNewKeyIndex(InputAction::NO_VALUE); return true; } return false; } #else // DYECMD bool InputManager::handleAssignKey(const SDL_Event &restrict event A_UNUSED, const InputTypeT type A_UNUSED) restrict2 { return false; } #endif // DYECMD bool InputManager::handleEvent(const SDL_Event &restrict event) restrict2 { BLOCK_START("InputManager::handleEvent") switch (event.type) { case SDL_KEYDOWN: { #ifdef USE_SDL2 if (keyboard.ignoreKey(event)) { BLOCK_END("InputManager::handleEvent") return true; } #endif // USE_SDL2 keyboard.refreshActiveKeys(); updateConditionMask(true); if (handleAssignKey(event, InputType::KEYBOARD)) { BLOCK_END("InputManager::handleEvent") return true; } keyboard.handleActivateKey(event); // send straight to gui for certain windows #ifndef DYECMD if ((quitDialog != nullptr) || TextDialog::isActive()) { if (guiInput != nullptr) guiInput->pushInput(event); if (gui != nullptr) gui->handleInput(); BLOCK_END("InputManager::handleEvent") return true; } #endif // DYECMD break; } case SDL_KEYUP: { #ifdef USE_SDL2 if (keyboard.ignoreKey(event)) { BLOCK_END("InputManager::handleEvent") return true; } #endif // USE_SDL2 keyboard.refreshActiveKeys(); updateConditionMask(false); keyboard.handleDeActicateKey(event); break; } case SDL_JOYBUTTONDOWN: { updateConditionMask(true); // joystick.handleActicateButton(event); if (handleAssignKey(event, InputType::JOYSTICK)) { BLOCK_END("InputManager::handleEvent") return true; } break; } case SDL_JOYBUTTONUP: { updateConditionMask(false); // joystick.handleDeActicateButton(event); break; } #ifdef USE_SDL2 case SDL_FINGERDOWN: multiTouchManager.handleFingerDown(event); break; case SDL_FINGERUP: multiTouchManager.handleFingerUp(event); break; #else // USE_SDL2 #ifdef ANDROID case SDL_ACCELEROMETER: { break; } #endif // ANDROID #endif // USE_SDL2 default: break; } if (guiInput != nullptr) guiInput->pushInput(event); if (gui != nullptr) { const bool res = gui->handleInput(); if (res && event.type == SDL_KEYDOWN) { BLOCK_END("InputManager::handleEvent") return true; } } switch (event.type) { case SDL_KEYDOWN: if (isActionActive(InputAction::IGNORE_INPUT_1) || isActionActive(InputAction::IGNORE_INPUT_2)) { BLOCK_END("InputManager::handleEvent") return true; } if (triggerAction(keyboard.getActionVector(event))) { BLOCK_END("InputManager::handleEvent") return true; } break; // disabled temporary // case SDL_KEYUP: // if (triggerAction(keyboard.getActionVector(event))) // { // BLOCK_END("InputManager::handleEvent") // return true; // } // break; case SDL_JOYBUTTONDOWN: if ((joystick != nullptr) && joystick->validate()) { if (triggerAction(joystick->getActionVector(event))) { BLOCK_END("InputManager::handleEvent") return true; } } break; #ifdef ANDROID #ifndef USE_SDL2 case SDL_ACCELEROMETER: { break; } #endif // USE_SDL2 #endif // ANDROID default: break; } BLOCK_END("InputManager::handleEvent") return false; } void InputManager::handleRepeat() { const int time = tick_time; keyboard.handleRepeat(time); if (joystick != nullptr) joystick->handleRepeat(time); } void InputManager::updateConditionMask(const bool pressed A_UNUSED) restrict2 { mMask = 1; if (keyboard.isEnabled()) mMask |= InputCondition::ENABLED; #ifndef DYECMD if (((chatWindow == nullptr) || !chatWindow->isInputFocused()) && !NpcDialog::isAnyInputFocused() && !InventoryWindow::isAnyInputFocused() && ((tradeWindow == nullptr) || !tradeWindow->isInpupFocused())) { if (gui != nullptr) { FocusHandler *restrict const focus = gui->getFocusHandler(); if (focus != nullptr) { if (dynamic_cast<TextField*>(focus->getFocused()) == nullptr) mMask |= InputCondition::NOINPUT; } else { mMask |= InputCondition::NOINPUT; } } else { mMask |= InputCondition::NOINPUT; } } if (!BuyDialog::isActive() && !SellDialog::isActive()) mMask |= InputCondition::NOBUYSELL; if (!PlayerInfo::isVending()) mMask |= InputCondition::NOVENDING; if (!PlayerInfo::isInRoom()) mMask |= InputCondition::NOROOM; const NpcDialog *restrict const dialog = NpcDialog::getActive(); if ((dialog == nullptr) || !dialog->isTextInputFocused()) mMask |= InputCondition::NONPCINPUT; if ((dialog == nullptr) || (dialog->isCloseState() != 0)) { mMask |= InputCondition::NONPCDIALOG; if (!InventoryWindow::isStorageActive()) mMask |= InputCondition::NOTALKING; } if ((setupWindow == nullptr) || !setupWindow->isWindowVisible()) mMask |= InputCondition::NOSETUP; if ((Game::instance() != nullptr) && Game::instance()->getValidSpeed()) mMask |= InputCondition::VALIDSPEED; if (Game::instance() != nullptr) mMask |= InputCondition::INGAME; if (localPlayer != nullptr) { if (localPlayer->getFollow().empty()) mMask |= InputCondition::NOFOLLOW; if (!localPlayer->isTrickDead()) mMask |= InputCondition::NOBLOCK; if (localPlayer->isAlive()) mMask |= InputCondition::ALIVE; } else { mMask |= InputCondition::NOFOLLOW; mMask |= InputCondition::NOBLOCK; } #endif // DYECMD if (!settings.awayMode) mMask |= InputCondition::NOAWAY; if (gui != nullptr && gui->getFocusHandler()->getModalFocused() == nullptr) mMask |= InputCondition::NOMODAL; if (!settings.disableGameModifiers) mMask |= InputCondition::EMODS; if (!isActionActive0(InputAction::STOP_ATTACK) && !isActionActive0(InputAction::UNTARGET)) { mMask |= InputCondition::NOTARGET; } // enable it temporary mMask |= InputCondition::KEY_DOWN; // if (pressed == true) // mMask |= InputCondition::KEY_DOWN; // else // mMask |= InputCondition::KEY_UP; } bool InputManager::checkKey(const InputActionData *restrict const key) const restrict2 { // logger->log("checkKey mask=%d, condition=%d", mMask, key->condition); if ((key == nullptr) || (key->condition & mMask) != key->condition) return false; return key->modKeyIndex == InputAction::NO_VALUE || isActionActive0(key->modKeyIndex); } bool InputManager::invokeKey(const InputActionData *restrict const key, const InputActionT keyNum) restrict2 { // no validation to keyNum because it validated in caller if (checkKey(key)) { InputEvent evt(keyNum, mMask); ActionFuncPtr func = *(inputActionData[ CAST_SIZE(keyNum)].action); if ((func != nullptr) && func(evt)) return true; } return false; } void InputManager::executeAction(const InputActionT keyNum) restrict2 { if (keyNum < InputAction::MOVE_UP || keyNum >= InputAction::TOTAL) return; ActionFuncPtr func = *(inputActionData[CAST_SIZE( keyNum)].action); if (func != nullptr) { InputEvent evt(keyNum, mMask); func(evt); } } bool InputManager::executeChatCommand(const std::string &restrict cmd, const std::string &restrict args, ChatTab *restrict const tab) restrict2 { const StringIntMapCIter it = mChatMap.find(cmd); if (it != mChatMap.end()) { ActionFuncPtr func = *(inputActionData[(*it).second].action); if (func != nullptr) { InputEvent evt(args, tab, mMask); func(evt); return true; } } else { reportAlways("Unknown chat command: /%s %s", cmd.c_str(), args.c_str()); } return false; } bool InputManager::executeRemoteChatCommand(const std::string &restrict cmd, const std::string &restrict args, ChatTab *restrict const tab) restrict2 { const StringIntMapCIter it = mChatMap.find(cmd); if (it != mChatMap.end()) { const InputActionData &restrict data = inputActionData[(*it).second]; if (data.isProtected == Protected_true) return false; ActionFuncPtr func = *(data.action); if (func != nullptr) { InputEvent evt(args, tab, mMask); func(evt); return true; } } return false; } bool InputManager::executeChatCommand(const InputActionT keyNum, const std::string &restrict args, ChatTab *restrict const tab) restrict2 { if (CAST_S32(keyNum) < 0 || keyNum >= InputAction::TOTAL) return false; ActionFuncPtr func = *(inputActionData[CAST_SIZE( keyNum)].action); if (func != nullptr) { InputEvent evt(args, tab, mMask); func(evt); return true; } return false; } void InputManager::updateKeyActionMap(KeyToActionMap &restrict actionMap, KeyToIdMap &restrict idMap, KeyTimeMap &restrict keyTimeMap, const InputTypeT type) const restrict2 { actionMap.clear(); keyTimeMap.clear(); for (size_t i = 0; i < CAST_SIZE(InputAction::TOTAL); i ++) { const InputFunction &restrict key = mKey[i]; const InputActionData &restrict kd = inputActionData[i]; if (kd.action != nullptr) { for (size_t i2 = 0; i2 < inputFunctionSize; i2 ++) { const InputItem &restrict ki = key.values[i2]; if (ki.type == type && ki.value != -1) { actionMap[ki.value].push_back( static_cast<InputActionT>(i)); } } } if (kd.configField != nullptr && (kd.grp & Input::GRP_GUICHAN) != 0) { for (size_t i2 = 0; i2 < inputFunctionSize; i2 ++) { const InputItem &restrict ki = key.values[i2]; if (ki.type == type && ki.value != -1) idMap[ki.value] = static_cast<InputActionT>(i); } } if (kd.configField != nullptr && (kd.grp & Input::GRP_REPEAT) != 0) { for (size_t i2 = 0; i2 < inputFunctionSize; i2 ++) { const InputItem &restrict ki = key.values[i2]; if (ki.type == type && ki.value != -1) keyTimeMap[ki.value] = 0; } } } inputActionDataSorter.keys = &inputActionData[0]; FOR_EACH (KeyToActionMapIter, it, actionMap) { KeysVector *const keys = &it->second; if (keys->size() > 1) std::sort(keys->begin(), keys->end(), inputActionDataSorter); } } bool InputManager::triggerAction(const KeysVector *restrict const ptrs) restrict2 { if (ptrs == nullptr) return false; // logger->log("ptrs: %d", (int)ptrs.size()); FOR_EACHP (KeysVectorCIter, it, ptrs) { const InputActionT keyNum = *it; if (CAST_S32(keyNum) < 0 || keyNum >= InputAction::TOTAL) continue; if (invokeKey(&inputActionData[CAST_SIZE(keyNum)], keyNum)) return true; } return false; } InputActionT InputManager::getKeyIndex(const int value, const int grp, const InputTypeT type) const restrict2 { for (size_t i = 0; i < CAST_SIZE(InputAction::TOTAL); i++) { const InputFunction &restrict key = mKey[i]; const InputActionData &restrict kd = inputActionData[i]; for (size_t i2 = 0; i2 < inputFunctionSize; i2 ++) { const InputItem &restrict vali2 = key.values[i2]; if (value == vali2.value && (grp & kd.grp) != 0 && vali2.type == type) { return static_cast<InputActionT>(i); } } } return InputAction::NO_VALUE; } InputActionT InputManager::getActionByKey(const SDL_Event &restrict event) const restrict2 { // for now support only keyboard events if (event.type == SDL_KEYDOWN || event.type == SDL_KEYUP) { const InputActionT idx = keyboard.getActionId(event); if (CAST_S32(idx) >= 0 && checkKey(&inputActionData[CAST_SIZE(idx)])) { return idx; } } return InputAction::NO_VALUE; } InputActionT InputManager::getActionByConfigField(const std::string &field) const restrict2 { for (int i = 0; i < CAST_S32(InputAction::TOTAL); i ++) { const std::string cf = inputActionData[i].configField; if (field == cf) return static_cast<InputActionT>(i); } return InputAction::NO_VALUE; } void InputManager::addChatCommands(std::list<std::string> &restrict arr) restrict { const int sz = CAST_S32(InputAction::TOTAL); for (int i = 0; i < sz; i++) { const InputActionData &restrict ad = inputActionData[i]; std::string cmd = ad.chatCommand; if (!cmd.empty()) { StringVect tokens; splitToStringVector(tokens, cmd, '|'); FOR_EACH (StringVectCIter, it, tokens) { cmd = std::string("/").append(*it); if (ad.useArgs == UseArgs_true) cmd.append(" "); arr.push_back(cmd); } } } }