summaryrefslogtreecommitdiff
path: root/src/actions
diff options
context:
space:
mode:
Diffstat (limited to 'src/actions')
-rw-r--r--src/actions/actions.cpp1190
-rw-r--r--src/actions/actions.h132
2 files changed, 1322 insertions, 0 deletions
diff --git a/src/actions/actions.cpp b/src/actions/actions.cpp
new file mode 100644
index 000000000..bf5c03966
--- /dev/null
+++ b/src/actions/actions.cpp
@@ -0,0 +1,1190 @@
+/*
+ * The ManaPlus Client
+ * Copyright (C) 2012-2014 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 "actions/actions.h"
+
+#include "actormanager.h"
+#include "dropshortcut.h"
+#include "emoteshortcut.h"
+#include "game.h"
+#include "gamemodifiers.h"
+#include "itemshortcut.h"
+#include "settings.h"
+#include "soundmanager.h"
+
+#include "being/attributes.h"
+#include "being/localplayer.h"
+#include "being/playerinfo.h"
+#include "being/playerrelations.h"
+
+#include "input/inputmanager.h"
+
+#include "gui/dialogsmanager.h"
+#include "gui/gui.h"
+#include "gui/popupmanager.h"
+#include "gui/sdlinput.h"
+#include "gui/viewport.h"
+
+#include "gui/popups/popupmenu.h"
+
+#include "gui/windows/skilldialog.h"
+#include "gui/windows/socialwindow.h"
+#include "gui/windows/statuswindow.h"
+#include "gui/windows/tradewindow.h"
+#include "gui/windows/questswindow.h"
+#include "gui/windows/quitdialog.h"
+#include "gui/windows/whoisonline.h"
+#include "gui/windows/botcheckerwindow.h"
+#include "gui/windows/buyselldialog.h"
+#include "gui/windows/chatwindow.h"
+#include "gui/windows/debugwindow.h"
+#include "gui/windows/didyouknowwindow.h"
+#include "gui/windows/equipmentwindow.h"
+#include "gui/windows/helpwindow.h"
+#include "gui/windows/inventorywindow.h"
+#include "gui/windows/killstats.h"
+#include "gui/windows/minimap.h"
+#include "gui/windows/npcdialog.h"
+#include "gui/windows/outfitwindow.h"
+#include "gui/windows/setupwindow.h"
+#include "gui/windows/shopwindow.h"
+#include "gui/windows/shortcutwindow.h"
+#include "gui/windows/updaterwindow.h"
+
+#include "gui/widgets/tabs/chattab.h"
+
+#include "render/graphics.h"
+
+#include "net/net.h"
+#include "net/playerhandler.h"
+#include "net/tradehandler.h"
+
+#include "listeners/updatestatuslistener.h"
+
+#include "resources/map/map.h"
+
+#include "utils/gettext.h"
+
+#ifdef ANDROID
+#ifndef USE_SDL2
+#include <SDL_screenkeyboard.h>
+#endif
+#endif
+
+#include "debug.h"
+
+#define impHandler(name) bool name(const InputEvent &event)
+#define impHandler0(name) bool name(const InputEvent &event A_UNUSED)
+
+#define callYellowBar(name) \
+ GameModifiers::name(!inputManager.isActionActive( \
+ InputAction::STOP_ATTACK)); \
+ return true;
+
+#define callYellowBarCond(name) \
+ if (!settings.disableGameModifiers) \
+ { \
+ GameModifiers::name(!inputManager.isActionActive( \
+ InputAction::STOP_ATTACK)); \
+ return true; \
+ } \
+ return false;
+
+extern ShortcutWindow *spellShortcutWindow;
+extern std::string tradePartnerName;
+extern QuitDialog *quitDialog;
+
+namespace ActionManager
+{
+
+static bool closeMoveNpcDialog(bool focus)
+{
+ NpcDialog *const dialog = NpcDialog::getActive();
+ if (dialog)
+ {
+ if (dialog->isCloseState())
+ {
+ dialog->closeDialog();
+ return true;
+ }
+ else if (focus)
+ {
+ dialog->refocus();
+ }
+ }
+ return false;
+}
+
+impHandler(moveUp)
+{
+ if (inputManager.isActionActive(InputAction::EMOTE))
+ return directUp(event);
+ return closeMoveNpcDialog(false);
+}
+
+impHandler(moveDown)
+{
+ if (inputManager.isActionActive(InputAction::EMOTE))
+ return directDown(event);
+ return closeMoveNpcDialog(false);
+}
+
+impHandler(moveLeft)
+{
+ if (outfitWindow && inputManager.isActionActive(InputAction::WEAR_OUTFIT))
+ {
+ outfitWindow->wearPreviousOutfit();
+ if (Game::instance())
+ Game::instance()->setValidSpeed();
+ return true;
+ }
+ if (inputManager.isActionActive(InputAction::EMOTE))
+ return directLeft(event);
+ return closeMoveNpcDialog(false);
+}
+
+impHandler(moveRight)
+{
+ if (outfitWindow && inputManager.isActionActive(InputAction::WEAR_OUTFIT))
+ {
+ outfitWindow->wearNextOutfit();
+ if (Game::instance())
+ Game::instance()->setValidSpeed();
+ return true;
+ }
+ if (inputManager.isActionActive(InputAction::EMOTE))
+ return directRight(event);
+ return closeMoveNpcDialog(false);
+}
+
+impHandler(moveForward)
+{
+ if (inputManager.isActionActive(InputAction::EMOTE))
+ return directRight(event);
+ return closeMoveNpcDialog(false);
+}
+
+impHandler(emote)
+{
+ const int emotion = 1 + event.action - InputAction::EMOTE_1;
+ if (emotion > 0)
+ {
+ if (emoteShortcut)
+ emoteShortcut->useEmote(emotion);
+ if (Game::instance())
+ Game::instance()->setValidSpeed();
+ return true;
+ }
+
+ return false;
+}
+
+impHandler(moveToPoint)
+{
+ const int num = event.action - InputAction::MOVE_TO_POINT_1;
+ if (socialWindow && num >= 0)
+ {
+ socialWindow->selectPortal(num);
+ return true;
+ }
+
+ return false;
+}
+
+impHandler(outfit)
+{
+ if (inputManager.isActionActive(InputAction::WEAR_OUTFIT))
+ {
+ const int num = event.action - InputAction::OUTFIT_1;
+ if (outfitWindow && num >= 0)
+ {
+ outfitWindow->wearOutfit(num);
+ if (Game::instance())
+ Game::instance()->setValidSpeed();
+ return true;
+ }
+ }
+ else if (inputManager.isActionActive(InputAction::COPY_OUTFIT))
+ {
+ const int num = event.action - InputAction::OUTFIT_1;
+ if (outfitWindow && num >= 0)
+ {
+ outfitWindow->copyOutfit(num);
+ if (Game::instance())
+ Game::instance()->setValidSpeed();
+ return true;
+ }
+ }
+
+ return false;
+}
+
+impHandler0(mouseClick)
+{
+ if (!guiInput || !gui)
+ return false;
+
+ int mouseX, mouseY;
+ Gui::getMouseState(&mouseX, &mouseY);
+ guiInput->simulateMouseClick(mouseX, mouseY, MouseButton::RIGHT);
+ return true;
+}
+
+impHandler0(ok)
+{
+ // Close the Browser if opened
+ if (helpWindow && helpWindow->isWindowVisible())
+ {
+ helpWindow->setVisible(false);
+ return true;
+ }
+ // Close the config window, cancelling changes if opened
+ else if (setupWindow && setupWindow->isWindowVisible())
+ {
+ setupWindow->action(ActionEvent(nullptr, "cancel"));
+ return true;
+ }
+ else if (NpcDialog *const dialog = NpcDialog::getActive())
+ {
+ dialog->action(ActionEvent(nullptr, "ok"));
+ return true;
+ }
+ return false;
+}
+
+impHandler(shortcut)
+{
+ if (itemShortcutWindow)
+ {
+ const int num = itemShortcutWindow->getTabIndex();
+ if (num >= 0 && num < static_cast<int>(SHORTCUT_TABS))
+ {
+ if (itemShortcut[num])
+ {
+ itemShortcut[num]->useItem(event.action
+ - InputAction::SHORTCUT_1);
+ }
+ }
+ return true;
+ }
+ return false;
+}
+
+impHandler0(toggleChat)
+{
+ return chatWindow ? chatWindow->requestChatFocus() : false;
+}
+
+impHandler0(prevChatTab)
+{
+ if (chatWindow)
+ {
+ chatWindow->prevTab();
+ return true;
+ }
+ return false;
+}
+
+impHandler0(nextChatTab)
+{
+ if (chatWindow)
+ {
+ chatWindow->nextTab();
+ return true;
+ }
+ return false;
+}
+
+impHandler0(closeChatTab)
+{
+ if (chatWindow)
+ {
+ chatWindow->closeTab();
+ return true;
+ }
+ return false;
+}
+
+impHandler0(prevSocialTab)
+{
+ if (socialWindow)
+ {
+ socialWindow->prevTab();
+ return true;
+ }
+ return false;
+}
+
+impHandler0(nextSocialTab)
+{
+ if (socialWindow)
+ {
+ socialWindow->nextTab();
+ return true;
+ }
+ return false;
+}
+
+impHandler0(scrollChatUp)
+{
+ if (chatWindow && chatWindow->isWindowVisible())
+ {
+ chatWindow->scroll(-DEFAULT_CHAT_WINDOW_SCROLL);
+ return true;
+ }
+ return false;
+}
+
+impHandler0(scrollChatDown)
+{
+ if (chatWindow && chatWindow->isWindowVisible())
+ {
+ chatWindow->scroll(DEFAULT_CHAT_WINDOW_SCROLL);
+ return true;
+ }
+ return false;
+}
+
+impHandler0(quit)
+{
+ if (!Game::instance())
+ return false;
+ if (popupManager && popupManager->isPopupMenuVisible())
+ {
+ popupManager->closePopupMenu();
+ return true;
+ }
+ else if (!quitDialog)
+ {
+ quitDialog = new QuitDialog(&quitDialog);
+ quitDialog->postInit();
+ quitDialog->requestMoveToTop();
+ return true;
+ }
+ return false;
+}
+
+impHandler0(dropItem0)
+{
+ if (dropShortcut)
+ {
+ dropShortcut->dropFirst();
+ return true;
+ }
+ return false;
+}
+
+impHandler0(dropItem)
+{
+ if (dropShortcut)
+ {
+ dropShortcut->dropItems();
+ return true;
+ }
+ return false;
+}
+
+impHandler0(switchQuickDrop)
+{
+ callYellowBarCond(changeQuickDropCounter)
+}
+
+impHandler0(heal)
+{
+ if (actorManager)
+ {
+ if (inputManager.isActionActive(InputAction::STOP_ATTACK))
+ {
+ Being *target = localPlayer->getTarget();
+ if (!target || target->getType() != ActorType::PLAYER)
+ {
+ target = actorManager->findNearestLivingBeing(
+ localPlayer, 10, ActorType::PLAYER, true);
+ if (target)
+ localPlayer->setTarget(target);
+ }
+ }
+
+ actorManager->healTarget();
+ if (Game::instance())
+ Game::instance()->setValidSpeed();
+ return true;
+ }
+ return false;
+}
+
+impHandler0(crazyMoves)
+{
+ if (localPlayer)
+ {
+ localPlayer->crazyMove();
+ return true;
+ }
+ return false;
+}
+
+impHandler0(itenplz)
+{
+ if (actorManager)
+ {
+ if (Net::getPlayerHandler() && Net::getPlayerHandler()->canUseMagic()
+ && PlayerInfo::getAttribute(Attributes::MP) >= 3)
+ {
+ actorManager->itenplz();
+ }
+ return true;
+ }
+ return false;
+}
+
+impHandler0(changeCrazyMove)
+{
+ callYellowBar(changeCrazyMoveType);
+}
+
+impHandler0(changePickupType)
+{
+ callYellowBar(changePickUpType);
+}
+
+impHandler0(moveToTarget)
+{
+ if (localPlayer && !inputManager.isActionActive(InputAction::TARGET_ATTACK)
+ && !inputManager.isActionActive(InputAction::ATTACK))
+ {
+ localPlayer->moveToTarget();
+ return true;
+ }
+ return false;
+}
+
+impHandler0(moveToHome)
+{
+ if (localPlayer && !inputManager.isActionActive(InputAction::TARGET_ATTACK)
+ && !inputManager.isActionActive(InputAction::ATTACK))
+ {
+ localPlayer->moveToHome();
+ if (Game::instance())
+ Game::instance()->setValidSpeed();
+ return true;
+ }
+ return false;
+}
+
+impHandler0(setHome)
+{
+ if (localPlayer)
+ {
+ localPlayer->setHome();
+ return true;
+ }
+ return false;
+}
+
+impHandler0(changeMoveType)
+{
+ callYellowBar(changeMoveType);
+}
+
+impHandler0(changeAttackWeaponType)
+{
+ callYellowBar(changeAttackWeaponType);
+}
+
+impHandler0(changeAttackType)
+{
+ callYellowBar(changeAttackType);
+}
+
+impHandler0(changeFollowMode)
+{
+ callYellowBar(changeFollowMode);
+}
+
+impHandler0(changeImitationMode)
+{
+ callYellowBar(changeImitationMode);
+}
+
+impHandler0(magicAttack)
+{
+ if (localPlayer)
+ {
+ localPlayer->magicAttack();
+ return true;
+ }
+ return false;
+}
+
+impHandler0(changeMagicAttackType)
+{
+ callYellowBar(changeMagicAttackType);
+}
+
+impHandler0(changePvpMode)
+{
+ callYellowBar(changePvpAttackType);
+}
+
+impHandler0(changeMoveToTarget)
+{
+ callYellowBar(changeMoveToTargetType);
+}
+
+impHandler0(copyEquippedToOutfit)
+{
+ if (outfitWindow)
+ {
+ outfitWindow->copyFromEquiped();
+ return true;
+ }
+ return false;
+}
+
+impHandler0(changeGameModifier)
+{
+ if (localPlayer)
+ {
+ GameModifiers::changeGameModifiers();
+ return true;
+ }
+ return false;
+}
+
+impHandler0(changeAudio)
+{
+ soundManager.changeAudio();
+ if (localPlayer)
+ localPlayer->updateMusic();
+ return true;
+}
+
+impHandler0(away)
+{
+ GameModifiers::changeAwayMode();
+ if (localPlayer)
+ {
+ localPlayer->updateStatus();
+ if (Game::instance())
+ Game::instance()->setValidSpeed();
+ return true;
+ }
+ return false;
+}
+
+impHandler0(camera)
+{
+ if (viewport)
+ {
+ viewport->toggleCameraMode();
+ if (Game::instance())
+ Game::instance()->setValidSpeed();
+ return true;
+ }
+ return false;
+}
+
+impHandler0(setupWindowShow)
+{
+ if (setupWindow)
+ {
+ if (setupWindow->isWindowVisible())
+ {
+ setupWindow->doCancel();
+ }
+ else
+ {
+ setupWindow->setVisible(true);
+ setupWindow->requestMoveToTop();
+ }
+ return true;
+ }
+ return false;
+}
+
+impHandler0(pickup)
+{
+ if (localPlayer)
+ {
+ localPlayer->pickUpItems();
+ return true;
+ }
+ return false;
+}
+
+static void doSit()
+{
+ if (inputManager.isActionActive(InputAction::EMOTE))
+ localPlayer->updateSit();
+ else
+ localPlayer->toggleSit();
+}
+
+impHandler0(sit)
+{
+ if (localPlayer)
+ {
+ doSit();
+ return true;
+ }
+ return false;
+}
+
+impHandler0(hideWindows)
+{
+ if (setupWindow)
+ setupWindow->hideWindows();
+ return true;
+}
+
+static bool showHelpPage(const std::string &page, const bool showHide)
+{
+ if (helpWindow)
+ {
+ if (showHide && helpWindow->isWindowVisible())
+ {
+ helpWindow->setVisible(false);
+ }
+ else
+ {
+ helpWindow->loadHelp(page);
+ helpWindow->requestMoveToTop();
+ }
+ return true;
+ }
+ return false;
+}
+
+impHandler0(helpWindowShow)
+{
+ return showHelpPage("index", true);
+}
+
+impHandler0(aboutWindowShow)
+{
+ return showHelpPage("about", false);
+}
+
+static void showHideWindow(Window *const window)
+{
+ if (window)
+ {
+ window->setVisible(!window->isWindowVisible());
+ if (window->isWindowVisible())
+ window->requestMoveToTop();
+ }
+}
+
+impHandler0(statusWindowShow)
+{
+ showHideWindow(statusWindow);
+ return true;
+}
+
+impHandler0(inventoryWindowShow)
+{
+ showHideWindow(inventoryWindow);
+ return true;
+}
+
+impHandler0(equipmentWindowShow)
+{
+ showHideWindow(equipmentWindow);
+ return true;
+}
+
+impHandler0(skillDialogShow)
+{
+ showHideWindow(skillDialog);
+ return true;
+}
+
+impHandler0(minimapWindowShow)
+{
+ if (minimap)
+ {
+ minimap->toggle();
+ return true;
+ }
+ return false;
+}
+
+impHandler0(chatWindowShow)
+{
+ showHideWindow(chatWindow);
+ return true;
+}
+
+impHandler0(shortcutWindowShow)
+{
+ showHideWindow(itemShortcutWindow);
+ return true;
+}
+
+impHandler0(debugWindowShow)
+{
+ showHideWindow(debugWindow);
+ return true;
+}
+
+impHandler0(socialWindowShow)
+{
+ showHideWindow(socialWindow);
+ return true;
+}
+
+impHandler0(emoteShortcutWindowShow)
+{
+ showHideWindow(emoteShortcutWindow);
+ return true;
+}
+
+impHandler0(outfitWindowShow)
+{
+ showHideWindow(outfitWindow);
+ return true;
+}
+
+impHandler0(shopWindowShow)
+{
+ showHideWindow(shopWindow);
+ return true;
+}
+
+impHandler0(dropShortcutWindowShow)
+{
+ showHideWindow(dropShortcutWindow);
+ return true;
+}
+
+impHandler0(killStatsWindowShow)
+{
+ showHideWindow(killStats);
+ return true;
+}
+
+impHandler0(spellShortcutWindowShow)
+{
+ showHideWindow(spellShortcutWindow);
+ return true;
+}
+
+impHandler0(botcheckerWindowShow)
+{
+ showHideWindow(botCheckerWindow);
+ return true;
+}
+
+impHandler0(whoIsOnlineWindowShow)
+{
+ showHideWindow(whoIsOnline);
+ return true;
+}
+
+impHandler0(didYouKnowWindowShow)
+{
+ showHideWindow(didYouKnowWindow);
+ return true;
+}
+
+impHandler0(questsWindowShow)
+{
+ showHideWindow(questsWindow);
+ return true;
+}
+
+impHandler0(updaterWindowShow)
+{
+ if (updaterWindow)
+ updaterWindow->deleteSelf();
+ else
+ DialogsManager::createUpdaterWindow();
+ return true;
+}
+
+impHandler0(changeMapMode)
+{
+ if (viewport)
+ viewport->toggleMapDrawType();
+ UpdateStatusListener::distributeEvent();
+ if (Game::instance())
+ {
+ if (Map *const map = Game::instance()->getCurrentMap())
+ map->redrawMap();
+ }
+ return true;
+}
+
+impHandler0(changeTrade)
+{
+ unsigned int deflt = player_relations.getDefault();
+ if (deflt & PlayerRelation::TRADE)
+ {
+ if (localChatTab)
+ {
+ // TRANSLATORS: disable trades message
+ localChatTab->chatLog(_("Ignoring incoming trade requests"),
+ ChatMsgType::BY_SERVER);
+ }
+ deflt &= ~PlayerRelation::TRADE;
+ }
+ else
+ {
+ if (localChatTab)
+ {
+ // TRANSLATORS: enable trades message
+ localChatTab->chatLog(_("Accepting incoming trade requests"),
+ ChatMsgType::BY_SERVER);
+ }
+ deflt |= PlayerRelation::TRADE;
+ }
+
+ player_relations.setDefault(deflt);
+ return true;
+}
+
+impHandler0(screenshot)
+{
+ Game::createScreenshot();
+ return true;
+}
+
+impHandler0(ignoreInput)
+{
+ return true;
+}
+
+impHandler0(directUp)
+{
+ if (localPlayer)
+ {
+ if (localPlayer->getDirection() != BeingDirection::UP)
+ {
+// if (PacketLimiter::limitPackets(PACKET_DIRECTION))
+ {
+ localPlayer->setDirection(BeingDirection::UP);
+ if (Net::getPlayerHandler())
+ Net::getPlayerHandler()->setDirection(BeingDirection::UP);
+ }
+ }
+ return true;
+ }
+ return false;
+}
+
+impHandler0(directDown)
+{
+ if (localPlayer)
+ {
+ if (localPlayer->getDirection() != BeingDirection::DOWN)
+ {
+// if (PacketLimiter::limitPackets(PACKET_DIRECTION))
+ {
+ localPlayer->setDirection(BeingDirection::DOWN);
+ if (Net::getPlayerHandler())
+ {
+ Net::getPlayerHandler()->setDirection(
+ BeingDirection::DOWN);
+ }
+ }
+ }
+ return true;
+ }
+ return false;
+}
+
+impHandler0(directLeft)
+{
+ if (localPlayer)
+ {
+ if (localPlayer->getDirection() != BeingDirection::LEFT)
+ {
+// if (PacketLimiter::limitPackets(PACKET_DIRECTION))
+ {
+ localPlayer->setDirection(BeingDirection::LEFT);
+ if (Net::getPlayerHandler())
+ {
+ Net::getPlayerHandler()->setDirection(
+ BeingDirection::LEFT);
+ }
+ }
+ }
+ return true;
+ }
+ return false;
+}
+
+impHandler0(directRight)
+{
+ if (localPlayer)
+ {
+ if (localPlayer->getDirection() != BeingDirection::RIGHT)
+ {
+// if (PacketLimiter::limitPackets(PACKET_DIRECTION))
+ {
+ localPlayer->setDirection(BeingDirection::RIGHT);
+ if (Net::getPlayerHandler())
+ {
+ Net::getPlayerHandler()->setDirection(
+ BeingDirection::RIGHT);
+ }
+ }
+ }
+ return true;
+ }
+ return false;
+}
+
+impHandler0(talk)
+{
+ if (localPlayer)
+ {
+ Being *target = localPlayer->getTarget();
+ if (!target && actorManager)
+ {
+ target = actorManager->findNearestLivingBeing(
+ localPlayer, 1, ActorType::NPC, true);
+ // ignore closest target if distance in each direction more than 1
+ if (target)
+ {
+ if (abs(target->getTileX() - localPlayer->getTileX()) > 1
+ || abs(target->getTileY() - localPlayer->getTileY()) > 1)
+ {
+ return true;
+ }
+ }
+ }
+ if (target)
+ {
+ if (target->canTalk())
+ target->talkTo();
+ else if (target->getType() == ActorType::PLAYER)
+ new BuySellDialog(target->getName());
+ }
+ return true;
+ }
+ return false;
+}
+
+impHandler0(stopAttack)
+{
+ if (localPlayer)
+ {
+ localPlayer->stopAttack();
+ // not consume if target attack key pressed
+ if (inputManager.isActionActive(InputAction::TARGET_ATTACK))
+ return false;
+ return true;
+ }
+ return false;
+}
+
+impHandler0(untarget)
+{
+ if (localPlayer)
+ {
+ localPlayer->untarget();
+ return true;
+ }
+ return false;
+}
+
+impHandler0(attack)
+{
+ if (localPlayer)
+ {
+ Being *const target = localPlayer->getTarget();
+ if (target)
+ localPlayer->attack(target, true);
+ return true;
+ }
+ return false;
+}
+
+impHandler0(targetAttack)
+{
+ if (localPlayer && actorManager)
+ {
+ Being *target = nullptr;
+
+ const bool newTarget = !inputManager.isActionActive(
+ InputAction::STOP_ATTACK);
+ // A set target has highest priority
+ if (!localPlayer->getTarget())
+ {
+ // Only auto target Monsters
+ target = actorManager->findNearestLivingBeing(
+ localPlayer, 90, ActorType::MONSTER, true);
+ }
+ else
+ {
+ target = localPlayer->getTarget();
+ }
+
+ localPlayer->attack2(target, newTarget);
+ return true;
+ }
+ return false;
+}
+
+static bool setTarget(const ActorType::Type type, const bool allowSort)
+{
+ if (actorManager && localPlayer)
+ {
+ Being *const target = actorManager->findNearestLivingBeing(
+ localPlayer, 20, type, allowSort);
+
+ if (target && target != localPlayer->getTarget())
+ localPlayer->setTarget(target);
+
+ return true;
+ }
+ return false;
+}
+
+impHandler0(targetPlayer)
+{
+ return setTarget(ActorType::PLAYER, true);
+}
+
+impHandler0(targetMonster)
+{
+ return setTarget(ActorType::MONSTER, true);
+}
+
+impHandler0(targetClosestMonster)
+{
+ return setTarget(ActorType::MONSTER, false);
+}
+
+impHandler0(targetNPC)
+{
+ return setTarget(ActorType::NPC, true);
+}
+
+impHandler0(safeVideoMode)
+{
+ if (mainGraphics)
+ mainGraphics->setFullscreen(false);
+
+ return true;
+}
+
+impHandler0(stopSit)
+{
+ if (localPlayer)
+ {
+ localPlayer->stopAttack();
+ // not consume if target attack key pressed
+ if (inputManager.isActionActive(InputAction::TARGET_ATTACK))
+ return false;
+ if (!localPlayer->getTarget())
+ {
+ doSit();
+ return true;
+ }
+ return true;
+ }
+ return false;
+}
+
+impHandler0(showKeyboard)
+{
+#ifdef ANDROID
+#ifdef USE_SDL2
+ if (SDL_IsTextInputActive())
+ SDL_StopTextInput();
+ else
+ SDL_StartTextInput();
+#else
+ SDL_ANDROID_ToggleScreenKeyboardTextInput(nullptr);
+#endif
+ return true;
+#else
+ return false;
+#endif
+}
+
+impHandler0(showWindows)
+{
+ if (popupMenu)
+ {
+ popupMenu->showWindowsPopup(viewport->mMouseX,
+ viewport->mMouseY);
+ return true;
+ }
+ return false;
+}
+
+impHandler0(nextShortcutsTab)
+{
+ if (itemShortcutWindow)
+ {
+ itemShortcutWindow->nextTab();
+ return true;
+ }
+ return false;
+}
+
+impHandler0(prevShortcutsTab)
+{
+ if (itemShortcutWindow)
+ {
+ itemShortcutWindow->prevTab();
+ return true;
+ }
+ return false;
+}
+
+impHandler0(nextCommandsTab)
+{
+ if (spellShortcutWindow)
+ {
+ spellShortcutWindow->nextTab();
+ return true;
+ }
+ return false;
+}
+
+impHandler0(prevCommandsTab)
+{
+ if (spellShortcutWindow)
+ {
+ spellShortcutWindow->prevTab();
+ return true;
+ }
+ return false;
+}
+
+impHandler0(openTrade)
+{
+ const Being *const being = localPlayer->getTarget();
+ if (being && being->getType() == ActorType::PLAYER)
+ {
+ Net::getTradeHandler()->request(being);
+ tradePartnerName = being->getName();
+ if (tradeWindow)
+ tradeWindow->clear();
+ return true;
+ }
+ return false;
+}
+
+} // namespace ActionManager
diff --git a/src/actions/actions.h b/src/actions/actions.h
new file mode 100644
index 000000000..a1b7f3287
--- /dev/null
+++ b/src/actions/actions.h
@@ -0,0 +1,132 @@
+/*
+ * The ManaPlus Client
+ * Copyright (C) 2011-2014 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/>.
+ */
+
+#ifndef ACTIONS_ACTIONS_H
+#define ACTIONS_ACTIONS_H
+
+#define decHandler(name) bool name(const InputEvent &event)
+
+struct InputEvent;
+
+namespace ActionManager
+{
+ decHandler(moveUp);
+ decHandler(moveDown);
+ decHandler(moveLeft);
+ decHandler(moveRight);
+ decHandler(moveForward);
+ decHandler(emote);
+ decHandler(outfit);
+ decHandler(moveToPoint);
+ decHandler(mouseClick);
+ decHandler(ok);
+ decHandler(shortcut);
+ decHandler(toggleChat);
+ decHandler(prevChatTab);
+ decHandler(nextChatTab);
+ decHandler(closeChatTab);
+ decHandler(prevSocialTab);
+ decHandler(nextSocialTab);
+ decHandler(scrollChatUp);
+ decHandler(scrollChatDown);
+ decHandler(quit);
+ decHandler(dropItem0);
+ decHandler(dropItem);
+ decHandler(switchQuickDrop);
+ decHandler(heal);
+ decHandler(crazyMoves);
+ decHandler(itenplz);
+ decHandler(changeCrazyMove);
+ decHandler(changePickupType);
+ decHandler(moveToTarget);
+ decHandler(moveToHome);
+ decHandler(setHome);
+ decHandler(changeMoveType);
+ decHandler(changeAttackWeaponType);
+ decHandler(changeAttackType);
+ decHandler(changeFollowMode);
+ decHandler(changeImitationMode);
+ decHandler(magicAttack);
+ decHandler(changeMagicAttackType);
+ decHandler(changePvpMode);
+ decHandler(changeMoveToTarget);
+ decHandler(copyEquippedToOutfit);
+ decHandler(changeGameModifier);
+ decHandler(changeAudio);
+ decHandler(away);
+ decHandler(camera);
+ decHandler(pickup);
+ decHandler(sit);
+ decHandler(changeMapMode);
+ decHandler(changeTrade);
+ decHandler(screenshot);
+ decHandler(ignoreInput);
+ decHandler(directUp);
+ decHandler(directDown);
+ decHandler(directLeft);
+ decHandler(directRight);
+ decHandler(talk);
+ decHandler(stopAttack);
+ decHandler(untarget);
+ decHandler(attack);
+ decHandler(targetAttack);
+ decHandler(targetPlayer);
+ decHandler(targetMonster);
+ decHandler(targetClosestMonster);
+ decHandler(targetNPC);
+ decHandler(safeVideoMode);
+ decHandler(stopSit);
+ decHandler(showKeyboard);
+ decHandler(showWindows);
+ decHandler(nextShortcutsTab);
+ decHandler(prevShortcutsTab);
+ decHandler(nextCommandsTab);
+ decHandler(prevCommandsTab);
+ decHandler(openTrade);
+
+ decHandler(hideWindows);
+ decHandler(helpWindowShow);
+ decHandler(aboutWindowShow);
+ decHandler(setupWindowShow);
+ decHandler(statusWindowShow);
+ decHandler(inventoryWindowShow);
+ decHandler(equipmentWindowShow);
+ decHandler(skillDialogShow);
+ decHandler(minimapWindowShow);
+ decHandler(chatWindowShow);
+ decHandler(shortcutWindowShow);
+ decHandler(debugWindowShow);
+ decHandler(socialWindowShow);
+ decHandler(emoteShortcutWindowShow);
+ decHandler(outfitWindowShow);
+ decHandler(shopWindowShow);
+ decHandler(dropShortcutWindowShow);
+ decHandler(killStatsWindowShow);
+ decHandler(spellShortcutWindowShow);
+ decHandler(botcheckerWindowShow);
+ decHandler(whoIsOnlineWindowShow);
+ decHandler(didYouKnowWindowShow);
+ decHandler(questsWindowShow);
+ decHandler(updaterWindowShow);
+} // namespace ActionManager
+
+#undef decHandler
+
+#endif // ACTIONS_ACTIONS_H