Move manaplus game related files into progs/manaplus.

14 files changed, 9731 insertions, 1 deletions

diff --git a/src/progs/dyecmd/client.cpp b/src/progs/dyecmd/client.cpp
index 42b570a6b..7f75f4cd5 100644
--- a/src/progs/dyecmd/client.cpp
+++ b/src/progs/dyecmd/client.cpp
@@ -20,7 +20,7 @@
  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "client.h"
+#include "progs/dyecmd/client.h"
 
 #include "configmanager.h"
 #include "dirs.h"
diff --git a/src/progs/manaplus/actions/actions.cpp b/src/progs/manaplus/actions/actions.cpp
new file mode 100644
index 000000000..b958f8f62
--- /dev/null
+++ b/src/progs/manaplus/actions/actions.cpp
@@ -0,0 +1,1914 @@
+/*
+ *  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 "actions/actions.h"
+
+#include "actormanager.h"
+#include "configuration.h"
+#include "game.h"
+#ifdef USE_OPENGL
+#include "graphicsmanager.h"
+#endif  // USE_OPENGL
+#include "main.h"
+#include "spellmanager.h"
+
+#include "actions/actiondef.h"
+
+#include "being/localplayer.h"
+#include "being/playerinfo.h"
+
+#include "const/spells.h"
+
+#include "const/resources/skill.h"
+
+#include "fs/files.h"
+
+#include "gui/gui.h"
+#include "gui/popupmanager.h"
+#include "gui/sdlinput.h"
+#include "gui/windowmanager.h"
+
+#include "gui/shortcut/dropshortcut.h"
+#include "gui/shortcut/emoteshortcut.h"
+#include "gui/shortcut/itemshortcut.h"
+
+#include "gui/popups/popupmenu.h"
+
+#include "gui/windows/buydialog.h"
+#include "gui/windows/okdialog.h"
+#include "gui/windows/tradewindow.h"
+#include "gui/windows/quitdialog.h"
+#include "gui/windows/buyselldialog.h"
+#include "gui/windows/chatwindow.h"
+#include "gui/windows/helpwindow.h"
+#include "gui/windows/inventorywindow.h"
+#include "gui/windows/itemamountwindow.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/skilldialog.h"
+#include "gui/windows/whoisonline.h"
+
+#include "gui/widgets/createwidget.h"
+
+#include "gui/widgets/tabs/chat/chattab.h"
+
+#include "input/inputactionoperators.h"
+
+#if defined USE_OPENGL
+#include "render/normalopenglgraphics.h"
+#endif  // USE_OPENGL
+
+#include "net/adminhandler.h"
+#include "net/beinghandler.h"
+#include "net/buyingstorehandler.h"
+#include "net/buysellhandler.h"
+#include "net/chathandler.h"
+#include "net/download.h"
+#include "net/homunculushandler.h"
+#include "net/gamehandler.h"
+#include "net/inventoryhandler.h"
+#include "net/ipc.h"
+#include "net/mercenaryhandler.h"
+#include "net/net.h"
+#include "net/npchandler.h"
+#include "net/playerhandler.h"
+#include "net/serverfeatures.h"
+#include "net/uploadcharinfo.h"
+#include "net/tradehandler.h"
+#include "net/vendinghandler.h"
+
+#include "resources/iteminfo.h"
+#include "resources/memorymanager.h"
+
+#include "resources/resourcemanager/resourcemanager.h"
+
+#include "utils/chatutils.h"
+#include "utils/delete2.h"
+#include "utils/foreach.h"
+#include "utils/gettext.h"
+#include "utils/mathutils.h"
+#include "utils/parameters.h"
+#include "utils/timer.h"
+
+PRAGMA48(GCC diagnostic push)
+PRAGMA48(GCC diagnostic ignored "-Wshadow")
+#ifdef ANDROID
+#ifndef USE_SDL2
+#include <SDL_screenkeyboard.h>
+#endif  // USE_OPENGL
+#endif  // ANDROID
+PRAGMA48(GCC diagnostic pop)
+
+#include <sstream>
+
+#include "debug.h"
+
+extern std::string tradePartnerName;
+extern QuitDialog *quitDialog;
+extern time_t start_time;
+extern char **environ;
+
+namespace Actions
+{
+
+static int uploadUpdate(void *ptr,
+                        const DownloadStatusT status,
+                        size_t total A_UNUSED,
+                        const size_t remaining A_UNUSED) A_NONNULL(1);
+
+static int uploadUpdate(void *ptr,
+                        const DownloadStatusT status,
+                        size_t total A_UNUSED,
+                        const size_t remaining A_UNUSED)
+{
+    if (status == DownloadStatus::Idle || status == DownloadStatus::Starting)
+        return 0;
+
+    UploadChatInfo *const info = reinterpret_cast<UploadChatInfo*>(ptr);
+    if (info == nullptr)
+        return 0;
+
+    if (status == DownloadStatus::Complete)
+    {
+        std::string str = Net::Download::getUploadResponse();
+        const size_t sz = str.size();
+        if (sz > 0)
+        {
+            if (str[sz - 1] == '\n')
+                str = str.substr(0, sz - 1);
+            str.append(info->addStr);
+            ChatTab *const tab = info->tab;
+            if (chatWindow != nullptr &&
+                (tab == nullptr || chatWindow->isTabPresent(tab)))
+            {
+                str = strprintf("%s [@@%s |%s@@]",
+                    info->text.c_str(), str.c_str(), str.c_str());
+                outStringNormal(tab, str, str);
+            }
+            else
+            {
+                CREATEWIDGET(OkDialog,
+                    // TRANSLATORS: file uploaded message
+                    _("File uploaded"),
+                    str,
+                    // TRANSLATORS: ok dialog button
+                    _("OK"),
+                    DialogType::OK,
+                    Modal_true,
+                    ShowCenter_false,
+                    nullptr,
+                    260);
+            }
+        }
+    }
+    delete2(info->upload);
+    delete info;
+    return 0;
+}
+
+static void uploadFile(const std::string &str,
+                       const std::string &fileName,
+                       const std::string &addStr,
+                       ChatTab *const tab)
+{
+    UploadChatInfo *const info = new UploadChatInfo;
+    Net::Download *const upload = new Net::Download(info,
+        "http://sprunge.us",
+        &uploadUpdate,
+        false, true, false);
+    info->upload = upload;
+    info->text = str;
+    info->addStr = addStr;
+    info->tab = tab;
+    upload->setFile(fileName);
+    upload->start();
+}
+
+static Being *findBeing(const std::string &name, const bool npc)
+{
+    if ((localPlayer == nullptr) || (actorManager == nullptr))
+        return nullptr;
+
+    Being *being = nullptr;
+
+    if (name.empty())
+    {
+        being = localPlayer->getTarget();
+    }
+    else
+    {
+        being = actorManager->findBeingByName(
+            name, ActorType::Unknown);
+    }
+    if ((being == nullptr) && npc)
+    {
+        being = actorManager->findNearestLivingBeing(
+            localPlayer, 1, ActorType::Npc, AllowSort_true);
+        if (being != nullptr)
+        {
+            if (abs(being->getTileX() - localPlayer->getTileX()) > 1
+                || abs(being->getTileY() - localPlayer->getTileY()) > 1)
+            {
+                being = nullptr;
+            }
+        }
+    }
+    if ((being == nullptr) && npc)
+    {
+        being = actorManager->findNearestLivingBeing(
+            localPlayer, 1, ActorType::Player, AllowSort_true);
+        if (being != nullptr)
+        {
+            if (abs(being->getTileX() - localPlayer->getTileX()) > 1
+                || abs(being->getTileY() - localPlayer->getTileY()) > 1)
+            {
+                being = nullptr;
+            }
+        }
+    }
+    return being;
+}
+
+static Item *getItemByInvIndex(const int index,
+                               const InventoryTypeT invType)
+{
+    const Inventory *inv = nullptr;
+    switch (invType)
+    {
+        case InventoryType::Storage:
+            inv = PlayerInfo::getStorageInventory();
+            break;
+
+        case InventoryType::Inventory:
+            inv = PlayerInfo::getInventory();
+            break;
+        case InventoryType::Trade:
+        case InventoryType::Npc:
+        case InventoryType::Cart:
+        case InventoryType::Vending:
+        case InventoryType::MailEdit:
+        case InventoryType::MailView:
+        case InventoryType::Craft:
+        case InventoryType::TypeEnd:
+        default:
+            break;
+    }
+    if (inv != nullptr)
+        return inv->getItem(index);
+    return nullptr;
+}
+
+static int getAmountFromEvent(const InputEvent &event,
+                              Item *&item0,
+                              const InventoryTypeT invType)
+{
+    Item *const item = getItemByInvIndex(atoi(event.args.c_str()),
+        invType);
+    item0 = item;
+    if (item == nullptr)
+        return 0;
+
+    std::string str = event.args;
+    removeToken(str, " ");
+
+    if (str.empty())
+        return 0;
+
+    int amount = 0;
+    if (str[0] == '-')
+    {
+        if (str.size() > 1)
+        {
+            amount = item->getQuantity() - atoi(str.substr(1).c_str());
+            if (amount <= 0 || amount > item->getQuantity())
+                amount = item->getQuantity();
+        }
+    }
+    else if (str == "/")
+    {
+        amount = item->getQuantity() / 2;
+    }
+    else if (str == "all")
+    {
+        amount = item->getQuantity();
+    }
+    else
+    {
+        amount = atoi(str.c_str());
+    }
+    return amount;
+}
+
+impHandler(emote)
+{
+    const int emotion = 1 + (event.action - InputAction::EMOTE_1);
+    if (emotion > 0)
+    {
+        if (emoteShortcut != nullptr)
+            emoteShortcut->useEmotePlayer(emotion);
+        if (Game::instance() != nullptr)
+            Game::instance()->setValidSpeed();
+        return true;
+    }
+
+    return false;
+}
+
+impHandler(outfit)
+{
+    if (inputManager.isActionActive(InputAction::WEAR_OUTFIT))
+    {
+        const int num = event.action - InputAction::OUTFIT_1;
+        if ((outfitWindow != nullptr) && num >= 0)
+        {
+            outfitWindow->wearOutfit(num);
+            if (Game::instance() != nullptr)
+                Game::instance()->setValidSpeed();
+            return true;
+        }
+    }
+    else if (inputManager.isActionActive(InputAction::COPY_OUTFIT))
+    {
+        const int num = event.action - InputAction::OUTFIT_1;
+        if ((outfitWindow != nullptr) && num >= 0)
+        {
+            outfitWindow->copyOutfit(num);
+            if (Game::instance() != nullptr)
+                Game::instance()->setValidSpeed();
+            return true;
+        }
+    }
+
+    return false;
+}
+
+impHandler0(mouseClick)
+{
+    if ((guiInput == nullptr) || (gui == nullptr))
+        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 != nullptr) && helpWindow->isWindowVisible())
+    {
+        helpWindow->setVisible(Visible_false);
+        return true;
+    }
+    // Close the config window, cancelling changes if opened
+    else if ((setupWindow != nullptr) && setupWindow->isWindowVisible())
+    {
+        setupWindow->action(ActionEvent(nullptr, "cancel"));
+        return true;
+    }
+    else if (NpcDialog *const dialog = NpcDialog::getActive())
+    {
+        dialog->action(ActionEvent(nullptr, "ok"));
+        return true;
+    }
+    else if (popupMenu->isPopupVisible())
+    {
+        popupMenu->select();
+    }
+    return false;
+}
+
+impHandler(shortcut)
+{
+    if (itemShortcutWindow != nullptr)
+    {
+        const int num = itemShortcutWindow->getTabIndex();
+        if (num >= 0 && num < CAST_S32(SHORTCUT_TABS))
+        {
+            if (itemShortcut[num] != nullptr)
+            {
+                itemShortcut[num]->useItem(event.action
+                    - InputAction::SHORTCUT_1);
+            }
+        }
+        return true;
+    }
+    return false;
+}
+
+impHandler0(quit)
+{
+    if (Game::instance() == nullptr)
+        return false;
+    if (PopupManager::isPopupMenuVisible())
+    {
+        PopupManager::closePopupMenu();
+        return true;
+    }
+    else if (quitDialog == nullptr)
+    {
+        CREATEWIDGETV(quitDialog, QuitDialog,
+            &quitDialog);
+        quitDialog->requestMoveToTop();
+        return true;
+    }
+    return false;
+}
+
+impHandler0(dropItem0)
+{
+    if (dropShortcut != nullptr)
+    {
+        dropShortcut->dropFirst();
+        return true;
+    }
+    return false;
+}
+
+impHandler0(dropItem)
+{
+    if (dropShortcut != nullptr)
+    {
+        dropShortcut->dropItems();
+        return true;
+    }
+    return false;
+}
+
+impHandler(dropItemId)
+{
+    const Inventory *const inv = PlayerInfo::getInventory();
+    if (inv == nullptr)
+        return false;
+
+    // +++ ignoring item color for now
+    Item *const item = inv->findItem(atoi(event.args.c_str()),
+        ItemColor_one);
+
+    if ((item != nullptr) && !PlayerInfo::isItemProtected(item->getId()))
+    {
+        ItemAmountWindow::showWindow(ItemAmountWindowUsage::ItemDrop,
+            inventoryWindow, item);
+    }
+    return true;
+}
+
+impHandler(dropItemInv)
+{
+    Item *const item = getItemByInvIndex(atoi(event.args.c_str()),
+        InventoryType::Inventory);
+    if ((item != nullptr) && !PlayerInfo::isItemProtected(item->getId()))
+    {
+        ItemAmountWindow::showWindow(ItemAmountWindowUsage::ItemDrop,
+            inventoryWindow, item);
+    }
+    return true;
+}
+
+impHandler(dropItemIdAll)
+{
+    const Inventory *const inv = PlayerInfo::getInventory();
+    if (inv == nullptr)
+        return false;
+
+    // +++ ignoring item color for now
+    Item *const item = inv->findItem(atoi(event.args.c_str()),
+        ItemColor_one);
+
+    if ((item != nullptr) && !PlayerInfo::isItemProtected(item->getId()))
+        PlayerInfo::dropItem(item, item->getQuantity(), Sfx_true);
+    return true;
+}
+
+impHandler(dropItemInvAll)
+{
+    Item *const item = getItemByInvIndex(atoi(event.args.c_str()),
+        InventoryType::Inventory);
+    if ((item != nullptr) && !PlayerInfo::isItemProtected(item->getId()))
+        PlayerInfo::dropItem(item, item->getQuantity(), Sfx_true);
+    return true;
+}
+
+#ifdef TMWA_SUPPORT
+impHandler(heal)
+{
+    if (Net::getNetworkType() != ServerType::TMWATHENA)
+        return false;
+    if (actorManager != nullptr &&
+        localPlayer != nullptr)
+    {
+        std::string args = event.args;
+
+        if (!args.empty())
+        {
+            const Being *being = nullptr;
+            if (args[0] == ':')
+            {
+                being = actorManager->findBeing(fromInt(atoi(
+                    args.substr(1).c_str()), BeingId));
+                if (being != nullptr && being->getType() == ActorType::Monster)
+                    being = nullptr;
+            }
+            else
+            {
+                being = actorManager->findBeingByName(args, ActorType::Player);
+            }
+            if (being != nullptr)
+                actorManager->heal(being);
+        }
+        else
+        {
+            Being *target = localPlayer->getTarget();
+            if (inputManager.isActionActive(InputAction::STOP_ATTACK))
+            {
+                if (target == nullptr ||
+                    target->getType() != ActorType::Player)
+                {
+                    target = actorManager->findNearestLivingBeing(
+                        localPlayer, 10, ActorType::Player, AllowSort_true);
+                }
+            }
+            else
+            {
+                if (target == nullptr)
+                    target = localPlayer;
+            }
+            actorManager->heal(target);
+        }
+
+        if (Game::instance() != nullptr)
+            Game::instance()->setValidSpeed();
+        return true;
+    }
+    return false;
+}
+#else  // TMWA_SUPPORT
+
+impHandler0(heal)
+{
+    return false;
+}
+#endif  // TMWA_SUPPORT
+
+impHandler0(healmd)
+{
+#ifdef TMWA_SUPPORT
+    if (Net::getNetworkType() != ServerType::TMWATHENA)
+        return false;
+    if (actorManager != nullptr)
+    {
+        const int matk = PlayerInfo::getStatEffective(Attributes::PLAYER_MATK);
+        int maxHealingRadius;
+
+        // magic levels < 2
+        if (PlayerInfo::getSkillLevel(340) < 2
+            || PlayerInfo::getSkillLevel(341) < 2)
+        {
+            maxHealingRadius = matk / 100 + 1;
+        }
+        else
+        {
+            maxHealingRadius = (12 * fastSqrtInt(matk) + matk) / 100 + 1;
+        }
+
+        Being *target = actorManager->findMostDamagedPlayer(maxHealingRadius);
+        if (target != nullptr)
+            actorManager->heal(target);
+
+        if (Game::instance() != nullptr)
+            Game::instance()->setValidSpeed();
+        return true;
+    }
+#endif  // TMWA_SUPPORT
+
+    return false;
+}
+
+impHandler0(itenplz)
+{
+#ifdef TMWA_SUPPORT
+    if (Net::getNetworkType() != ServerType::TMWATHENA)
+        return false;
+    if (actorManager != nullptr)
+    {
+        if (playerHandler != nullptr &&
+            playerHandler->canUseMagic() &&
+            PlayerInfo::getAttribute(Attributes::PLAYER_MP) >= 3)
+        {
+            actorManager->itenplz();
+        }
+        return true;
+    }
+#endif  // TMWA_SUPPORT
+
+    return false;
+}
+
+impHandler0(setHome)
+{
+    if (localPlayer != nullptr)
+    {
+        localPlayer->setHome();
+        return true;
+    }
+    return false;
+}
+
+impHandler0(magicAttack)
+{
+#ifdef TMWA_SUPPORT
+    if (Net::getNetworkType() != ServerType::TMWATHENA)
+        return false;
+    if (localPlayer != nullptr)
+    {
+        localPlayer->magicAttack();
+        return true;
+    }
+#endif  // TMWA_SUPPORT
+
+    return false;
+}
+
+impHandler0(copyEquippedToOutfit)
+{
+    if (outfitWindow != nullptr)
+    {
+        outfitWindow->copyFromEquiped();
+        return true;
+    }
+    return false;
+}
+
+impHandler(pickup)
+{
+    if (localPlayer == nullptr)
+        return false;
+
+    const std::string args = event.args;
+    if (args.empty())
+    {
+        localPlayer->pickUpItems();
+    }
+    else
+    {
+        FloorItem *const item = actorManager->findItem(fromInt(
+            atoi(args.c_str()), BeingId));
+        if (item != nullptr)
+            localPlayer->pickUp(item);
+    }
+    return true;
+}
+
+static void doSit()
+{
+    if (inputManager.isActionActive(InputAction::EMOTE))
+        localPlayer->updateSit();
+    else
+        localPlayer->toggleSit();
+}
+
+impHandler0(sit)
+{
+    if (localPlayer != nullptr)
+    {
+        doSit();
+        return true;
+    }
+    return false;
+}
+
+impHandler(screenshot)
+{
+    Game::createScreenshot(event.args);
+    return true;
+}
+
+impHandler0(ignoreInput)
+{
+    return true;
+}
+
+impHandler(buy)
+{
+    if (serverFeatures == nullptr)
+        return false;
+    const std::string args = event.args;
+    Being *being = findBeing(args, false);
+    if ((being == nullptr) && Net::getNetworkType() == ServerType::TMWATHENA)
+    {
+        if (whoIsOnline != nullptr)
+        {
+            const std::set<std::string> &players =
+                whoIsOnline->getOnlineNicks();
+            if (players.find(args) != players.end())
+            {
+                if (buySellHandler != nullptr)
+                    buySellHandler->requestSellList(args);
+                return true;
+            }
+        }
+        return false;
+    }
+
+    if (being == nullptr)
+        being = findBeing(args, true);
+
+    if (being == nullptr)
+        return false;
+
+    if (being->getType() == ActorType::Npc)
+    {
+        if (npcHandler != nullptr)
+            npcHandler->buy(being);
+        return true;
+    }
+    else if (being->getType() == ActorType::Player)
+    {
+        if (vendingHandler != nullptr &&
+            Net::getNetworkType() != ServerType::TMWATHENA)
+        {
+            vendingHandler->open(being);
+        }
+        else if (buySellHandler != nullptr)
+        {
+            buySellHandler->requestSellList(being->getName());
+        }
+        return true;
+    }
+    return false;
+}
+
+impHandler(sell)
+{
+    if (serverFeatures == nullptr)
+        return false;
+
+    const std::string args = event.args;
+    Being *being = findBeing(args, false);
+    if (being == nullptr &&
+        Net::getNetworkType() == ServerType::TMWATHENA)
+    {
+        if (whoIsOnline != nullptr)
+        {
+            const std::set<std::string> &players =
+                whoIsOnline->getOnlineNicks();
+            if (players.find(args) != players.end())
+            {
+                if (buySellHandler != nullptr)
+                    buySellHandler->requestBuyList(args);
+                return true;
+            }
+        }
+        return false;
+    }
+
+    if (being == nullptr)
+        being = findBeing(args, true);
+
+    if (being == nullptr)
+        return false;
+
+    if (being->getType() == ActorType::Npc)
+    {
+        if (npcHandler != nullptr)
+            npcHandler->sell(being->getId());
+        return true;
+    }
+    else if (being->getType() == ActorType::Player)
+    {
+        if ((buyingStoreHandler != nullptr) &&
+            Net::getNetworkType() != ServerType::TMWATHENA)
+        {
+            buyingStoreHandler->open(being);
+        }
+        else if (buySellHandler != nullptr)
+        {
+            buySellHandler->requestBuyList(being->getName());
+        }
+        return true;
+    }
+    return false;
+}
+
+impHandler(talk)
+{
+    Being *being = findBeing(event.args, true);
+    if (being == nullptr)
+        return false;
+
+    if (being->canTalk())
+    {
+        being->talkTo();
+    }
+    else if (being->getType() == ActorType::Player)
+    {
+        CREATEWIDGET(BuySellDialog,
+            being->getName());
+    }
+    return true;
+}
+
+impHandler0(stopAttack)
+{
+    if (localPlayer != nullptr)
+    {
+        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 != nullptr)
+    {
+        localPlayer->untarget();
+        return true;
+    }
+    return false;
+}
+
+impHandler(attack)
+{
+    if ((localPlayer == nullptr) || (actorManager == nullptr))
+        return false;
+
+    Being *target = nullptr;
+    std::string args = event.args;
+    if (!args.empty())
+    {
+        if (args[0] != ':')
+        {
+            target = actorManager->findNearestByName(args);
+        }
+        else
+        {
+            target = actorManager->findBeing(fromInt(atoi(
+                args.substr(1).c_str()), BeingId));
+            if (target != nullptr &&
+                target->getType() != ActorType::Monster)
+            {
+                target = nullptr;
+            }
+        }
+    }
+    if (target == nullptr)
+        target = localPlayer->getTarget();
+    else
+        localPlayer->setTarget(target);
+    if (target != nullptr)
+        localPlayer->attack(target, true);
+    return true;
+}
+
+impHandler(targetAttack)
+{
+    if ((localPlayer != nullptr) && (actorManager != nullptr))
+    {
+        Being *target = nullptr;
+        std::string args = event.args;
+        const bool newTarget = !inputManager.isActionActive(
+            InputAction::STOP_ATTACK);
+
+        if (!args.empty())
+        {
+            if (args[0] != ':')
+            {
+                target = actorManager->findNearestByName(args);
+            }
+            else
+            {
+                target = actorManager->findBeing(fromInt(atoi(
+                    args.substr(1).c_str()), BeingId));
+                if (target != nullptr &&
+                    target->getType() != ActorType::Monster)
+                {
+                    target = nullptr;
+                }
+            }
+        }
+
+        if ((target == nullptr) && (settings.targetingType == 0u))
+            target = localPlayer->getTarget();
+
+        if (target == nullptr)
+        {
+            target = actorManager->findNearestLivingBeing(
+                localPlayer, 90, ActorType::Monster, AllowSort_true);
+        }
+
+        localPlayer->attack2(target, newTarget);
+        return true;
+    }
+    return false;
+}
+
+impHandler0(attackHuman)
+{
+    if ((actorManager == nullptr) || (localPlayer == nullptr))
+        return false;
+
+    Being *const target = actorManager->findNearestPvpPlayer();
+    if (target != nullptr)
+    {
+        localPlayer->setTarget(target);
+        localPlayer->attack2(target, true);
+    }
+    return true;
+}
+
+impHandler0(safeVideoMode)
+{
+    WindowManager::setFullScreen(false);
+
+    return true;
+}
+
+impHandler0(stopSit)
+{
+    if (localPlayer != nullptr)
+    {
+        localPlayer->stopAttack();
+        // not consume if target attack key pressed
+        if (inputManager.isActionActive(InputAction::TARGET_ATTACK))
+            return false;
+        if (localPlayer->getTarget() == nullptr)
+        {
+            doSit();
+            return true;
+        }
+        return true;
+    }
+    return false;
+}
+
+impHandler0(showKeyboard)
+{
+#ifdef ANDROID
+#ifdef USE_SDL2
+    if (SDL_IsTextInputActive())
+        SDL_StopTextInput();
+    else
+        SDL_StartTextInput();
+#else  // USE_SDL2
+
+    SDL_ANDROID_ToggleScreenKeyboardTextInput(nullptr);
+#endif  // USE_SDL2
+
+    return true;
+#else  // ANDROID
+
+    return false;
+#endif  // ANDROID
+}
+
+impHandler0(showWindows)
+{
+    if (popupMenu != nullptr)
+    {
+        popupMenu->showWindowsPopup();
+        return true;
+    }
+    return false;
+}
+
+impHandler0(openTrade)
+{
+    const Being *const being = localPlayer->getTarget();
+    if ((being != nullptr) && being->getType() == ActorType::Player)
+    {
+        if (tradeHandler != nullptr)
+            tradeHandler->request(being);
+        tradePartnerName = being->getName();
+        if (tradeWindow != nullptr)
+            tradeWindow->clear();
+        return true;
+    }
+    return false;
+}
+
+impHandler0(ipcToggle)
+{
+    if (ipc != nullptr)
+    {
+        IPC::stop();
+        if (ipc == nullptr)
+        {
+            debugChatTab->chatLog("IPC service stopped.",
+                ChatMsgType::BY_SERVER);
+        }
+        else
+        {
+            debugChatTab->chatLog("Unable to stop IPC service.",
+                ChatMsgType::BY_SERVER);
+        }
+    }
+    else
+    {
+        IPC::start();
+        if (ipc != nullptr)
+        {
+            debugChatTab->chatLog(
+                strprintf("IPC service available on port %d", ipc->getPort()),
+                ChatMsgType::BY_SERVER);
+        }
+        else
+        {
+            debugChatTab->chatLog("Unable to start IPC service",
+                ChatMsgType::BY_SERVER);
+        }
+    }
+    return true;
+}
+
+impHandler(where)
+{
+    ChatTab *const tab = event.tab != nullptr ? event.tab : debugChatTab;
+    if (tab == nullptr)
+        return false;
+    std::ostringstream where;
+    where << Game::instance()->getCurrentMapName() << ", coordinates: "
+        << ((localPlayer->getPixelX() - mapTileSize / 2) / mapTileSize)
+        << ", " << ((localPlayer->getPixelY() - mapTileSize) / mapTileSize);
+    tab->chatLog(where.str(), ChatMsgType::BY_SERVER);
+    return true;
+}
+
+impHandler0(who)
+{
+    if (chatHandler != nullptr)
+        chatHandler->who();
+    return true;
+}
+
+impHandler0(cleanGraphics)
+{
+    ResourceManager::clearCache();
+
+    if (debugChatTab != nullptr)
+    {
+        // TRANSLATORS: clear graphics command message
+        debugChatTab->chatLog(_("Cache cleaned"),
+            ChatMsgType::BY_SERVER);
+    }
+    return true;
+}
+
+impHandler0(cleanFonts)
+{
+    if (gui != nullptr)
+        gui->clearFonts();
+    if (debugChatTab != nullptr)
+    {
+        // TRANSLATORS: clear fonts cache message
+        debugChatTab->chatLog(_("Cache cleaned"),
+            ChatMsgType::BY_SERVER);
+    }
+    return true;
+}
+
+impHandler(trade)
+{
+    if (actorManager == nullptr)
+        return false;
+
+    const Being *being = actorManager->findBeingByName(
+        event.args, ActorType::Player);
+    if (being == nullptr)
+        being = localPlayer->getTarget();
+    if (being != nullptr)
+    {
+        if (tradeHandler != nullptr)
+            tradeHandler->request(being);
+        tradePartnerName = being->getName();
+        if (tradeWindow != nullptr)
+            tradeWindow->clear();
+    }
+    return true;
+}
+
+impHandler0(priceLoad)
+{
+    if (shopWindow != nullptr)
+    {
+        shopWindow->loadList();
+        return true;
+    }
+    return false;
+}
+
+impHandler0(priceSave)
+{
+    if (shopWindow != nullptr)
+    {
+        shopWindow->saveList();
+        return true;
+    }
+    return false;
+}
+
+impHandler0(cacheInfo)
+{
+    if ((chatWindow == nullptr) || (debugChatTab == nullptr))
+        return false;
+
+/*
+    Font *const font = chatWindow->getFont();
+    if (!font)
+        return;
+
+    const TextChunkList *const cache = font->getCache();
+    if (!cache)
+        return;
+
+    unsigned int all = 0;
+    // TRANSLATORS: chat fonts message
+    debugChatTab->chatLog(_("font cache size"), ChatMsgType::BY_SERVER);
+    std::string str;
+    for (int f = 0; f < 256; f ++)
+    {
+        if (!cache[f].size)
+        {
+            const unsigned int sz = CAST_S32(cache[f].size);
+            all += sz;
+            str.append(strprintf("%d: %u, ", f, sz));
+        }
+    }
+    debugChatTab->chatLog(str, ChatMsgType::BY_SERVER);
+    // TRANSLATORS: chat fonts message
+    debugChatTab->chatLog(strprintf("%s %d", _("Cache size:"), all),
+        ChatMsgType::BY_SERVER);
+#ifdef DEBUG_FONT_COUNTERS
+    debugChatTab->chatLog("", ChatMsgType::BY_SERVER);
+    debugChatTab->chatLog(strprintf("%s %d",
+        // TRANSLATORS: chat fonts message
+        _("Created:"), font->getCreateCounter()),
+        ChatMsgType::BY_SERVER);
+    debugChatTab->chatLog(strprintf("%s %d",
+        // TRANSLATORS: chat fonts message
+        _("Deleted:"), font->getDeleteCounter()),
+        ChatMsgType::BY_SERVER);
+#endif
+*/
+    return true;
+}
+
+impHandler0(disconnect)
+{
+    if (gameHandler != nullptr)
+        gameHandler->disconnect2();
+    return true;
+}
+
+impHandler(undress)
+{
+    if ((actorManager == nullptr) || (localPlayer == nullptr))
+        return false;
+
+    const std::string args = event.args;
+    StringVect pars;
+    if (!splitParameters(pars, args, " ,", '\"'))
+        return false;
+    Being *target = nullptr;
+    const size_t sz = pars.size();
+    if (sz == 0)
+    {
+        target = localPlayer->getTarget();
+    }
+    else
+    {
+        if (pars[0][0] == ':')
+        {
+            target = actorManager->findBeing(fromInt(atoi(
+                pars[0].substr(1).c_str()), BeingId));
+            if ((target != nullptr) && target->getType() == ActorType::Monster)
+                target = nullptr;
+        }
+        else
+        {
+            target = actorManager->findNearestByName(args);
+        }
+    }
+
+    if (sz == 2)
+    {
+        const int itemId = atoi(pars[1].c_str());
+        if (target != nullptr)
+            target->undressItemById(itemId);
+    }
+    else
+    {
+        if ((target != nullptr) && (beingHandler != nullptr))
+            beingHandler->undress(target);
+    }
+
+    return true;
+}
+
+impHandler0(dirs)
+{
+    if (debugChatTab == nullptr)
+        return false;
+
+    debugChatTab->chatLog("config directory: "
+        + settings.configDir,
+        ChatMsgType::BY_SERVER);
+    debugChatTab->chatLog("logs directory: "
+        + settings.localDataDir,
+        ChatMsgType::BY_SERVER);
+    debugChatTab->chatLog("screenshots directory: "
+        + settings.screenshotDir,
+        ChatMsgType::BY_SERVER);
+    debugChatTab->chatLog("temp directory: "
+        + settings.tempDir,
+        ChatMsgType::BY_SERVER);
+    return true;
+}
+
+impHandler0(uptime)
+{
+    if (debugChatTab == nullptr)
+        return false;
+
+    if (cur_time < start_time)
+    {
+        // TRANSLATORS: uptime command
+        debugChatTab->chatLog(strprintf(_("Client uptime: %s"), "unknown"),
+            ChatMsgType::BY_SERVER);
+    }
+    else
+    {
+        // TRANSLATORS: uptime command
+        debugChatTab->chatLog(strprintf(_("Client uptime: %s"),
+            timeDiffToString(CAST_S32(cur_time - start_time)).c_str()),
+            ChatMsgType::BY_SERVER);
+    }
+    return true;
+}
+
+#ifdef DEBUG_DUMP_LEAKS1
+static void showRes(std::string str, ResourceManager::Resources *res)
+{
+    if (!res)
+        return;
+
+    str.append(toString(res->size()));
+    if (debugChatTab)
+        debugChatTab->chatLog(str, ChatMsgType::BY_SERVER);
+    logger->log(str);
+    ResourceManager::ResourceIterator iter = res->begin();
+    const ResourceManager::ResourceIterator iter_end = res->end();
+    while (iter != iter_end)
+    {
+        if (iter->second && iter->second->mRefCount)
+        {
+            char type = ' ';
+            char isNew = 'N';
+            if (iter->second->getDumped())
+                isNew = 'O';
+            else
+                iter->second->setDumped(true);
+
+            SubImage *const subImage = dynamic_cast<SubImage *>(
+                iter->second);
+            Image *const image = dynamic_cast<Image *>(iter->second);
+            int id = 0;
+            if (subImage)
+                type = 'S';
+            else if (image)
+                type = 'I';
+            if (image)
+                id = image->getGLImage();
+            logger->log("Resource %c%c: %s (%d) id=%d", type,
+                isNew, iter->second->getIdPath().c_str(),
+                iter->second->mRefCount, id);
+        }
+        ++ iter;
+    }
+}
+
+impHandler(dump)
+{
+    if (!debugChatTab)
+        return false;
+
+    if (!event.args.empty())
+    {
+        ResourceManager::Resources *res = ResourceManager::getResources();
+        // TRANSLATORS: dump command
+        showRes(_("Resource images:"), res);
+        res = ResourceManager::getOrphanedResources();
+        // TRANSLATORS: dump command
+        showRes(_("Resource orphaned images:"), res);
+    }
+    else
+    {
+        ResourceManager::Resources *res = ResourceManager::getResources();
+        // TRANSLATORS: dump command
+        debugChatTab->chatLog(_("Resource images:") + toString(res->size()),
+            ChatMsgType::BY_SERVER);
+        res = ResourceManager::getOrphanedResources();
+        // TRANSLATORS: dump command
+        debugChatTab->chatLog(_("Resource orphaned images:")
+            + toString(res->size()),
+            ChatMsgType::BY_SERVER);
+    }
+    return true;
+}
+
+#elif defined ENABLE_MEM_DEBUG
+impHandler0(dump)
+{
+    nvwa::check_leaks();
+    return true;
+}
+#else  // DEBUG_DUMP_LEAKS1
+
+impHandler0(dump)
+{
+    return true;
+}
+#endif  // DEBUG_DUMP_LEAKS1
+
+impHandler0(serverIgnoreAll)
+{
+    if (chatHandler != nullptr)
+        chatHandler->ignoreAll();
+    return true;
+}
+
+impHandler0(serverUnIgnoreAll)
+{
+    if (chatHandler != nullptr)
+        chatHandler->unIgnoreAll();
+    return true;
+}
+
+PRAGMA6(GCC diagnostic push)
+PRAGMA6(GCC diagnostic ignored "-Wnull-dereference")
+impHandler0(error)
+{
+    int *const ptr = nullptr;
+    *(ptr + 1) = 20;
+//    logger->log("test %d", *ptr);
+    exit(1);
+}
+PRAGMA6(GCC diagnostic pop)
+
+impHandler(dumpGraphics)
+{
+    std::string str = strprintf("%s,%s,%dX%dX%d,", PACKAGE_OS, SMALL_VERSION,
+        mainGraphics->getWidth(), mainGraphics->getHeight(),
+        mainGraphics->getBpp());
+
+    if (mainGraphics->getFullScreen())
+        str.append("F");
+    else
+        str.append("W");
+    if (mainGraphics->getHWAccel())
+        str.append("H");
+    else
+        str.append("S");
+
+    if (mainGraphics->getDoubleBuffer())
+        str.append("D");
+    else
+        str.append("_");
+
+#if defined USE_OPENGL
+    str.append(strprintf(",%d", mainGraphics->getOpenGL()));
+#else  // defined USE_OPENGL
+
+    str.append(",0");
+#endif  // defined USE_OPENGL
+
+    str.append(strprintf(",%f,", static_cast<double>(settings.guiAlpha)))
+        .append(config.getBoolValue("adjustPerfomance") ? "1" : "0")
+        .append(config.getBoolValue("alphaCache") ? "1" : "0")
+        .append(config.getBoolValue("enableMapReduce") ? "1" : "0")
+        .append(config.getBoolValue("beingopacity") ? "1" : "0")
+        .append(",")
+        .append(config.getBoolValue("enableAlphaFix") ? "1" : "0")
+        .append(config.getBoolValue("disableAdvBeingCaching") ? "1" : "0")
+        .append(config.getBoolValue("disableBeingCaching") ? "1" : "0")
+        .append(config.getBoolValue("particleeffects") ? "1" : "0")
+        .append(strprintf(",%d-%d", fps, config.getIntValue("fpslimit")));
+    outStringNormal(event.tab, str, str);
+    return true;
+}
+
+impHandler0(dumpEnvironment)
+{
+    logger->log1("Start environment variables");
+    for (char **env = environ; *env != nullptr; ++ env)
+        logger->log1(*env);
+    logger->log1("End environment variables");
+    if (debugChatTab != nullptr)
+    {
+        // TRANSLATORS: dump environment command
+        debugChatTab->chatLog(_("Environment variables dumped"),
+            ChatMsgType::BY_SERVER);
+    }
+    return true;
+}
+
+impHandler(dumpTests)
+{
+    const std::string str = config.getStringValue("testInfo");
+    outStringNormal(event.tab, str, str);
+    return true;
+}
+
+impHandler0(dumpOGL)
+{
+#if defined(USE_OPENGL) && !defined(ANDROID) && !defined(__native_client__)
+    NormalOpenGLGraphics::dumpSettings();
+#endif  // defined(USE_OPENGL) && !defined(ANDROID) &&
+        // !defined(__native_client__)
+
+    return true;
+}
+
+#ifdef USE_OPENGL
+impHandler(dumpGL)
+{
+    std::string str = graphicsManager.getGLVersion();
+    outStringNormal(event.tab, str, str);
+    return true;
+}
+#else  // USE_OPENGL
+
+impHandler0(dumpGL)
+{
+    return true;
+}
+#endif  // USE_OPENGL
+
+impHandler(dumpMods)
+{
+    std::string str = "enabled mods: " + serverConfig.getValue("mods", "");
+    outStringNormal(event.tab, str, str);
+    return true;
+}
+
+#if defined USE_OPENGL && defined DEBUG_SDLFONT
+impHandler0(testSdlFont)
+{
+    Font *font = new Font("fonts/dejavusans.ttf", 18);
+    timespec time1;
+    timespec time2;
+    NullOpenGLGraphics *nullGraphics = new NullOpenGLGraphics;
+    STD_VECTOR<std::string> data;
+    volatile int width = 0;
+
+    for (int f = 0; f < 300; f ++)
+        data.push_back("test " + toString(f) + "string");
+    nullGraphics->beginDraw();
+
+    clock_gettime(CLOCK_MONOTONIC, &time1);
+    Color color(0, 0, 0, 255);
+
+    for (int f = 0; f < 500; f ++)
+    {
+        FOR_EACH (STD_VECTOR<std::string>::const_iterator, it, data)
+        {
+            width += font->getWidth(*it);
+            font->drawString(nullGraphics, color, color, *it, 10, 10);
+        }
+        FOR_EACH (STD_VECTOR<std::string>::const_iterator, it, data)
+            font->drawString(nullGraphics, color, color, *it, 10, 10);
+
+        font->doClean();
+    }
+
+    clock_gettime(CLOCK_MONOTONIC, &time2);
+
+    delete nullGraphics;
+    delete font;
+
+    int64_t diff = (static_cast<long long int>(
+        time2.tv_sec) * 1000000000LL + static_cast<long long int>(
+        time2.tv_nsec)) / 100000 - (static_cast<long long int>(
+        time1.tv_sec) * 1000000000LL + static_cast<long long int>(
+        time1.tv_nsec)) / 100000;
+    if (debugChatTab)
+    {
+        debugChatTab->chatLog("sdlfont time: " + toString(diff),
+            ChatMsgType::BY_SERVER);
+    }
+    return true;
+}
+#endif  // defined USE_OPENGL && defined DEBUG_SDLFONT
+
+impHandler0(createItems)
+{
+    BuyDialog *const dialog = CREATEWIDGETR0(BuyDialog);
+    const ItemDB::ItemInfos &items = ItemDB::getItemInfos();
+    FOR_EACH (ItemDB::ItemInfos::const_iterator, it, items)
+    {
+        const ItemInfo *const info = (*it).second;
+        if (info == nullptr)
+            continue;
+        const int id = info->getId();
+        if (id <= 500)
+            continue;
+
+        dialog->addItem(id,
+            ItemType::Unknown,
+            ItemColor_one,
+            100,
+            0);
+    }
+    dialog->sort();
+    return true;
+}
+
+impHandler(createItem)
+{
+    int id = 0;
+    int amount = 0;
+
+    if (adminHandler == nullptr)
+        return false;
+
+    if (parse2Int(event.args, id, amount))
+        adminHandler->createItems(id, ItemColor_one, amount);
+    else
+        adminHandler->createItems(atoi(event.args.c_str()), ItemColor_one, 1);
+    return true;
+}
+
+impHandler(uploadConfig)
+{
+    // TRANSLATORS: upload config chat message
+    uploadFile(_("Uploaded config into:"),
+        config.getFileName(),
+        "?xml",
+        event.tab);
+    return true;
+}
+
+impHandler(uploadServerConfig)
+{
+    // TRANSLATORS: upload config chat message
+    uploadFile(_("Uploaded server config into:"),
+        serverConfig.getFileName(),
+        "?xml",
+        event.tab);
+    return true;
+}
+
+impHandler(uploadLog)
+{
+    // TRANSLATORS: upload log chat message
+    uploadFile(_("Uploaded log into:"),
+        settings.logFileName,
+        "?txt",
+        event.tab);
+    return true;
+}
+
+impHandler0(mercenaryFire)
+{
+    if (mercenaryHandler != nullptr)
+        mercenaryHandler->fire();
+    return true;
+}
+
+impHandler0(mercenaryToMaster)
+{
+    if (mercenaryHandler != nullptr)
+        mercenaryHandler->moveToMaster();
+    return true;
+}
+
+impHandler0(homunculusToMaster)
+{
+    if (homunculusHandler != nullptr)
+        homunculusHandler->moveToMaster();
+    return true;
+}
+
+impHandler0(homunculusFeed)
+{
+    if (homunculusHandler != nullptr)
+        homunculusHandler->feed();
+    return true;
+}
+
+impHandler(useItem)
+{
+    const int itemId = atoi(event.args.c_str());
+
+    if (itemId < SPELL_MIN_ID)
+    {
+        const Inventory *const inv = PlayerInfo::getInventory();
+        if (inv != nullptr)
+        {
+            // +++ ignoring item color for now
+            const Item *const item = inv->findItem(itemId,
+                ItemColor_one);
+            PlayerInfo::useEquipItem(item, 0, Sfx_true);
+        }
+    }
+    else if (itemId < SKILL_MIN_ID && (spellManager != nullptr))
+    {
+        spellManager->useItem(itemId);
+    }
+    else if (skillDialog != nullptr)
+    {
+        // +++ probably need get data parameter from args
+        skillDialog->useItem(itemId,
+            fromBool(config.getBoolValue("skillAutotarget"), AutoTarget),
+            0,
+            std::string());
+    }
+    return true;
+}
+
+impHandler(useItemInv)
+{
+    int param1 = 0;
+    int param2 = 0;
+    const std::string args = event.args;
+    if (parse2Int(args, param1, param2))
+    {
+        Item *const item = getItemByInvIndex(param1,
+            InventoryType::Inventory);
+        PlayerInfo::useEquipItem(item, CAST_S16(param2), Sfx_true);
+    }
+    else
+    {
+        Item *const item = getItemByInvIndex(atoi(event.args.c_str()),
+            InventoryType::Inventory);
+        PlayerInfo::useEquipItem(item, 0, Sfx_true);
+    }
+    return true;
+}
+
+impHandler(invToStorage)
+{
+    Item *item = nullptr;
+    const int amount = getAmountFromEvent(event, item,
+        InventoryType::Inventory);
+    if (item == nullptr)
+        return true;
+    if (amount != 0)
+    {
+        if (inventoryHandler != nullptr)
+        {
+            inventoryHandler->moveItem2(InventoryType::Inventory,
+                item->getInvIndex(),
+                amount,
+                InventoryType::Storage);
+        }
+    }
+    else
+    {
+        ItemAmountWindow::showWindow(ItemAmountWindowUsage::StoreAdd,
+            inventoryWindow, item);
+    }
+    return true;
+}
+
+impHandler(tradeAdd)
+{
+    Item *item = nullptr;
+    const int amount = getAmountFromEvent(event, item,
+        InventoryType::Inventory);
+    if ((item == nullptr) || PlayerInfo::isItemProtected(item->getId()))
+        return true;
+
+    if (amount != 0)
+    {
+        if (tradeWindow != nullptr)
+            tradeWindow->tradeItem(item, amount, true);
+    }
+    else
+    {
+        ItemAmountWindow::showWindow(ItemAmountWindowUsage::TradeAdd,
+            tradeWindow, item);
+    }
+    return true;
+}
+
+impHandler(storageToInv)
+{
+    Item *item = nullptr;
+    const int amount = getAmountFromEvent(event, item, InventoryType::Storage);
+    if (amount != 0)
+    {
+        if ((inventoryHandler != nullptr) && (item != nullptr))
+        {
+            inventoryHandler->moveItem2(InventoryType::Storage,
+                item->getInvIndex(),
+                amount,
+                InventoryType::Inventory);
+        }
+    }
+    else
+    {
+        ItemAmountWindow::showWindow(ItemAmountWindowUsage::StoreRemove,
+            storageWindow, item);
+    }
+    return true;
+}
+
+impHandler(protectItem)
+{
+    const int id = atoi(event.args.c_str());
+    if (id > 0)
+        PlayerInfo::protectItem(id);
+    return true;
+}
+
+impHandler(unprotectItem)
+{
+    const int id = atoi(event.args.c_str());
+    if (id > 0)
+        PlayerInfo::unprotectItem(id);
+    return true;
+}
+
+impHandler(kick)
+{
+    if ((localPlayer == nullptr) || (actorManager == nullptr))
+        return false;
+
+    Being *target = nullptr;
+    std::string args = event.args;
+    if (!args.empty())
+    {
+        if (args[0] != ':')
+        {
+            target = actorManager->findNearestByName(args);
+        }
+        else
+        {
+            target = actorManager->findBeing(fromInt(atoi(
+                args.substr(1).c_str()), BeingId));
+        }
+    }
+    if (target == nullptr)
+        target = localPlayer->getTarget();
+    if ((target != nullptr) && (adminHandler != nullptr))
+        adminHandler->kick(target->getId());
+    return true;
+}
+
+impHandler0(clearDrop)
+{
+    if (dropShortcut != nullptr)
+        dropShortcut->clear();
+    return true;
+}
+
+impHandler0(testInfo)
+{
+    if (actorManager != nullptr)
+    {
+        logger->log("actors count: %d", CAST_S32(
+            actorManager->size()));
+        return true;
+    }
+    return false;
+}
+
+impHandler(craftKey)
+{
+    const int slot = (event.action - InputAction::CRAFT_1);
+    if (slot >= 0 && slot < 9)
+    {
+        if (inventoryWindow != nullptr)
+            inventoryWindow->moveItemToCraft(slot);
+        return true;
+    }
+    return false;
+}
+
+impHandler0(resetGameModifiers)
+{
+    GameModifiers::resetModifiers();
+    return true;
+}
+
+impHandler(barToChat)
+{
+    if (chatWindow != nullptr)
+    {
+        chatWindow->addInputText(event.args);
+        return true;
+    }
+    return false;
+}
+
+impHandler(seen)
+{
+    if (actorManager == nullptr)
+        return false;
+
+    ChatTab *tab = event.tab;
+    if (tab == nullptr)
+        tab = localChatTab;
+    if (tab == nullptr)
+        return false;
+
+    if (config.getBoolValue("enableIdCollecting") == false)
+    {
+        // TRANSLATORS: last seen disabled warning
+        tab->chatLog(_("Last seen disabled. "
+            "Enable in players / collect players id and seen log."),
+            ChatMsgType::BY_SERVER);
+        return true;
+    }
+
+    const std::string name = event.args;
+    if (name.empty())
+        return false;
+
+    std::string dir = settings.usersDir;
+    dir.append(stringToHexPath(name)).append("/seen.txt");
+    if (Files::existsLocal(dir))
+    {
+        StringVect lines;
+        Files::loadTextFileLocal(dir, lines);
+        if (lines.size() < 3)
+        {
+            // TRANSLATORS: last seen error
+            tab->chatLog(_("You not saw this nick."),
+                ChatMsgType::BY_SERVER);
+            return true;
+        }
+        const std::string message = strprintf(
+            // TRANSLATORS: last seen message
+            _("Last seen for %s: %s"),
+            name.c_str(),
+            lines[2].c_str());
+        tab->chatLog(message, ChatMsgType::BY_SERVER);
+    }
+    else
+    {
+        // TRANSLATORS: last seen error
+        tab->chatLog(_("You not saw this nick."),
+            ChatMsgType::BY_SERVER);
+    }
+
+    return true;
+}
+
+impHandler(dumpMemoryUsage)
+{
+    if (event.tab != nullptr)
+        memoryManager.printAllMemory(event.tab);
+    else
+        memoryManager.printAllMemory(localChatTab);
+    return true;
+}
+
+impHandler(setEmoteType)
+{
+    const std::string &args = event.args;
+    if (args == "player" || args.empty())
+    {
+        settings.emoteType = EmoteType::Player;
+    }
+    else if (args == "pet")
+    {
+        settings.emoteType = EmoteType::Pet;
+    }
+    else if (args == "homun" || args == "homunculus")
+    {
+        settings.emoteType = EmoteType::Homunculus;
+    }
+    else if (args == "merc" || args == "mercenary")
+    {
+        settings.emoteType = EmoteType::Mercenary;
+    }
+    return true;
+}
+
+}  // namespace Actions
diff --git a/src/progs/manaplus/actions/chat.cpp b/src/progs/manaplus/actions/chat.cpp
new file mode 100644
index 000000000..307e4556e
--- /dev/null
+++ b/src/progs/manaplus/actions/chat.cpp
@@ -0,0 +1,808 @@
+/*
+ *  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 "actions/chat.h"
+
+#include "configuration.h"
+
+#include "actions/actiondef.h"
+
+#include "const/gui/chat.h"
+
+#include "being/localplayer.h"
+
+#include "gui/sdlinput.h"
+
+#include "gui/windows/chatwindow.h"
+
+#include "listeners/inputactionreplaylistener.h"
+
+#include "net/charserverhandler.h"
+#include "net/chathandler.h"
+#include "net/guildhandler.h"
+#include "net/net.h"
+#include "net/partyhandler.h"
+
+#ifdef TMWA_SUPPORT
+#include "net/tmwa/guildmanager.h"
+#endif  // TMWA_SUPPORT
+
+#include "resources/iteminfo.h"
+
+#include "resources/db/itemdb.h"
+
+#include "utils/booleanoptions.h"
+#include "utils/chatutils.h"
+#include "utils/parameters.h"
+
+#include "utils/translation/podict.h"
+
+#include "debug.h"
+
+const int DEFAULT_CHAT_WINDOW_SCROLL = 7;
+
+namespace Actions
+{
+
+static void outString(ChatTab *const tab,
+                      const std::string &str,
+                      const std::string &def)
+{
+    if (tab == nullptr)
+    {
+        if (chatHandler != nullptr)
+            chatHandler->talk(def, GENERAL_CHANNEL);
+        return;
+    }
+
+    switch (tab->getType())
+    {
+        case ChatTabType::PARTY:
+        {
+            if (partyHandler != nullptr)
+                partyHandler->chat(str);
+            break;
+        }
+        case ChatTabType::GUILD:
+        {
+            if ((guildHandler == nullptr) || (localPlayer == nullptr))
+                return;
+            const Guild *const guild = localPlayer->getGuild();
+            if (guild != nullptr)
+            {
+#ifdef TMWA_SUPPORT
+                if (guild->getServerGuild())
+                {
+                    if (Net::getNetworkType() == ServerType::TMWATHENA)
+                        return;
+                    guildHandler->chat(str);
+                }
+                else if (guildManager != nullptr)
+                {
+                    guildManager->chat(str);
+                }
+#else  // TMWA_SUPPORT
+
+                if (guild->getServerGuild())
+                    guildHandler->chat(str);
+#endif  // TMWA_SUPPORT
+            }
+            break;
+        }
+        case ChatTabType::CHANNEL:
+        case ChatTabType::GM:
+        case ChatTabType::TRADE:
+            tab->chatInput(str);
+            break;
+        default:
+        case ChatTabType::UNKNOWN:
+        case ChatTabType::INPUT:
+        case ChatTabType::WHISPER:
+        case ChatTabType::DEBUG:
+        case ChatTabType::BATTLE:
+        case ChatTabType::LANG:
+            if (chatHandler != nullptr)
+                chatHandler->talk(str, GENERAL_CHANNEL);
+            break;
+    }
+}
+
+impHandler0(toggleChat)
+{
+    return chatWindow != nullptr ? chatWindow->requestChatFocus() : false;
+}
+
+impHandler0(prevChatTab)
+{
+    if (chatWindow != nullptr)
+    {
+        chatWindow->prevTab();
+        return true;
+    }
+    return false;
+}
+
+impHandler0(nextChatTab)
+{
+    if (chatWindow != nullptr)
+    {
+        chatWindow->nextTab();
+        return true;
+    }
+    return false;
+}
+
+impHandler0(closeChatTab)
+{
+    if (chatWindow != nullptr)
+    {
+        chatWindow->closeTab();
+        return true;
+    }
+    return false;
+}
+
+impHandler0(closeAllChatTabs)
+{
+    if (chatWindow != nullptr)
+    {
+        chatWindow->removeAllWhispers();
+        chatWindow->saveState();
+        return true;
+    }
+    return false;
+}
+
+impHandler0(ignoreAllWhispers)
+{
+    if (chatWindow != nullptr)
+    {
+        chatWindow->ignoreAllWhispers();
+        chatWindow->saveState();
+        return true;
+    }
+    return false;
+}
+
+impHandler0(scrollChatUp)
+{
+    if ((chatWindow != nullptr) && chatWindow->isWindowVisible())
+    {
+        chatWindow->scroll(-DEFAULT_CHAT_WINDOW_SCROLL);
+        return true;
+    }
+    return false;
+}
+
+impHandler0(scrollChatDown)
+{
+    if ((chatWindow != nullptr) && chatWindow->isWindowVisible())
+    {
+        chatWindow->scroll(DEFAULT_CHAT_WINDOW_SCROLL);
+        return true;
+    }
+    return false;
+}
+
+static bool splitWhisper(const std::string &args,
+                         std::string &recvnick,
+                         std::string &message)
+{
+    if (args.substr(0, 1) == "\"")
+    {
+        const size_t pos = args.find('"', 1);
+        if (pos != std::string::npos)
+        {
+            recvnick = args.substr(1, pos - 1);
+            if (pos + 2 < args.length())
+                message = args.substr(pos + 2, args.length());
+        }
+    }
+    else
+    {
+        const size_t pos = args.find(' ');
+        if (pos != std::string::npos)
+        {
+            recvnick = args.substr(0, pos);
+            if (pos + 1 < args.length())
+                message = args.substr(pos + 1, args.length());
+        }
+        else
+        {
+            recvnick = std::string(args);
+            message.clear();
+        }
+    }
+
+    trim(message);
+
+    if (message.length() > 0)
+    {
+        std::string playerName = localPlayer->getName();
+        std::string tempNick = recvnick;
+
+        toLower(playerName);
+        toLower(tempNick);
+
+        if (tempNick == playerName || args.empty())
+            return false;
+
+        return true;
+    }
+    return false;
+}
+
+impHandler(msg)
+{
+    std::string recvnick;
+    std::string message;
+
+    if (splitWhisper(event.args, recvnick, message))
+    {
+        if (chatWindow == nullptr)
+            return false;
+        ChatTab *const tab = chatWindow->addChatTab(recvnick, false, true);
+        if (tab != nullptr)
+        {
+            chatWindow->saveState();
+            tab->chatInput(message);
+        }
+    }
+    else
+    {
+        if (event.tab != nullptr)
+        {
+            event.tab->chatLog(
+                // TRANSLATORS: whisper send
+                _("Cannot send empty whisper or channel message!"),
+                ChatMsgType::BY_SERVER);
+        }
+    }
+    return true;
+}
+
+impHandler(msgText)
+{
+    if (chatWindow == nullptr)
+        return false;
+
+    if (config.getBoolValue("whispertab"))
+    {
+        chatWindow->localChatInput("/q " + event.args);
+    }
+    else
+    {
+        chatWindow->addInputText(std::string("/w \"").append(
+            event.args).append("\" "));
+    }
+    return true;
+}
+
+impHandler(msg2)
+{
+    std::string recvnick;
+    std::string message;
+
+    if (chatHandler != nullptr &&
+        splitWhisper(event.args, recvnick, message))
+    {
+        chatHandler->privateMessage(recvnick, message);
+    }
+    return true;
+}
+
+impHandler(query)
+{
+    const std::string &args = event.args;
+    if (chatWindow != nullptr)
+    {
+        if (chatWindow->addChatTab(args, true, true) != nullptr)
+        {
+            chatWindow->saveState();
+            return true;
+        }
+    }
+
+    if (event.tab != nullptr)
+    {
+        // TRANSLATORS: new whisper or channel query
+        event.tab->chatLog(strprintf(_("Cannot create a whisper tab "
+            "\"%s\"! It probably already exists."),
+            args.c_str()), ChatMsgType::BY_SERVER);
+    }
+    return true;
+}
+
+impHandler0(clearChatTab)
+{
+    if (chatWindow != nullptr)
+    {
+        chatWindow->clearTab();
+        return true;
+    }
+    return false;
+}
+
+impHandler(createParty)
+{
+    if (partyHandler == nullptr)
+        return false;
+
+    if (event.args.empty())
+    {
+        // TRANSLATORS: dialog header
+        inputActionReplayListener.openDialog(_("Create party"),
+            "",
+            InputAction::CREATE_PARTY);
+    }
+    else
+    {
+        partyHandler->create(event.args);
+    }
+    return true;
+}
+
+impHandler(createGuild)
+{
+    if ((guildHandler == nullptr) ||
+        Net::getNetworkType() == ServerType::TMWATHENA)
+    {
+        return false;
+    }
+
+    if (event.args.empty())
+    {
+        // TRANSLATORS: dialog header
+        inputActionReplayListener.openDialog(_("Create guild"),
+            "",
+            InputAction::CREATE_GUILD);
+    }
+    else
+    {
+        guildHandler->create(event.args);
+    }
+    return true;
+}
+
+impHandler(party)
+{
+    if (!event.args.empty())
+    {
+        if (partyHandler != nullptr)
+            partyHandler->invite(event.args);
+    }
+    else
+    {
+        if (event.tab != nullptr)
+        {
+            // TRANSLATORS: party invite message
+            event.tab->chatLog(_("Please specify a name."),
+                ChatMsgType::BY_SERVER);
+        }
+    }
+    return true;
+}
+
+impHandler(guild)
+{
+    if ((guildHandler == nullptr) || (localPlayer == nullptr))
+        return false;
+
+    const std::string args = event.args;
+    if (!args.empty())
+    {
+        const Guild *const guild = localPlayer->getGuild();
+        if (guild != nullptr)
+        {
+#ifdef TMWA_SUPPORT
+            if (guild->getServerGuild())
+                guildHandler->invite(args);
+            else if (guildManager != nullptr)
+                GuildManager::invite(args);
+#else  // TMWA_SUPPORT
+
+            guildHandler->invite(args);
+#endif  // TMWA_SUPPORT
+        }
+    }
+    else
+    {
+        if (event.tab != nullptr)
+        {
+            // TRANSLATORS: guild invite message
+            event.tab->chatLog(_("Please specify a name."),
+                ChatMsgType::BY_SERVER);
+        }
+        else if (localChatTab != nullptr)
+        {
+            // TRANSLATORS: guild invite message
+            localChatTab->chatLog(_("Please specify a name."),
+                ChatMsgType::BY_SERVER);
+        }
+    }
+    return true;
+}
+
+impHandler(me)
+{
+    outString(event.tab, textToMe(event.args), event.args);
+    return true;
+}
+
+impHandler(toggle)
+{
+    if (event.args.empty())
+    {
+        if ((chatWindow != nullptr) && (event.tab != nullptr))
+        {
+            event.tab->chatLog(chatWindow->getReturnTogglesChat() ?
+                // TRANSLATORS: message from toggle chat command
+                _("Return toggles chat.") : _("Message closes chat."),
+                ChatMsgType::BY_SERVER);
+        }
+        return true;
+    }
+
+    switch (parseBoolean(event.args))
+    {
+        case 1:
+            if (event.tab != nullptr)
+            {
+                // TRANSLATORS: message from toggle chat command
+                event.tab->chatLog(_("Return now toggles chat."),
+                    ChatMsgType::BY_SERVER);
+            }
+            if (chatWindow != nullptr)
+                chatWindow->setReturnTogglesChat(true);
+            return true;
+        case 0:
+            if (event.tab != nullptr)
+            {
+                // TRANSLATORS: message from toggle chat command
+                event.tab->chatLog(_("Message now closes chat."),
+                    ChatMsgType::BY_SERVER);
+            }
+            if (chatWindow != nullptr)
+                chatWindow->setReturnTogglesChat(false);
+            return true;
+        case -1:
+            if (event.tab != nullptr)
+            {
+                event.tab->chatLog(strprintf(BOOLEAN_OPTIONS, "toggle"),
+                    ChatMsgType::BY_SERVER);
+            }
+            return true;
+        default:
+            return true;
+    }
+}
+
+impHandler(kickParty)
+{
+    if (!event.args.empty())
+    {
+        if (partyHandler != nullptr)
+            partyHandler->kick(event.args);
+    }
+    else
+    {
+        if (event.tab != nullptr)
+        {
+            // TRANSLATORS: party kick message
+            event.tab->chatLog(_("Please specify a name."),
+                ChatMsgType::BY_SERVER);
+        }
+    }
+    return true;
+}
+
+impHandler(kickGuild)
+{
+    if (!event.args.empty())
+    {
+        if (localPlayer != nullptr)
+        {
+            const Guild *const guild = localPlayer->getGuild();
+            if (guild != nullptr)
+            {
+                if (guild->getServerGuild())
+                {
+                    if (guildHandler != nullptr)
+                        guildHandler->kick(guild->getMember(event.args), "");
+                }
+#ifdef TMWA_SUPPORT
+                else if (guildManager != nullptr)
+                {
+                    GuildManager::kick(event.args);
+                }
+#endif  // TMWA_SUPPORT
+            }
+        }
+    }
+    else
+    {
+        if (event.tab != nullptr)
+        {
+            // TRANSLATORS: party kick message
+            event.tab->chatLog(_("Please specify a name."),
+                ChatMsgType::BY_SERVER);
+        }
+    }
+    return true;
+}
+
+impHandler(addText)
+{
+    if (chatWindow != nullptr)
+        chatWindow->addInputText(event.args);
+    return true;
+}
+
+impHandler0(clearChat)
+{
+    if (chatWindow != nullptr)
+        chatWindow->clearTab();
+    return true;
+}
+
+impHandler0(chatGeneralTab)
+{
+    if (chatWindow != nullptr)
+        chatWindow->selectTabByType(ChatTabType::INPUT);
+    return true;
+}
+
+impHandler0(chatDebugTab)
+{
+    if (chatWindow != nullptr)
+        chatWindow->selectTabByType(ChatTabType::DEBUG);
+    return true;
+}
+
+impHandler0(chatBattleTab)
+{
+    if (chatWindow != nullptr)
+        chatWindow->selectTabByType(ChatTabType::BATTLE);
+    return true;
+}
+
+impHandler0(chatTradeTab)
+{
+    if (chatWindow != nullptr)
+        chatWindow->selectTabByType(ChatTabType::TRADE);
+    return true;
+}
+
+impHandler0(chatLangTab)
+{
+    if (chatWindow != nullptr)
+        chatWindow->selectTabByType(ChatTabType::LANG);
+    return true;
+}
+
+impHandler0(chatGmTab)
+{
+    if (chatWindow != nullptr)
+        chatWindow->selectTabByType(ChatTabType::GM);
+    return true;
+}
+
+impHandler0(chatPartyTab)
+{
+    if (chatWindow != nullptr)
+        chatWindow->selectTabByType(ChatTabType::PARTY);
+    return true;
+}
+
+impHandler0(chatGuildTab)
+{
+    if (chatWindow != nullptr)
+        chatWindow->selectTabByType(ChatTabType::GUILD);
+    return true;
+}
+
+impHandler(hat)
+{
+    if ((localPlayer == nullptr) || (charServerHandler == nullptr))
+        return false;
+
+    const int sprite = localPlayer->getSpriteID(
+        charServerHandler->hatSprite());
+    std::string str;
+    if (sprite == 0)
+    {
+        // TRANSLATORS: equipped hat chat message
+        str = strprintf(_("no hat equipped."));
+    }
+    else
+    {
+        const ItemInfo &info = ItemDB::get(sprite);
+        // TRANSLATORS: equipped hat chat message
+        str = strprintf(_("equipped hat %s."),
+            info.getName().c_str());
+    }
+    outString(event.tab, str, str);
+    return true;
+}
+
+impHandler(chatClipboard)
+{
+    int x = 0;
+    int y = 0;
+
+    if ((chatWindow != nullptr) && parse2Int(event.args, x, y))
+    {
+        chatWindow->copyToClipboard(x, y);
+        return true;
+    }
+    return false;
+}
+
+impHandler(guildNotice)
+{
+    if (localPlayer == nullptr)
+        return false;
+    const std::string args = event.args;
+    if (args.empty())
+    {
+        // TRANSLATORS: dialog header
+        inputActionReplayListener.openDialog(_("Guild notice"),
+            "",
+            InputAction::GUILD_NOTICE);
+        return true;
+    }
+
+    std::string str2;
+    if (args.size() > 60)
+        str2 = args.substr(60);
+    const Guild *const guild = localPlayer->getGuild();
+    if (guild != nullptr)
+    {
+        guildHandler->changeNotice(guild->getId(),
+            args.substr(0, 60),
+            str2);
+    }
+    return true;
+}
+
+impHandler(translate)
+{
+    if (reverseDictionary == nullptr ||
+        localPlayer == nullptr ||
+        event.args.empty())
+    {
+        return false;
+    }
+
+    ChatTab *const tab = event.tab;
+    if (tab == nullptr)
+        return false;
+
+    std::string srcStr = event.args;
+    std::string enStr;
+    toLower(srcStr);
+    if (localPlayer->getLanguageId() > 0)
+    {
+        if (reverseDictionary->haveStr(srcStr))
+            enStr = reverseDictionary->getStr(srcStr);
+        else if (dictionary->haveStr(srcStr))
+            enStr = srcStr;
+    }
+    else
+    {
+        if (dictionary->haveStr(srcStr))
+            enStr = srcStr;
+    }
+
+    if (enStr.empty())
+    {
+        tab->chatLog(
+            // TRANSLATORS: translation error message
+            strprintf(_("No translation found for string: %s"),
+            srcStr.c_str()),
+            ChatMsgType::BY_SERVER);
+        return true;
+    }
+
+    tab->chatInput(enStr);
+    return true;
+}
+
+impHandler(sendGuiKey)
+{
+    if (guiInput == nullptr)
+        return false;
+
+    const std::string args = event.args;
+    if (args.empty())
+        return false;
+    StringVect pars;
+    if (!splitParameters(pars, args, " ,", '\"'))
+        return false;
+    const int sz = CAST_S32(pars.size());
+    if (sz < 1)
+        return false;
+
+    int keyValue = atoi(pars[0].c_str());
+    if (keyValue == 0 &&
+        pars[0].size() == 1)
+    {
+        keyValue = CAST_S32(pars[0][0]);
+    }
+    if (sz == 2)
+    {
+        const InputActionT actionId = inputManager.getActionByConfigField(
+            pars[1]);
+        guiInput->simulateKey(keyValue, actionId);
+    }
+    else
+    {
+        guiInput->simulateKey(keyValue, InputAction::NO_VALUE);
+    }
+    return true;
+}
+
+impHandler(sendMouseKey)
+{
+    if (guiInput == nullptr)
+        return false;
+    const std::string args = event.args;
+    if (args.empty())
+        return false;
+    StringVect pars;
+    if (!splitParameters(pars, args, " ,", '\"'))
+        return false;
+    const int sz = CAST_S32(pars.size());
+    if (sz != 3)
+        return false;
+
+    const int x = atoi(pars[0].c_str());
+    const int y = atoi(pars[1].c_str());
+    const int key1 = CAST_S32(MouseButton::LEFT);
+    const int key2 = CAST_S32(MouseButton::MIDDLE);
+    const int key = atoi(pars[2].c_str());
+    if (key < key1 || key > key2)
+        return false;
+    guiInput->simulateMouseClick(x,
+        y,
+        static_cast<MouseButtonT>(key));
+    return true;
+}
+
+impHandler(sendChars)
+{
+    if (guiInput == nullptr)
+        return false;
+
+    const std::string args = event.args;
+    if (args.empty())
+        return false;
+
+    const size_t sz = args.size();
+    for (size_t f = 0; f < sz; f ++)
+    {
+        guiInput->simulateKey(CAST_S32(args[f]),
+            InputAction::NO_VALUE);
+    }
+
+    return true;
+}
+
+}  // namespace Actions
diff --git a/src/progs/manaplus/actions/commands.cpp b/src/progs/manaplus/actions/commands.cpp
new file mode 100644
index 000000000..f2d49b13b
--- /dev/null
+++ b/src/progs/manaplus/actions/commands.cpp
@@ -0,0 +1,2156 @@
+/*
+ *  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 "actions/commands.h"
+
+#include "actormanager.h"
+#include "configuration.h"
+#include "game.h"
+#include "party.h"
+
+#include "actions/actiondef.h"
+
+#include "being/flooritem.h"
+#include "being/localplayer.h"
+#include "being/playerrelations.h"
+#include "being/homunculusinfo.h"
+#include "being/playerinfo.h"
+
+#include "const/resources/skill.h"
+
+#include "gui/viewport.h"
+
+#include "gui/popups/popupmenu.h"
+
+#include "gui/shortcut/emoteshortcut.h"
+#include "gui/shortcut/itemshortcut.h"
+
+#include "gui/windows/mailwindow.h"
+
+#include "gui/windows/chatwindow.h"
+#include "gui/windows/inventorywindow.h"
+#include "gui/windows/npcdialog.h"
+#include "gui/windows/outfitwindow.h"
+#include "gui/windows/shortcutwindow.h"
+#include "gui/windows/skilldialog.h"
+#include "gui/windows/socialwindow.h"
+
+#include "gui/widgets/tabs/chat/whispertab.h"
+
+#include "input/inputactionoperators.h"
+
+#include "listeners/inputactionreplaylistener.h"
+
+#include "net/adminhandler.h"
+#include "net/chathandler.h"
+#include "net/guildhandler.h"
+#include "net/familyhandler.h"
+#include "net/homunculushandler.h"
+#include "net/mail2handler.h"
+#include "net/mailhandler.h"
+#include "net/net.h"
+#include "net/npchandler.h"
+#include "net/partyhandler.h"
+#include "net/serverfeatures.h"
+
+#include "resources/chatobject.h"
+
+#include "resources/db/itemdb.h"
+
+#include "resources/map/map.h"
+
+#include "resources/skill/skillinfo.h"
+
+#include "utils/booleanoptions.h"
+#include "utils/chatutils.h"
+#include "utils/copynpaste.h"
+#include "utils/gmfunctions.h"
+#include "utils/parameters.h"
+#include "utils/process.h"
+
+#include "debug.h"
+
+namespace Actions
+{
+
+static std::string getNick(const InputEvent &event)
+{
+    std::string args = event.args;
+    if (args.empty())
+    {
+        if (event.tab == nullptr ||
+            event.tab->getType() != ChatTabType::WHISPER)
+        {
+            return std::string();
+        }
+
+        WhisperTab *const whisper = static_cast<WhisperTab *>(event.tab);
+        if (whisper->getNick().empty())
+        {
+            // TRANSLATORS: change relation
+            event.tab->chatLog(_("Please specify a name."),
+                ChatMsgType::BY_SERVER);
+            return std::string();
+        }
+        args = whisper->getNick();
+    }
+    return args;
+}
+
+static void reportRelation(const InputEvent &event,
+                           const RelationT &rel,
+                           const std::string &str1,
+                           const std::string &str2)
+{
+    if (event.tab != nullptr)
+    {
+        if (playerRelations.getRelation(event.args) == rel)
+        {
+            // TRANSLATORS: unignore command
+            event.tab->chatLog(str1, ChatMsgType::BY_SERVER);
+        }
+        else
+        {
+            // TRANSLATORS: unignore command
+            event.tab->chatLog(str2, ChatMsgType::BY_SERVER);
+        }
+    }
+}
+
+static void changeRelation(const InputEvent &event,
+                           const RelationT relation,
+                           const std::string &relationText)
+{
+    std::string args = getNick(event);
+    if (args.empty())
+        return;
+
+    if (playerRelations.getRelation(args) == relation)
+    {
+        if (event.tab != nullptr)
+        {
+            // TRANSLATORS: change relation
+            event.tab->chatLog(strprintf(_("Player already %s!"),
+                relationText.c_str()), ChatMsgType::BY_SERVER);
+            return;
+        }
+    }
+    else
+    {
+        playerRelations.setRelation(args, relation);
+    }
+
+    reportRelation(event,
+        relation,
+        // TRANSLATORS: change relation
+        strprintf(_("Player successfully %s!"), relationText.c_str()),
+        // TRANSLATORS: change relation
+        strprintf(_("Player could not be %s!"), relationText.c_str()));
+}
+
+impHandler(chatAnnounce)
+{
+    if (adminHandler != nullptr)
+    {
+        adminHandler->announce(event.args);
+        return true;
+    }
+    return false;
+}
+
+impHandler(chatIgnore)
+{
+    changeRelation(event, Relation::IGNORED, "ignored");
+    return true;
+}
+
+impHandler(chatUnignore)
+{
+    std::string args = getNick(event);
+    if (args.empty())
+        return false;
+
+    const RelationT rel = playerRelations.getRelation(args);
+    if (rel != Relation::NEUTRAL && rel != Relation::FRIEND)
+    {
+        playerRelations.setRelation(args, Relation::NEUTRAL);
+    }
+    else
+    {
+        if (event.tab != nullptr)
+        {
+            // TRANSLATORS: unignore command
+            event.tab->chatLog(_("Player wasn't ignored!"),
+                ChatMsgType::BY_SERVER);
+        }
+        return true;
+    }
+
+    reportRelation(event,
+        Relation::NEUTRAL,
+        // TRANSLATORS: unignore command
+        _("Player no longer ignored!"),
+        // TRANSLATORS: unignore command
+        _("Player could not be unignored!"));
+    return true;
+}
+
+impHandler(chatErase)
+{
+    std::string args = getNick(event);
+    if (args.empty())
+        return false;
+
+    if (playerRelations.getRelation(args) == Relation::ERASED)
+    {
+        if (event.tab != nullptr)
+        {
+            // TRANSLATORS: erase command
+            event.tab->chatLog(_("Player already erased!"),
+                ChatMsgType::BY_SERVER);
+        }
+        return true;
+    }
+    playerRelations.setRelation(args, Relation::ERASED);
+
+    reportRelation(event,
+        Relation::ERASED,
+        // TRANSLATORS: erase command
+        _("Player no longer erased!"),
+        // TRANSLATORS: erase command
+        _("Player could not be erased!"));
+    return true;
+}
+
+impHandler(chatFriend)
+{
+    // TRANSLATORS: adding friend command
+    changeRelation(event, Relation::FRIEND, _("friend"));
+    return true;
+}
+
+impHandler(chatDisregard)
+{
+    // TRANSLATORS: disregard command
+    changeRelation(event, Relation::DISREGARDED, _("disregarded"));
+    return true;
+}
+
+impHandler(chatNeutral)
+{
+    // TRANSLATORS: neutral command
+    changeRelation(event, Relation::NEUTRAL, _("neutral"));
+    return true;
+}
+
+impHandler(chatBlackList)
+{
+    // TRANSLATORS: blacklist command
+    changeRelation(event, Relation::BLACKLISTED, _("blacklisted"));
+    return true;
+}
+
+impHandler(chatEnemy)
+{
+    // TRANSLATORS: enemy command
+    changeRelation(event, Relation::ENEMY2, _("enemy"));
+    return true;
+}
+
+impHandler(chatNuke)
+{
+    if (actorManager == nullptr)
+        return false;
+
+    const std::string nick = getNick(event);
+    Being *const being = actorManager->findBeingByName(
+        nick, ActorType::Player);
+    if (being == nullptr)
+        return true;
+
+    actorManager->addBlock(being->getId());
+    actorManager->destroy(being);
+    return true;
+}
+
+impHandler(chatAdd)
+{
+    if (chatWindow == nullptr)
+        return false;
+
+    if (event.args.empty())
+        return true;
+
+    STD_VECTOR<int> str;
+    splitToIntVector(str, event.args, ',');
+    if (str.empty())
+        return true;
+
+    int id = str[0];
+    if (id == 0)
+        return true;
+
+    if (ItemDB::exists(id))
+    {
+        const std::string names = ItemDB::getNamesStr(str);
+        if (!names.empty())
+            chatWindow->addItemText(names);
+        return true;
+    }
+
+    const FloorItem *const floorItem = actorManager->findItem(
+        fromInt(id, BeingId));
+
+    if (floorItem != nullptr)
+    {
+        str[0] =  floorItem->getItemId();
+        const std::string names = ItemDB::getNamesStr(str);
+        chatWindow->addItemText(names);
+    }
+    return true;
+}
+
+impHandler0(present)
+{
+    if (chatWindow != nullptr)
+    {
+        chatWindow->doPresent();
+        return true;
+    }
+    return false;
+}
+
+impHandler0(printAll)
+{
+    if (actorManager != nullptr)
+    {
+        actorManager->printAllToChat();
+        return true;
+    }
+    return false;
+}
+
+impHandler(move)
+{
+    int x = 0;
+    int y = 0;
+
+    if ((localPlayer != nullptr) && parse2Int(event.args, x, y))
+    {
+        localPlayer->setDestination(x, y);
+        return true;
+    }
+    return false;
+}
+
+impHandler(setTarget)
+{
+    if ((actorManager == nullptr) || (localPlayer == nullptr))
+        return false;
+
+    Being *const target = actorManager->findNearestByName(event.args);
+    if (target != nullptr)
+        localPlayer->setTarget(target);
+    return true;
+}
+
+impHandler(commandOutfit)
+{
+    if (outfitWindow != nullptr)
+    {
+        if (!event.args.empty())
+        {
+            const std::string op = event.args.substr(0, 1);
+            if (op == "n")
+            {
+                outfitWindow->wearNextOutfit(true);
+            }
+            else if (op == "p")
+            {
+                outfitWindow->wearPreviousOutfit(true);
+            }
+            else
+            {
+                outfitWindow->wearOutfit(atoi(event.args.c_str()) - 1,
+                    false, true);
+            }
+        }
+        else
+        {
+            outfitWindow->wearOutfit(atoi(event.args.c_str()) - 1,
+                false, true);
+        }
+        return true;
+    }
+    return false;
+}
+
+impHandler(commandEmote)
+{
+    LocalPlayer::emote(CAST_U8(atoi(event.args.c_str())));
+    return true;
+}
+
+impHandler(awayMessage)
+{
+    if (localPlayer != nullptr)
+    {
+        localPlayer->setAway(event.args);
+        return true;
+    }
+    return false;
+}
+
+impHandler(pseudoAway)
+{
+    if (localPlayer != nullptr)
+    {
+        LocalPlayer::setPseudoAway(event.args);
+        localPlayer->updateStatus();
+        return true;
+    }
+    return false;
+}
+
+impHandler(follow)
+{
+    if (localPlayer == nullptr)
+        return false;
+
+    if (!features.getBoolValue("allowFollow"))
+        return false;
+
+    if (!event.args.empty())
+    {
+        localPlayer->setFollow(event.args);
+    }
+    else if (event.tab != nullptr &&
+             event.tab->getType() == ChatTabType::WHISPER)
+    {
+        localPlayer->setFollow(static_cast<WhisperTab*>(event.tab)->getNick());
+    }
+    else
+    {
+        const Being *const being = localPlayer->getTarget();
+        if (being != nullptr)
+            localPlayer->setFollow(being->getName());
+    }
+    return true;
+}
+
+impHandler(navigate)
+{
+    if ((localPlayer == nullptr) ||
+        !localPlayer->canMove())
+    {
+        return false;
+    }
+
+    int x = 0;
+    int y = 0;
+
+    if (parse2Int(event.args, x, y))
+        localPlayer->navigateTo(x, y);
+    else
+        localPlayer->navigateClean();
+    return true;
+}
+
+impHandler(navigateTo)
+{
+    if ((localPlayer == nullptr) ||
+        !localPlayer->canMove())
+    {
+        return false;
+    }
+
+    const std::string args = event.args;
+    if (args.empty())
+        return true;
+
+    Being *const being = actorManager->findBeingByName(args);
+    if (being != nullptr)
+    {
+        localPlayer->navigateTo(being->getTileX(), being->getTileY());
+    }
+    else if (localPlayer->isInParty())
+    {
+        const Party *const party = localPlayer->getParty();
+        if (party != nullptr)
+        {
+            const PartyMember *const m = party->getMember(args);
+            const PartyMember *const o = party->getMember(
+                localPlayer->getName());
+            if (m != nullptr &&
+                o != nullptr &&
+                m->getMap() == o->getMap())
+            {
+                localPlayer->navigateTo(m->getX(), m->getY());
+            }
+        }
+    }
+    return true;
+}
+
+impHandler(moveCamera)
+{
+    int x = 0;
+    int y = 0;
+
+    if (viewport == nullptr)
+        return false;
+
+    if (parse2Int(event.args, x, y))
+        viewport->moveCameraToPosition(x * mapTileSize, y * mapTileSize);
+    return true;
+}
+
+impHandler0(restoreCamera)
+{
+    if (viewport == nullptr)
+        return false;
+
+    viewport->returnCamera();
+    return true;
+}
+
+impHandler(imitation)
+{
+    if (localPlayer == nullptr)
+        return false;
+
+    if (!event.args.empty())
+    {
+        localPlayer->setImitate(event.args);
+    }
+    else if (event.tab != nullptr &&
+             event.tab->getType() == ChatTabType::WHISPER)
+    {
+        localPlayer->setImitate(static_cast<WhisperTab*>(
+            event.tab)->getNick());
+    }
+    else
+    {
+        localPlayer->setImitate("");
+    }
+    return true;
+}
+
+impHandler(sendMail)
+{
+#ifdef TMWA_SUPPORT
+    const ServerTypeT type = Net::getNetworkType();
+    if (type == ServerType::EATHENA || type == ServerType::EVOL2)
+#endif  // TMWA_SUPPORT
+    {
+        std::string name;
+        std::string text;
+
+        if (parse2Str(event.args, name, text))
+        {
+            if (settings.enableNewMailSystem)
+            {
+                mail2Handler->queueCheckName(MailQueueType::SendMail,
+                    name,
+                    // TRANSLATORS: quick mail message caption
+                    _("Quick message"),
+                    text,
+                    0);
+            }
+            else
+            {
+                // TRANSLATORS: quick mail message caption
+                mailHandler->send(name, _("Quick message"), text);
+            }
+        }
+    }
+#ifdef TMWA_SUPPORT
+    else if (serverConfig.getBoolValue("enableManaMarketBot"))
+    {
+        chatHandler->privateMessage("ManaMarket", "!mail " + event.args);
+        return true;
+    }
+#endif  // TMWA_SUPPORT
+
+    return false;
+}
+
+impHandler(info)
+{
+    if (event.tab == nullptr ||
+        localPlayer == nullptr ||
+        Net::getNetworkType() == ServerType::TMWATHENA)
+    {
+        return false;
+    }
+
+    if (guildHandler != nullptr &&
+        event.tab->getType() == ChatTabType::GUILD)
+    {
+        const Guild *const guild = localPlayer->getGuild();
+        if (guild != nullptr)
+            guildHandler->info();
+    }
+    return true;
+}
+
+impHandler(wait)
+{
+    if (localPlayer != nullptr)
+    {
+        localPlayer->waitFor(event.args);
+        return true;
+    }
+    return false;
+}
+
+impHandler(addPriorityAttack)
+{
+    if ((actorManager == nullptr) ||
+        actorManager->isInPriorityAttackList(event.args))
+    {
+        return false;
+    }
+
+    actorManager->removeAttackMob(event.args);
+    actorManager->addPriorityAttackMob(event.args);
+
+    if (socialWindow != nullptr)
+        socialWindow->updateAttackFilter();
+    return true;
+}
+
+impHandler(addAttack)
+{
+    if (actorManager == nullptr)
+        return false;
+
+    actorManager->removeAttackMob(event.args);
+    actorManager->addAttackMob(event.args);
+
+    if (socialWindow != nullptr)
+        socialWindow->updateAttackFilter();
+    return true;
+}
+
+impHandler(removeAttack)
+{
+    if (actorManager == nullptr)
+        return false;
+
+    if (event.args.empty())
+    {
+        if (actorManager->isInAttackList(event.args))
+        {
+            actorManager->removeAttackMob(event.args);
+            actorManager->addIgnoreAttackMob(event.args);
+        }
+        else
+        {
+            actorManager->removeAttackMob(event.args);
+            actorManager->addAttackMob(event.args);
+        }
+    }
+    else
+    {
+        actorManager->removeAttackMob(event.args);
+    }
+
+
+    if (socialWindow != nullptr)
+        socialWindow->updateAttackFilter();
+    return true;
+}
+
+impHandler(addIgnoreAttack)
+{
+    if (actorManager == nullptr)
+        return false;
+
+    actorManager->removeAttackMob(event.args);
+    actorManager->addIgnoreAttackMob(event.args);
+
+    if (socialWindow != nullptr)
+        socialWindow->updateAttackFilter();
+    return true;
+}
+
+impHandler(setDrop)
+{
+    GameModifiers::setQuickDropCounter(atoi(event.args.c_str()));
+    return true;
+}
+
+impHandler(url)
+{
+    if (event.tab != nullptr)
+    {
+        std::string url1 = event.args;
+        if (!strStartWith(url1, "http") && !strStartWith(url1, "?"))
+            url1 = "http://" + url1;
+        std::string str(strprintf("[@@%s |%s@@]",
+            url1.c_str(), event.args.c_str()));
+        outStringNormal(event.tab, str, str);
+        return true;
+    }
+    return false;
+}
+
+impHandler(openUrl)
+{
+    std::string url = event.args;
+    if (!strStartWith(url, "http"))
+        url = "http://" + url;
+    openBrowser(url);
+    return true;
+}
+
+impHandler(execute)
+{
+    const size_t idx = event.args.find(' ');
+    std::string name;
+    std::string params;
+    if (idx == std::string::npos)
+    {
+        name = event.args;
+    }
+    else
+    {
+        name = event.args.substr(0, idx);
+        params = event.args.substr(idx + 1);
+    }
+    execFile(name, name, params, "");
+    return true;
+}
+
+impHandler(enableHighlight)
+{
+    if (event.tab != nullptr)
+    {
+        event.tab->setAllowHighlight(true);
+        if (chatWindow != nullptr)
+        {
+            chatWindow->saveState();
+            return true;
+        }
+    }
+    return false;
+}
+
+impHandler(disableHighlight)
+{
+    if (event.tab != nullptr)
+    {
+        event.tab->setAllowHighlight(false);
+        if (chatWindow != nullptr)
+        {
+            chatWindow->saveState();
+            return true;
+        }
+    }
+    return false;
+}
+
+impHandler(dontRemoveName)
+{
+    if (event.tab != nullptr)
+    {
+        event.tab->setRemoveNames(false);
+        if (chatWindow != nullptr)
+        {
+            chatWindow->saveState();
+            return true;
+        }
+    }
+    return false;
+}
+
+impHandler(removeName)
+{
+    if (event.tab != nullptr)
+    {
+        event.tab->setRemoveNames(true);
+        if (chatWindow != nullptr)
+        {
+            chatWindow->saveState();
+            return true;
+        }
+    }
+    return false;
+}
+
+impHandler(disableAway)
+{
+    if (event.tab != nullptr)
+    {
+        event.tab->setNoAway(true);
+        if (chatWindow != nullptr)
+        {
+            chatWindow->saveState();
+            return true;
+        }
+    }
+    return false;
+}
+
+impHandler(enableAway)
+{
+    if (event.tab != nullptr)
+    {
+        event.tab->setNoAway(false);
+        if (chatWindow != nullptr)
+        {
+            chatWindow->saveState();
+            return true;
+        }
+    }
+    return false;
+}
+
+impHandler(testParticle)
+{
+    if (localPlayer != nullptr)
+    {
+        localPlayer->setTestParticle(event.args);
+        return true;
+    }
+    return false;
+}
+
+impHandler(talkRaw)
+{
+    if (chatHandler != nullptr)
+    {
+        chatHandler->talkRaw(event.args);
+        return true;
+    }
+    return false;
+}
+
+impHandler(gm)
+{
+    if (chatHandler != nullptr)
+    {
+        Gm::runCommand("wgm", event.args);
+        return true;
+    }
+    return false;
+}
+
+impHandler(hack)
+{
+    if (chatHandler != nullptr)
+    {
+        chatHandler->sendRaw(event.args);
+        return true;
+    }
+    return false;
+}
+
+impHandler(debugSpawn)
+{
+    if (localPlayer == nullptr)
+        return false;
+    int cnt = atoi(event.args.c_str());
+    if (cnt < 1)
+        cnt = 1;
+    const int half = cnt / 2;
+    const Map *const map = localPlayer->getMap();
+    int x1 = -half;
+    if (x1 < 0)
+        x1 = 0;
+    int y1 = x1;
+    int x2 = cnt - half;
+    if (x2 > map->getWidth())
+        x2 = map->getWidth();
+    int y2 = x2;
+
+    for (int x = x1; x < x2; x ++)
+    {
+        for (int y = y1; y < y2; y ++)
+            ActorManager::cloneBeing(localPlayer, x, y, cnt);
+    }
+    return true;
+}
+
+impHandler(serverIgnoreWhisper)
+{
+    std::string args = getNick(event);
+    if (args.empty())
+        return false;
+
+    if (chatHandler != nullptr)
+    {
+        chatHandler->ignore(args);
+        return true;
+    }
+    return false;
+}
+
+impHandler(serverUnIgnoreWhisper)
+{
+    std::string args = getNick(event);
+    if (args.empty())
+        return false;
+
+    if (chatHandler != nullptr)
+    {
+        chatHandler->unIgnore(args);
+        return true;
+    }
+    return false;
+}
+
+impHandler(setHomunculusName)
+{
+    const std::string args = event.args;
+    if (args.empty())
+    {
+        const HomunculusInfo *const info = PlayerInfo::getHomunculus();
+        if (info != nullptr)
+        {
+            // TRANSLATORS: dialog header
+            inputActionReplayListener.openDialog(_("Rename your homun"),
+                info->name,
+                InputAction::HOMUNCULUS_SET_NAME);
+        }
+        return false;
+    }
+
+    if (homunculusHandler != nullptr)
+    {
+        homunculusHandler->setName(args);
+        return true;
+    }
+    return false;
+}
+
+impHandler0(fireHomunculus)
+{
+    if (homunculusHandler != nullptr)
+    {
+        homunculusHandler->fire();
+        return true;
+    }
+    return false;
+}
+
+impHandler0(leaveParty)
+{
+    if (partyHandler != nullptr)
+    {
+        partyHandler->leave();
+        return true;
+    }
+    return false;
+}
+
+impHandler0(leaveGuild)
+{
+    if ((guildHandler != nullptr) && (localPlayer != nullptr))
+    {
+        const Guild *const guild = localPlayer->getGuild();
+        if (guild != nullptr)
+            guildHandler->leave(guild->getId());
+        return true;
+    }
+    return false;
+}
+
+impHandler(warp)
+{
+    int x = 0;
+    int y = 0;
+
+    if ((adminHandler != nullptr) &&
+        (Game::instance() != nullptr) &&
+        parse2Int(event.args, x, y))
+    {
+        adminHandler->warp(Game::instance()->getCurrentMapName(),
+            x, y);
+        return true;
+    }
+    return false;
+}
+
+impHandler(homunTalk)
+{
+    if ((serverFeatures == nullptr) || !serverFeatures->haveTalkPet())
+        return false;
+
+    std::string args = event.args;
+    if (findCutFirst(args, "/me "))
+        args = textToMe(args);
+    if (homunculusHandler != nullptr)
+    {
+        homunculusHandler->talk(args);
+        return true;
+    }
+    return false;
+}
+
+impHandler(homunEmote)
+{
+    if ((serverFeatures == nullptr) || !serverFeatures->haveTalkPet())
+        return false;
+
+    if ((homunculusHandler != nullptr) &&
+        event.action >= InputAction::HOMUN_EMOTE_1 &&
+        event.action <= InputAction::HOMUN_EMOTE_48)
+    {
+        const int emotion = event.action - InputAction::HOMUN_EMOTE_1;
+        if (emoteShortcut != nullptr)
+            homunculusHandler->emote(emoteShortcut->getEmote(emotion));
+        if (Game::instance() != nullptr)
+            Game::instance()->setValidSpeed();
+        return true;
+    }
+
+    return false;
+}
+
+impHandler(commandHomunEmote)
+{
+    if ((serverFeatures == nullptr) || !serverFeatures->haveTalkPet())
+        return false;
+
+    if (homunculusHandler != nullptr)
+    {
+        homunculusHandler->emote(CAST_U8(
+            atoi(event.args.c_str())));
+        return true;
+    }
+    return false;
+}
+
+impHandler(createPublicChatRoom)
+{
+    if ((chatHandler == nullptr) || event.args.empty())
+        return false;
+    chatHandler->createChatRoom(event.args, "", 100, true);
+    return true;
+}
+
+impHandler(joinChatRoom)
+{
+    if (chatHandler == nullptr)
+        return false;
+    const std::string args = event.args;
+    if (args.empty())
+        return false;
+    ChatObject *const chat = ChatObject::findByName(args);
+    if (chat == nullptr)
+        return false;
+    chatHandler->joinChat(chat, "");
+    return true;
+}
+
+impHandler0(leaveChatRoom)
+{
+    if (chatHandler != nullptr)
+    {
+        chatHandler->leaveChatRoom();
+        return true;
+    }
+    return false;
+}
+
+impHandler(confSet)
+{
+    std::string name;
+    std::string val;
+
+    if (parse2Str(event.args, name, val))
+    {
+        config.setValue(name, val);
+        return true;
+    }
+    return false;
+}
+
+impHandler(serverConfSet)
+{
+    std::string name;
+    std::string val;
+
+    if (parse2Str(event.args, name, val))
+    {
+        serverConfig.setValue(name, val);
+        return true;
+    }
+    return false;
+}
+
+impHandler(confGet)
+{
+    const std::string args = event.args;
+    if (args.empty())
+        return false;
+
+    // TRANSLATORS: result from command /confget
+    const std::string str = strprintf(_("Config value: %s"),
+        config.getStringValue(args).c_str());
+    outStringNormal(event.tab, str, str);
+    return true;
+}
+
+impHandler(serverConfGet)
+{
+    const std::string args = event.args;
+    if (args.empty())
+        return false;
+
+    // TRANSLATORS: result from command /serverconfget
+    const std::string str = strprintf(_("Server config value: %s"),
+        serverConfig.getStringValue(args).c_str());
+    outStringNormal(event.tab, str, str);
+    return true;
+}
+
+impHandler(slide)
+{
+    int x = 0;
+    int y = 0;
+
+    if ((adminHandler != nullptr) && parse2Int(event.args, x, y))
+    {
+        adminHandler->slide(x, y);
+        return true;
+    }
+    return false;
+}
+
+impHandler(selectSkillLevel)
+{
+    int skill = 0;
+    int level = 0;
+
+    if ((skillDialog != nullptr) && parse2Int(event.args, skill, level))
+    {
+        skillDialog->selectSkillLevel(skill, level);
+        return true;
+    }
+    return false;
+}
+
+impHandler(skill)
+{
+    StringVect vect;
+    splitToStringVector(vect, event.args, ' ');
+    const int sz = CAST_S32(vect.size());
+    if (sz < 1)
+        return true;
+    const int skillId = atoi(vect[0].c_str());
+    int level = 0;
+    std::string text;
+    if (sz > 1)
+    {
+        level = atoi(vect[1].c_str());
+        if (sz > 2)
+            text = vect[2];
+    }
+    // +++ add here also cast type and offsets
+    if (text.empty())
+    {
+        SkillDialog::useSkill(skillId,
+            AutoTarget_true,
+            level,
+            false,
+            "",
+            CastType::Default,
+            0,
+            0);
+    }
+    else
+    {
+        SkillDialog::useSkill(skillId,
+            AutoTarget_true,
+            level,
+            true,
+            text,
+            CastType::Default,
+            0,
+            0);
+    }
+    return true;
+}
+
+impHandler(craft)
+{
+    const std::string args = event.args;
+    if (args.empty() || (inventoryWindow == nullptr))
+        return false;
+
+    inventoryWindow->moveItemToCraft(atoi(args.c_str()));
+    return true;
+}
+
+impHandler(npcClipboard)
+{
+    if (npcHandler != nullptr)
+    {
+        int x = 0;
+        int y = 0;
+
+        NpcDialog *const dialog = npcHandler->getCurrentNpcDialog();
+
+        if ((dialog != nullptr) && parse2Int(event.args, x, y))
+        {
+            dialog->copyToClipboard(x, y);
+            return true;
+        }
+    }
+    return false;
+}
+
+impHandler(clipboardCopy)
+{
+    const std::string args = event.args;
+    if (args.empty())
+        return false;
+    sendBuffer(args);
+    return true;
+}
+
+impHandler(addPickup)
+{
+    if (actorManager != nullptr)
+    {
+        actorManager->removePickupItem(event.args);
+        actorManager->addPickupItem(event.args);
+        if (socialWindow != nullptr)
+            socialWindow->updatePickupFilter();
+        return true;
+    }
+    return false;
+}
+
+impHandler(removePickup)
+{
+    if (actorManager != nullptr)
+    {
+        if (event.args.empty())
+        {   // default pickup manipulation
+            if (actorManager->checkDefaultPickup())
+            {
+                actorManager->removePickupItem(event.args);
+                actorManager->addIgnorePickupItem(event.args);
+            }
+            else
+            {
+                actorManager->removePickupItem(event.args);
+                actorManager->addPickupItem(event.args);
+            }
+        }
+        else
+        {   // any other pickups
+            actorManager->removePickupItem(event.args);
+        }
+        if (socialWindow != nullptr)
+            socialWindow->updatePickupFilter();
+        return true;
+    }
+    return false;
+}
+
+impHandler(ignorePickup)
+{
+    if (actorManager != nullptr)
+    {
+        actorManager->removePickupItem(event.args);
+        actorManager->addIgnorePickupItem(event.args);
+        if (socialWindow != nullptr)
+            socialWindow->updatePickupFilter();
+        return true;
+    }
+    return false;
+}
+
+impHandler(monsterInfo)
+{
+    const std::string args = event.args;
+    if (args.empty())
+        return false;
+    adminHandler->monsterInfo(args);
+    return true;
+}
+
+impHandler(itemInfo)
+{
+    const std::string args = event.args;
+    if (args.empty())
+        return false;
+    adminHandler->itemInfo(args);
+    return true;
+}
+
+impHandler(whoDrops)
+{
+    const std::string args = event.args;
+    if (args.empty())
+        return false;
+    adminHandler->whoDrops(args);
+    return true;
+}
+
+impHandler(mobSearch)
+{
+    const std::string args = event.args;
+    if (args.empty())
+        return false;
+    adminHandler->mobSearch(args);
+    return true;
+}
+
+impHandler(mobSpawnSearch)
+{
+    const std::string args = event.args;
+    if (args.empty())
+        return false;
+    adminHandler->mobSpawnSearch(args);
+    return true;
+}
+
+impHandler(playerGmCommands)
+{
+    adminHandler->playerGmCommands(event.args);
+    return true;
+}
+
+impHandler(playerCharGmCommands)
+{
+    adminHandler->playerCharGmCommands(event.args);
+    return true;
+}
+
+impHandler(commandShowLevel)
+{
+    adminHandler->showLevel(event.args);
+    return true;
+}
+
+impHandler(commandShowStats)
+{
+    adminHandler->showStats(event.args);
+    return true;
+}
+
+impHandler(commandShowStorage)
+{
+    adminHandler->showStorageList(event.args);
+    return true;
+}
+
+impHandler(commandShowCart)
+{
+    adminHandler->showCartList(event.args);
+    return true;
+}
+
+impHandler(commandShowInventory)
+{
+    adminHandler->showInventoryList(event.args);
+    return true;
+}
+
+impHandler(locatePlayer)
+{
+    const std::string args = event.args;
+    if (args.empty())
+        return false;
+    adminHandler->locatePlayer(args);
+    return true;
+}
+
+impHandler(commandShowAccountInfo)
+{
+    const std::string args = event.args;
+    if (args.empty())
+        return false;
+    adminHandler->showAccountInfo(args);
+    return true;
+}
+
+impHandler(commandSpawn)
+{
+    const std::string args = event.args;
+    if (args.empty())
+        return false;
+    adminHandler->spawn(args);
+    return true;
+}
+
+impHandler(commandSpawnSlave)
+{
+    const std::string args = event.args;
+    if (args.empty())
+        return false;
+    adminHandler->spawnSlave(args);
+    return true;
+}
+
+impHandler(commandSpawnClone)
+{
+    const std::string args = event.args;
+    if (args.empty())
+        return false;
+    adminHandler->spawnClone(args);
+    return true;
+}
+
+impHandler(commandSpawnSlaveClone)
+{
+    const std::string args = event.args;
+    if (args.empty())
+        return false;
+    adminHandler->spawnSlaveClone(args);
+    return true;
+}
+
+impHandler(commandSpawnEvilClone)
+{
+    const std::string args = event.args;
+    if (args.empty())
+        return false;
+    adminHandler->spawnEvilClone(args);
+    return true;
+}
+
+impHandler(commandSavePosition)
+{
+    adminHandler->savePosition(event.args);
+    return true;
+}
+
+impHandler(commandLoadPosition)
+{
+    adminHandler->loadPosition(event.args);
+    return true;
+}
+
+impHandler(commandRandomWarp)
+{
+    adminHandler->randomWarp(event.args);
+    return true;
+}
+
+impHandler(commandGotoNpc)
+{
+    const std::string args = event.args;
+    if (args.empty())
+        return false;
+    adminHandler->gotoNpc(args);
+    return true;
+}
+
+impHandler(commandGotoPc)
+{
+    const std::string args = event.args;
+    if (args.empty())
+        return false;
+    adminHandler->gotoName(args);
+    return true;
+}
+
+impHandler(commandRecallPc)
+{
+    const std::string args = event.args;
+    if (args.empty())
+        return false;
+    adminHandler->recallName(args);
+    return true;
+}
+
+impHandler(commandIpCheck)
+{
+    const std::string args = event.args;
+    if (args.empty())
+        return false;
+    adminHandler->ipcheckName(args);
+    return true;
+}
+
+impHandler(commandKiller)
+{
+    adminHandler->killer(event.args);
+    return true;
+}
+
+impHandler(commandKillable)
+{
+    adminHandler->killable(event.args);
+    return true;
+}
+
+impHandler(commandHeal)
+{
+    adminHandler->heal(event.args);
+    return true;
+}
+
+impHandler(commandAlive)
+{
+    adminHandler->alive(event.args);
+    return true;
+}
+
+impHandler(commandDisguise)
+{
+    const std::string args = event.args;
+    if (args.empty())
+        return false;
+    adminHandler->disguise(args);
+    return true;
+}
+
+impHandler(commandImmortal)
+{
+    adminHandler->immortal(event.args);
+    return true;
+}
+
+impHandler(commandHide)
+{
+    adminHandler->hide(event.args);
+    return true;
+}
+
+impHandler(commandNuke)
+{
+    const std::string args = event.args;
+    if (args.empty())
+        return false;
+    adminHandler->nuke(args);
+    return true;
+}
+
+impHandler(commandKill)
+{
+    adminHandler->kill(event.args);
+    return true;
+}
+
+impHandler(commandJail)
+{
+    const std::string args = event.args;
+    if (args.empty())
+        return false;
+    adminHandler->jail(args);
+    return true;
+}
+
+impHandler(commandUnjail)
+{
+    const std::string args = event.args;
+    if (args.empty())
+        return false;
+    adminHandler->unjail(args);
+    return true;
+}
+
+impHandler(commandNpcMove)
+{
+    const std::string args = event.args;
+    if (args.empty())
+        return false;
+    StringVect pars;
+    if (!splitParameters(pars, args, " ,", '\"'))
+        return false;
+
+    if (pars.size() != 3)
+        return false;
+
+    adminHandler->npcMove(pars[0],
+        atoi(pars[1].c_str()),
+        atoi(pars[2].c_str()));
+    return true;
+}
+
+impHandler(commandNpcHide)
+{
+    const std::string args = event.args;
+    if (args.empty())
+        return false;
+    adminHandler->hideNpc(args);
+    return true;
+}
+
+impHandler(commandNpcShow)
+{
+    const std::string args = event.args;
+    if (args.empty())
+        return false;
+    adminHandler->showNpc(args);
+    return true;
+}
+
+impHandler(commandChangePartyLeader)
+{
+    const std::string args = event.args;
+    if (args.empty())
+        return false;
+    adminHandler->changePartyLeader(args);
+    return true;
+}
+
+impHandler(commandPartyRecall)
+{
+    const std::string args = event.args;
+    if (args.empty())
+        return false;
+    adminHandler->partyRecall(args);
+    return true;
+}
+
+impHandler(commandBreakGuild)
+{
+    adminHandler->breakGuild(event.args);
+    return true;
+}
+
+impHandler(commandGuildRecall)
+{
+    const std::string args = event.args;
+    if (args.empty())
+        return false;
+    adminHandler->guildRecall(args);
+    return true;
+}
+
+impHandler(mailTo)
+{
+    if (mailWindow == nullptr)
+        return false;
+    const std::string args = event.args;
+    if (settings.enableNewMailSystem)
+    {
+        mail2Handler->queueCheckName(MailQueueType::EditMail,
+            args,
+            std::string(),
+            std::string(),
+            0);
+    }
+    else
+    {
+        mailWindow->createMail(args);
+    }
+    return true;
+}
+
+impHandler(adoptChild)
+{
+    const std::string nick = getNick(event);
+    Being *const being = actorManager->findBeingByName(
+        nick, ActorType::Player);
+    if (being == nullptr)
+        return true;
+    familyHandler->askForChild(being);
+    return true;
+}
+
+impHandler(showSkillLevels)
+{
+    const std::string args = event.args;
+    if (args.empty())
+        return false;
+    const SkillInfo *restrict const skill = skillDialog->getSkill(
+        atoi(args.c_str()));
+    if (skill == nullptr)
+        return false;
+    popupMenu->showSkillLevelPopup(skill);
+    return true;
+}
+
+impHandler(showSkillType)
+{
+    const std::string args = event.args;
+    if (args.empty())
+        return false;
+    const SkillInfo *restrict const skill = skillDialog->getSkill(
+        atoi(args.c_str()));
+    if (skill == nullptr)
+        return false;
+    popupMenu->showSkillTypePopup(skill);
+    return true;
+}
+
+impHandler(selectSkillType)
+{
+    int skill = 0;
+    int type = 0;
+
+    if ((skillDialog != nullptr) && parse2Int(event.args, skill, type))
+    {
+        skillDialog->selectSkillCastType(skill,
+            static_cast<CastTypeT>(type));
+        return true;
+    }
+    return false;
+}
+
+impHandler(showSkillOffsetX)
+{
+    const std::string args = event.args;
+    if (args.empty())
+        return false;
+    const SkillInfo *restrict const skill = skillDialog->getSkill(
+        atoi(args.c_str()));
+    if (skill == nullptr)
+        return false;
+    popupMenu->showSkillOffsetPopup(skill, true);
+    return true;
+}
+
+impHandler(showSkillOffsetY)
+{
+    const std::string args = event.args;
+    if (args.empty())
+        return false;
+    const SkillInfo *restrict const skill = skillDialog->getSkill(
+        atoi(args.c_str()));
+    if (skill == nullptr)
+        return false;
+    popupMenu->showSkillOffsetPopup(skill, false);
+    return true;
+}
+
+impHandler(setSkillOffsetX)
+{
+    int skill = 0;
+    int offset = 0;
+
+    if ((skillDialog != nullptr) && parse2Int(event.args, skill, offset))
+    {
+        skillDialog->setSkillOffsetX(skill, offset);
+        return true;
+    }
+    return false;
+}
+
+impHandler(setSkillOffsetY)
+{
+    int skill = 0;
+    int offset = 0;
+
+    if ((skillDialog != nullptr) && parse2Int(event.args, skill, offset))
+    {
+        skillDialog->setSkillOffsetY(skill, offset);
+        return true;
+    }
+    return false;
+}
+
+impHandler(partyItemShare)
+{
+    if (localPlayer == nullptr)
+        return false;
+
+    if (localPlayer->isInParty() == false)
+        return true;
+
+    ChatTab *tab = event.tab;
+    if (tab == nullptr)
+        tab = localChatTab;
+    if (tab == nullptr)
+        return true;
+
+    const std::string args = event.args;
+    if (args.empty())
+    {
+        switch (partyHandler->getShareItems())
+        {
+            case PartyShare::YES:
+                // TRANSLATORS: chat message
+                tab->chatLog(_("Item sharing enabled."),
+                    ChatMsgType::BY_SERVER);
+                return true;
+            case PartyShare::NO:
+                // TRANSLATORS: chat message
+                tab->chatLog(_("Item sharing disabled."),
+                    ChatMsgType::BY_SERVER);
+                return true;
+            case PartyShare::NOT_POSSIBLE:
+                // TRANSLATORS: chat message
+                tab->chatLog(_("Item sharing not possible."),
+                    ChatMsgType::BY_SERVER);
+                return true;
+            case PartyShare::UNKNOWN:
+                // TRANSLATORS: chat message
+                tab->chatLog(_("Item sharing unknown."),
+                    ChatMsgType::BY_SERVER);
+                return true;
+            default:
+                break;
+        }
+    }
+
+    const signed char opt = parseBoolean(args);
+
+    switch (opt)
+    {
+        case 1:
+            partyHandler->setShareItems(
+                PartyShare::YES);
+            break;
+        case 0:
+            partyHandler->setShareItems(
+                PartyShare::NO);
+            break;
+        case -1:
+            tab->chatLog(strprintf(BOOLEAN_OPTIONS, "item"),
+                ChatMsgType::BY_SERVER);
+            break;
+        default:
+            break;
+    }
+    return true;
+}
+
+impHandler(partyExpShare)
+{
+    if (localPlayer == nullptr)
+        return false;
+
+    if (localPlayer->isInParty() == false)
+        return true;
+
+    ChatTab *tab = event.tab;
+    if (tab == nullptr)
+        tab = localChatTab;
+    if (tab == nullptr)
+        return true;
+
+    const std::string args = event.args;
+    if (args.empty())
+    {
+        switch (partyHandler->getShareExperience())
+        {
+            case PartyShare::YES:
+                // TRANSLATORS: chat message
+                tab->chatLog(_("Experience sharing enabled."),
+                    ChatMsgType::BY_SERVER);
+                return true;
+            case PartyShare::NO:
+                // TRANSLATORS: chat message
+                tab->chatLog(_("Experience sharing disabled."),
+                    ChatMsgType::BY_SERVER);
+                return true;
+            case PartyShare::NOT_POSSIBLE:
+                // TRANSLATORS: chat message
+                tab->chatLog(_("Experience sharing not possible."),
+                    ChatMsgType::BY_SERVER);
+                return true;
+            case PartyShare::UNKNOWN:
+                // TRANSLATORS: chat message
+                tab->chatLog(_("Experience sharing unknown."),
+                    ChatMsgType::BY_SERVER);
+                return true;
+            default:
+                break;
+        }
+    }
+
+    const signed char opt = parseBoolean(args);
+
+    switch (opt)
+    {
+        case 1:
+            partyHandler->setShareExperience(
+                PartyShare::YES);
+            break;
+        case 0:
+            partyHandler->setShareExperience(
+                PartyShare::NO);
+            break;
+        case -1:
+            tab->chatLog(strprintf(BOOLEAN_OPTIONS, "exp"),
+                ChatMsgType::BY_SERVER);
+            break;
+        default:
+            break;
+    }
+    return true;
+}
+
+impHandler(partyAutoItemShare)
+{
+    if (localPlayer == nullptr)
+        return false;
+
+    if (localPlayer->isInParty() == false)
+        return true;
+
+    ChatTab *tab = event.tab;
+    if (tab == nullptr)
+        tab = localChatTab;
+    if (tab == nullptr)
+        return true;
+
+    const std::string args = event.args;
+    if (args.empty())
+    {
+        switch (partyHandler->getShareAutoItems())
+        {
+            case PartyShare::YES:
+                // TRANSLATORS: chat message
+                tab->chatLog(_("Auto item sharing enabled."),
+                    ChatMsgType::BY_SERVER);
+                return true;
+            case PartyShare::NO:
+                // TRANSLATORS: chat message
+                tab->chatLog(_("Auto item sharing disabled."),
+                    ChatMsgType::BY_SERVER);
+                return true;
+            case PartyShare::NOT_POSSIBLE:
+                // TRANSLATORS: chat message
+                tab->chatLog(_("Auto item sharing not possible."),
+                    ChatMsgType::BY_SERVER);
+                return true;
+            case PartyShare::UNKNOWN:
+                // TRANSLATORS: chat message
+                tab->chatLog(_("Auto item sharing unknown."),
+                    ChatMsgType::BY_SERVER);
+                return true;
+            default:
+                break;
+        }
+    }
+
+    const signed char opt = parseBoolean(args);
+
+    switch (opt)
+    {
+        case 1:
+            partyHandler->setShareAutoItems(
+                PartyShare::YES);
+            break;
+        case 0:
+            partyHandler->setShareAutoItems(
+                PartyShare::NO);
+            break;
+        case -1:
+            tab->chatLog(strprintf(BOOLEAN_OPTIONS, "item"),
+                ChatMsgType::BY_SERVER);
+            break;
+        default:
+            break;
+    }
+    return true;
+}
+
+impHandler0(outfitToChat)
+{
+    if ((outfitWindow == nullptr) || (chatWindow == nullptr))
+        return false;
+
+    const std::string str = outfitWindow->getOutfitString();
+    if (!str.empty())
+        chatWindow->addInputText(str);
+    return true;
+}
+
+impHandler0(outfitClear)
+{
+    if (outfitWindow == nullptr)
+        return false;
+
+    outfitWindow->clearCurrentOutfit();
+    return true;
+}
+
+impHandler(moveAttackUp)
+{
+    if (actorManager == nullptr)
+        return false;
+    const std::string args = event.args;
+    const int idx = actorManager->getAttackMobIndex(args);
+    if (idx > 0)
+    {
+        std::list<std::string> mobs
+            = actorManager->getAttackMobs();
+        std::list<std::string>::iterator it = mobs.begin();
+        std::list<std::string>::iterator it2 = it;
+        while (it != mobs.end())
+        {
+            if (*it == args)
+            {
+                -- it2;
+                mobs.splice(it2, mobs, it);
+                actorManager->setAttackMobs(mobs);
+                actorManager->rebuildAttackMobs();
+                break;
+            }
+            ++ it;
+            ++ it2;
+        }
+
+        if (socialWindow != nullptr)
+            socialWindow->updateAttackFilter();
+        return true;
+    }
+    return false;
+}
+
+impHandler(moveAttackDown)
+{
+    if (actorManager == nullptr)
+        return false;
+    const std::string args = event.args;
+    const int idx = actorManager->getAttackMobIndex(args);
+    const int size = actorManager->getAttackMobsSize();
+    if (idx + 1 < size)
+    {
+        std::list<std::string> mobs
+            = actorManager->getAttackMobs();
+        std::list<std::string>::iterator it = mobs.begin();
+        std::list<std::string>::iterator it2 = it;
+        while (it != mobs.end())
+        {
+            if (*it == args)
+            {
+                ++ it2;
+                if (it2 == mobs.end())
+                    break;
+
+                mobs.splice(it, mobs, it2);
+                actorManager->setAttackMobs(mobs);
+                actorManager->rebuildAttackMobs();
+                break;
+            }
+            ++ it;
+            ++ it2;
+        }
+
+        if (socialWindow != nullptr)
+            socialWindow->updateAttackFilter();
+        return true;
+    }
+    return false;
+}
+
+impHandler(movePriorityAttackUp)
+{
+    if (actorManager == nullptr)
+        return false;
+    const std::string args = event.args;
+    const int idx = actorManager->
+        getPriorityAttackMobIndex(args);
+    if (idx > 0)
+    {
+        std::list<std::string> mobs
+            = actorManager->getPriorityAttackMobs();
+        std::list<std::string>::iterator it = mobs.begin();
+        std::list<std::string>::iterator it2 = it;
+        while (it != mobs.end())
+        {
+            if (*it == args)
+            {
+                -- it2;
+                mobs.splice(it2, mobs, it);
+                actorManager->setPriorityAttackMobs(mobs);
+                actorManager->rebuildPriorityAttackMobs();
+                break;
+            }
+            ++ it;
+            ++ it2;
+        }
+
+        if (socialWindow != nullptr)
+            socialWindow->updateAttackFilter();
+        return true;
+    }
+    return false;
+}
+
+impHandler(movePriorityAttackDown)
+{
+    if (actorManager == nullptr)
+        return false;
+    const std::string args = event.args;
+    const int idx = actorManager
+        ->getPriorityAttackMobIndex(args);
+    const int size = actorManager->getPriorityAttackMobsSize();
+    if (idx + 1 < size)
+    {
+        std::list<std::string> mobs
+            = actorManager->getPriorityAttackMobs();
+        std::list<std::string>::iterator it = mobs.begin();
+        std::list<std::string>::iterator it2 = it;
+        while (it != mobs.end())
+        {
+            if (*it == args)
+            {
+                ++ it2;
+                if (it2 == mobs.end())
+                    break;
+
+                mobs.splice(it, mobs, it2);
+                actorManager->setPriorityAttackMobs(mobs);
+                actorManager->rebuildPriorityAttackMobs();
+                break;
+            }
+            ++ it;
+            ++ it2;
+        }
+
+        if (socialWindow != nullptr)
+            socialWindow->updateAttackFilter();
+        return true;
+    }
+    return false;
+}
+
+impHandler(addSkillShortcut)
+{
+    const std::string args = event.args;
+    if (args.empty() ||
+        itemShortcutWindow == nullptr)
+    {
+        return false;
+    }
+    const SkillInfo *restrict const skill = skillDialog->getSkill(
+        atoi(args.c_str()));
+    if (skill == nullptr)
+        return false;
+
+    const int num = itemShortcutWindow->getTabIndex();
+    if (num < 0 ||
+        num >= CAST_S32(SHORTCUT_TABS) ||
+        num == CAST_S32(SHORTCUT_AUTO_TAB))
+    {
+        return false;
+    }
+
+    ItemShortcut *const selShortcut = itemShortcut[num];
+    const size_t index = selShortcut->getFreeIndex();
+    if (index == SHORTCUT_ITEMS)
+        return true;
+
+    selShortcut->setItem(index,
+        skill->id + SKILL_MIN_ID,
+        fromInt(skill->customSelectedLevel, ItemColor));
+    selShortcut->setItemData(index,
+        skill->toDataStr());
+
+//    popupMenu->showSkillLevelPopup(skill);
+    return true;
+}
+
+}  // namespace Actions
diff --git a/src/progs/manaplus/actions/move.cpp b/src/progs/manaplus/actions/move.cpp
new file mode 100644
index 000000000..d2be4de7e
--- /dev/null
+++ b/src/progs/manaplus/actions/move.cpp
@@ -0,0 +1,280 @@
+/*
+ *  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 "actions/move.h"
+
+#include "game.h"
+
+#include "actions/actiondef.h"
+#include "actions/pets.h"
+
+#include "being/crazymoves.h"
+#include "being/localplayer.h"
+
+#include "enums/being/beingdirection.h"
+
+#include "gui/windows/socialwindow.h"
+#include "gui/windows/npcdialog.h"
+#include "gui/windows/outfitwindow.h"
+
+#include "gui/popups/popupmenu.h"
+
+#include "input/inputactionoperators.h"
+
+#include "net/playerhandler.h"
+
+#include "debug.h"
+
+namespace Actions
+{
+
+static bool closeMoveNpcDialog(bool focus)
+{
+    NpcDialog *const dialog = NpcDialog::getActive();
+    if (dialog != nullptr)
+    {
+        if (dialog->isCloseState() != 0)
+        {
+            dialog->closeDialog();
+            return true;
+        }
+        else if (focus)
+        {
+            dialog->refocus();
+        }
+    }
+    return false;
+}
+
+impHandler(moveUp)
+{
+    if (inputManager.isActionActive(InputAction::EMOTE))
+        return directUp(event);
+    else if (inputManager.isActionActive(InputAction::PET_EMOTE))
+        return petDirectUp(event);
+    else if (inputManager.isActionActive(InputAction::STOP_ATTACK))
+        return petMoveUp(event);
+    else if (!localPlayer->canMove())
+        return directUp(event);
+    if (popupMenu->isPopupVisible())
+    {
+        popupMenu->moveUp();
+        return true;
+    }
+    return closeMoveNpcDialog(false);
+}
+
+impHandler(moveDown)
+{
+    if (inputManager.isActionActive(InputAction::EMOTE))
+        return directDown(event);
+    else if (inputManager.isActionActive(InputAction::PET_EMOTE))
+        return petDirectDown(event);
+    else if (inputManager.isActionActive(InputAction::STOP_ATTACK))
+        return petMoveDown(event);
+    else if (!localPlayer->canMove())
+        return directDown(event);
+    if (popupMenu->isPopupVisible())
+    {
+        popupMenu->moveDown();
+        return true;
+    }
+    return closeMoveNpcDialog(false);
+}
+
+impHandler(moveLeft)
+{
+    if (outfitWindow != nullptr &&
+        inputManager.isActionActive(InputAction::WEAR_OUTFIT))
+    {
+        outfitWindow->wearPreviousOutfit();
+        if (Game::instance() != nullptr)
+            Game::instance()->setValidSpeed();
+        return true;
+    }
+    if (inputManager.isActionActive(InputAction::EMOTE))
+        return directLeft(event);
+    else if (inputManager.isActionActive(InputAction::PET_EMOTE))
+        return petDirectLeft(event);
+    else if (inputManager.isActionActive(InputAction::STOP_ATTACK))
+        return petMoveLeft(event);
+    else if (!localPlayer->canMove())
+        return directLeft(event);
+    return closeMoveNpcDialog(false);
+}
+
+impHandler(moveRight)
+{
+    if (outfitWindow != nullptr &&
+        inputManager.isActionActive(InputAction::WEAR_OUTFIT))
+    {
+        outfitWindow->wearNextOutfit();
+        if (Game::instance() != nullptr)
+            Game::instance()->setValidSpeed();
+        return true;
+    }
+    if (inputManager.isActionActive(InputAction::EMOTE))
+        return directRight(event);
+    else if (inputManager.isActionActive(InputAction::PET_EMOTE))
+        return petDirectRight(event);
+    else if (inputManager.isActionActive(InputAction::STOP_ATTACK))
+        return petMoveRight(event);
+    else if (!localPlayer->canMove())
+        return directRight(event);
+    return closeMoveNpcDialog(false);
+}
+
+impHandler(moveForward)
+{
+    if (inputManager.isActionActive(InputAction::EMOTE))
+        return directRight(event);
+    return closeMoveNpcDialog(false);
+}
+
+impHandler(moveToPoint)
+{
+    const int num = event.action - InputAction::MOVE_TO_POINT_1;
+    if ((socialWindow != nullptr) && num >= 0)
+    {
+        socialWindow->selectPortal(num);
+        return true;
+    }
+
+    return false;
+}
+
+impHandler0(crazyMoves)
+{
+    if (localPlayer != nullptr)
+    {
+        ::crazyMoves->crazyMove();
+        return true;
+    }
+    return false;
+}
+
+impHandler0(moveToTarget)
+{
+    if (localPlayer != nullptr &&
+        !inputManager.isActionActive(InputAction::TARGET_ATTACK) &&
+        !inputManager.isActionActive(InputAction::ATTACK))
+    {
+        localPlayer->moveToTarget();
+        return true;
+    }
+    return false;
+}
+
+impHandler0(moveToHome)
+{
+    if (localPlayer != nullptr &&
+        !inputManager.isActionActive(InputAction::TARGET_ATTACK) &&
+        !inputManager.isActionActive(InputAction::ATTACK))
+    {
+        localPlayer->moveToHome();
+        if (Game::instance() != nullptr)
+            Game::instance()->setValidSpeed();
+        return true;
+    }
+    return false;
+}
+
+impHandler0(directUp)
+{
+    if (localPlayer != nullptr)
+    {
+        if (localPlayer->getDirection() != BeingDirection::UP)
+        {
+//            if (PacketLimiter::limitPackets(PacketType::PACKET_DIRECTION))
+            {
+                localPlayer->setDirection(BeingDirection::UP);
+                if (playerHandler != nullptr)
+                    playerHandler->setDirection(BeingDirection::UP);
+            }
+        }
+        return true;
+    }
+    return false;
+}
+
+impHandler0(directDown)
+{
+    if (localPlayer != nullptr)
+    {
+        if (localPlayer->getDirection() != BeingDirection::DOWN)
+        {
+//            if (PacketLimiter::limitPackets(PacketType::PACKET_DIRECTION))
+            {
+                localPlayer->setDirection(BeingDirection::DOWN);
+                if (playerHandler != nullptr)
+                {
+                    playerHandler->setDirection(
+                        BeingDirection::DOWN);
+                }
+            }
+        }
+        return true;
+    }
+    return false;
+}
+
+impHandler0(directLeft)
+{
+    if (localPlayer != nullptr)
+    {
+        if (localPlayer->getDirection() != BeingDirection::LEFT)
+        {
+//            if (PacketLimiter::limitPackets(PacketType::PACKET_DIRECTION))
+            {
+                localPlayer->setDirection(BeingDirection::LEFT);
+                if (playerHandler != nullptr)
+                {
+                    playerHandler->setDirection(
+                        BeingDirection::LEFT);
+                }
+            }
+        }
+        return true;
+    }
+    return false;
+}
+
+impHandler0(directRight)
+{
+    if (localPlayer != nullptr)
+    {
+        if (localPlayer->getDirection() != BeingDirection::RIGHT)
+        {
+//            if (PacketLimiter::limitPackets(PacketType::PACKET_DIRECTION))
+            {
+                localPlayer->setDirection(BeingDirection::RIGHT);
+                if (playerHandler != nullptr)
+                {
+                    playerHandler->setDirection(
+                        BeingDirection::RIGHT);
+                }
+            }
+        }
+        return true;
+    }
+    return false;
+}
+
+}  // namespace Actions
diff --git a/src/progs/manaplus/actions/pets.cpp b/src/progs/manaplus/actions/pets.cpp
new file mode 100644
index 000000000..25c5f1411
--- /dev/null
+++ b/src/progs/manaplus/actions/pets.cpp
@@ -0,0 +1,248 @@
+/*
+ *  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 "actions/pets.h"
+
+#include "actormanager.h"
+#include "game.h"
+
+#include "actions/actiondef.h"
+
+#include "being/localplayer.h"
+#include "being/playerinfo.h"
+
+#include "enums/being/beingdirection.h"
+
+#include "const/gui/chat.h"
+
+#include "input/inputactionoperators.h"
+
+#include "listeners/inputactionreplaylistener.h"
+
+#include "gui/shortcut/emoteshortcut.h"
+
+#include "net/chathandler.h"
+#include "net/pethandler.h"
+#include "net/serverfeatures.h"
+
+#include "utils/chatutils.h"
+#include "utils/gettext.h"
+#include "utils/stringutils.h"
+
+#include "debug.h"
+
+namespace Actions
+{
+
+static const Being *getPet()
+{
+    const BeingId id = PlayerInfo::getPetBeingId();
+    if (id == BeingId_zero)
+        return nullptr;
+    return actorManager->findBeing(id);
+}
+
+impHandler(commandEmotePet)
+{
+    petHandler->emote(CAST_U8(atoi(event.args.c_str())));
+    return true;
+}
+
+impHandler(talkPet)
+{
+    if (!serverFeatures->haveTalkPet())
+        return false;
+
+    std::string args = event.args;
+    if (findCutFirst(args, "/me "))
+        args = textToMe(args);
+    chatHandler->talkPet(args, GENERAL_CHANNEL);
+    return true;
+}
+
+impHandler(setPetName)
+{
+    const std::string args = event.args;
+    if (args.empty())
+    {
+        const Being *const pet = getPet();
+        if (pet == nullptr)
+            return false;
+        // TRANSLATORS: dialog header
+        inputActionReplayListener.openDialog(_("Rename your pet"),
+            pet->getName(),
+            InputAction::PET_SET_NAME);
+        return false;
+    }
+
+    petHandler->setName(args);
+    return true;
+}
+
+impHandler(petEmote)
+{
+    if (!serverFeatures->haveTalkPet())
+        return false;
+
+    if (event.action >= InputAction::PET_EMOTE_1
+        && event.action <= InputAction::PET_EMOTE_48)
+    {
+        const int emotion = event.action - InputAction::PET_EMOTE_1;
+        if (emoteShortcut != nullptr)
+            petHandler->emote(emoteShortcut->getEmote(emotion));
+        if (Game::instance() != nullptr)
+            Game::instance()->setValidSpeed();
+        return true;
+    }
+
+    return false;
+}
+
+impHandler(catchPet)
+{
+    if ((localPlayer == nullptr) || (actorManager == nullptr))
+        return false;
+
+    Being *target = nullptr;
+    const std::string args = event.args;
+    if (!args.empty())
+    {
+        if (args[0] == ':')
+        {
+            target = actorManager->findBeing(fromInt(atoi(
+                args.substr(1).c_str()), BeingId));
+        }
+        else
+        {
+            target = actorManager->findNearestByName(args);
+        }
+    }
+
+    if (target == nullptr)
+        target = localPlayer->getTarget();
+    else
+        localPlayer->setTarget(target);
+    if (target != nullptr)
+        petHandler->catchPet(target);
+    return true;
+}
+
+impHandler0(petMoveUp)
+{
+    const Being *const pet = getPet();
+    if (pet == nullptr)
+        return false;
+    petHandler->move(pet->getTileX(), pet->getTileY() - 1);
+    return true;
+}
+
+impHandler0(petMoveDown)
+{
+    const Being *const pet = getPet();
+    if (pet == nullptr)
+        return false;
+    petHandler->move(pet->getTileX(), pet->getTileY() + 1);
+    return true;
+}
+
+impHandler0(petMoveLeft)
+{
+    const Being *const pet = getPet();
+    if (pet == nullptr)
+        return false;
+    petHandler->move(pet->getTileX() - 1, pet->getTileY());
+    return true;
+}
+
+impHandler0(petMoveRight)
+{
+    const Being *const pet = getPet();
+    if (pet == nullptr)
+        return false;
+    petHandler->move(pet->getTileX() + 1, pet->getTileY());
+    return true;
+}
+
+impHandler0(petDirectUp)
+{
+    petHandler->setDirection(BeingDirection::UP);
+    return true;
+}
+
+impHandler0(petDirectDown)
+{
+    petHandler->setDirection(BeingDirection::DOWN);
+    return true;
+}
+
+impHandler0(petDirectLeft)
+{
+    petHandler->setDirection(BeingDirection::LEFT);
+    return true;
+}
+
+impHandler0(petDirectRight)
+{
+    petHandler->setDirection(BeingDirection::RIGHT);
+    return true;
+}
+
+impHandler(petMove)
+{
+    int x = 0;
+    int y = 0;
+
+    if (parse2Int(event.args, x, y))
+    {
+        petHandler->move(x, y);
+        return true;
+    }
+    return false;
+}
+
+impHandler0(petFeed)
+{
+    if (petHandler != nullptr)
+        petHandler->feed();
+    return true;
+}
+
+impHandler0(petDropLoot)
+{
+    if (petHandler != nullptr)
+        petHandler->dropLoot();
+    return true;
+}
+
+impHandler0(petReturnToEgg)
+{
+    if (petHandler != nullptr)
+        petHandler->returnToEgg();
+    return true;
+}
+
+impHandler0(petUnequip)
+{
+    if (petHandler != nullptr)
+        petHandler->unequip();
+    return true;
+}
+
+}  // namespace Actions
diff --git a/src/progs/manaplus/actions/statusbar.cpp b/src/progs/manaplus/actions/statusbar.cpp
new file mode 100644
index 000000000..0d5ba68cd
--- /dev/null
+++ b/src/progs/manaplus/actions/statusbar.cpp
@@ -0,0 +1,200 @@
+/*
+ *  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 "actions/statusbar.h"
+
+#include "game.h"
+#include "soundmanager.h"
+
+#include "actions/actiondef.h"
+
+#include "being/localplayer.h"
+#include "being/playerrelation.h"
+#include "being/playerrelations.h"
+
+#include "gui/viewport.h"
+
+#include "gui/widgets/tabs/chat/chattab.h"
+
+#include "listeners/updatestatuslistener.h"
+
+#include "resources/map/map.h"
+
+#include "utils/gettext.h"
+
+PRAGMA48(GCC diagnostic push)
+PRAGMA48(GCC diagnostic ignored "-Wshadow")
+#ifdef ANDROID
+#ifndef USE_SDL2
+#include <SDL_screenkeyboard.h>
+#endif  // USE_SDL2
+#endif  // ANDROID
+PRAGMA48(GCC diagnostic pop)
+
+#include "debug.h"
+
+namespace Actions
+{
+
+impHandler0(switchQuickDrop)
+{
+    callYellowBarCond(changeQuickDropCounter)
+}
+
+impHandler0(changeCrazyMove)
+{
+    callYellowBar(changeCrazyMoveType);
+}
+
+impHandler0(changePickupType)
+{
+    callYellowBar(changePickUpType);
+}
+
+impHandler0(changeMoveType)
+{
+    callYellowBar(changeMoveType);
+}
+
+impHandler0(changeAttackWeaponType)
+{
+    callYellowBar(changeAttackWeaponType);
+}
+
+impHandler0(changeAttackType)
+{
+    callYellowBar(changeAttackType);
+}
+
+impHandler0(changeTargetingType)
+{
+    callYellowBar(changeTargetingType);
+}
+
+impHandler0(changeFollowMode)
+{
+    callYellowBar(changeFollowMode);
+}
+
+impHandler0(changeImitationMode)
+{
+    callYellowBar(changeImitationMode);
+}
+
+impHandler0(changeMagicAttackType)
+{
+    callYellowBar(changeMagicAttackType);
+}
+
+impHandler0(changePvpMode)
+{
+    callYellowBar(changePvpAttackType);
+}
+
+impHandler0(changeMoveToTarget)
+{
+    callYellowBar(changeMoveToTargetType);
+}
+
+impHandler0(changeGameModifier)
+{
+    if (localPlayer != nullptr)
+    {
+        GameModifiers::changeGameModifiers(false);
+        return true;
+    }
+    return false;
+}
+
+impHandler0(changeAudio)
+{
+    soundManager.changeAudio();
+    if (localPlayer != nullptr)
+        localPlayer->updateMusic();
+    return true;
+}
+
+impHandler0(away)
+{
+    GameModifiers::changeAwayMode(true);
+    if (localPlayer != nullptr)
+    {
+        localPlayer->updateStatus();
+        if (Game::instance() != nullptr)
+            Game::instance()->setValidSpeed();
+        return true;
+    }
+    return false;
+}
+
+impHandler0(camera)
+{
+    if (viewport != nullptr)
+    {
+        viewport->toggleCameraMode();
+        if (Game::instance() != nullptr)
+            Game::instance()->setValidSpeed();
+        return true;
+    }
+    return false;
+}
+
+impHandler0(changeMapMode)
+{
+    if (viewport != nullptr)
+        viewport->toggleMapDrawType();
+    UpdateStatusListener::distributeEvent();
+    if (Game::instance() != nullptr)
+    {
+        if (Map *const map = Game::instance()->getCurrentMap())
+            map->redrawMap();
+    }
+    return true;
+}
+
+impHandler0(changeTrade)
+{
+    unsigned int deflt = playerRelations.getDefault();
+    if ((deflt & PlayerRelation::TRADE) != 0u)
+    {
+        if (localChatTab != nullptr)
+        {
+            // TRANSLATORS: disable trades message
+            localChatTab->chatLog(_("Ignoring incoming trade requests"),
+                ChatMsgType::BY_SERVER);
+        }
+        deflt &= ~PlayerRelation::TRADE;
+    }
+    else
+    {
+        if (localChatTab != nullptr)
+        {
+            // TRANSLATORS: enable trades message
+            localChatTab->chatLog(_("Accepting incoming trade requests"),
+                ChatMsgType::BY_SERVER);
+        }
+        deflt |= PlayerRelation::TRADE;
+    }
+
+    playerRelations.setDefault(deflt);
+    return true;
+}
+
+}  // namespace Actions
diff --git a/src/progs/manaplus/actions/tabs.cpp b/src/progs/manaplus/actions/tabs.cpp
new file mode 100644
index 000000000..99d964b40
--- /dev/null
+++ b/src/progs/manaplus/actions/tabs.cpp
@@ -0,0 +1,106 @@
+/*
+ *  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 "actions/tabs.h"
+
+#include "actions/actiondef.h"
+
+#include "gui/windows/inventorywindow.h"
+#include "gui/windows/socialwindow.h"
+#include "gui/windows/shortcutwindow.h"
+
+#include "debug.h"
+
+namespace Actions
+{
+
+impHandler0(prevSocialTab)
+{
+    if (socialWindow != nullptr)
+    {
+        socialWindow->prevTab();
+        return true;
+    }
+    return false;
+}
+
+impHandler0(nextSocialTab)
+{
+    if (socialWindow != nullptr)
+    {
+        socialWindow->nextTab();
+        return true;
+    }
+    return false;
+}
+
+impHandler0(nextShortcutsTab)
+{
+    if (itemShortcutWindow != nullptr)
+    {
+        itemShortcutWindow->nextTab();
+        return true;
+    }
+    return false;
+}
+
+impHandler0(prevShortcutsTab)
+{
+    if (itemShortcutWindow != nullptr)
+    {
+        itemShortcutWindow->prevTab();
+        return true;
+    }
+    return false;
+}
+
+impHandler0(nextCommandsTab)
+{
+    if (spellShortcutWindow != nullptr)
+    {
+        spellShortcutWindow->nextTab();
+        return true;
+    }
+    return false;
+}
+
+impHandler0(prevCommandsTab)
+{
+    if (spellShortcutWindow != nullptr)
+    {
+        spellShortcutWindow->prevTab();
+        return true;
+    }
+    return false;
+}
+
+impHandler0(nextInvTab)
+{
+    InventoryWindow::nextTab();
+    return true;
+}
+
+impHandler0(prevInvTab)
+{
+    InventoryWindow::prevTab();
+    return true;
+}
+
+}  // namespace Actions
diff --git a/src/progs/manaplus/actions/target.cpp b/src/progs/manaplus/actions/target.cpp
new file mode 100644
index 000000000..a72cbe502
--- /dev/null
+++ b/src/progs/manaplus/actions/target.cpp
@@ -0,0 +1,90 @@
+/*
+ *  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 "actions/target.h"
+
+#include "actions/actiondef.h"
+
+#include "being/localplayer.h"
+
+#include "gui/popups/popupmenu.h"
+
+#include "debug.h"
+
+namespace Actions
+{
+
+static bool setTarget(const ActorTypeT type, const AllowSort allowSort)
+{
+    if (localPlayer != nullptr)
+        return localPlayer->setNewTarget(type, allowSort) != nullptr;
+    return false;
+}
+
+impHandler0(targetPlayer)
+{
+    return setTarget(ActorType::Player, AllowSort_true);
+}
+
+impHandler0(targetMonster)
+{
+    return setTarget(ActorType::Monster, AllowSort_true);
+}
+
+impHandler0(targetClosestMonster)
+{
+    return setTarget(ActorType::Monster, AllowSort_false);
+}
+
+impHandler0(targetNPC)
+{
+    return setTarget(ActorType::Npc, AllowSort_true);
+}
+
+impHandler0(targetMercenary)
+{
+    return setTarget(ActorType::Mercenary, AllowSort_true);
+}
+
+impHandler0(targetSkillUnit)
+{
+    return setTarget(ActorType::SkillUnit, AllowSort_true);
+}
+
+impHandler0(targetPet)
+{
+    return setTarget(ActorType::Pet, AllowSort_true);
+}
+
+impHandler0(contextMenu)
+{
+    if (localPlayer == nullptr)
+        return false;
+    const Being *const target = localPlayer->getTarget();
+    if (target == nullptr)
+        return true;
+
+    popupMenu->showPopup(target->getPixelX(),
+        target->getPixelY(),
+        target);
+    return true;
+}
+
+}  // namespace Actions
diff --git a/src/progs/manaplus/actions/windows.cpp b/src/progs/manaplus/actions/windows.cpp
new file mode 100644
index 000000000..7c9b57d0a
--- /dev/null
+++ b/src/progs/manaplus/actions/windows.cpp
@@ -0,0 +1,383 @@
+/*
+ *  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 "actions/windows.h"
+
+#include "actormanager.h"
+#include "client.h"
+
+#include "actions/actiondef.h"
+
+#include "being/localplayer.h"
+
+#include "gui/dialogsmanager.h"
+
+#include "gui/windows/bankwindow.h"
+#include "gui/windows/skilldialog.h"
+#include "gui/windows/socialwindow.h"
+#include "gui/windows/statuswindow.h"
+#include "gui/windows/questswindow.h"
+#include "gui/windows/whoisonline.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/mailwindow.h"
+#include "gui/windows/minimap.h"
+#include "gui/windows/outfitwindow.h"
+#include "gui/windows/setupwindow.h"
+#include "gui/windows/serverinfowindow.h"
+#include "gui/windows/shopwindow.h"
+#include "gui/windows/shortcutwindow.h"
+#include "gui/windows/updaterwindow.h"
+
+#include "gui/widgets/createwidget.h"
+
+#include "gui/widgets/tabs/chat/chattab.h"
+
+#include "utils/gettext.h"
+
+#include "net/net.h"
+
+#include "debug.h"
+
+namespace Actions
+{
+
+impHandler0(setupWindowShow)
+{
+    if (setupWindow != nullptr)
+    {
+        if (setupWindow->isWindowVisible())
+        {
+            setupWindow->doCancel();
+        }
+        else
+        {
+            setupWindow->setVisible(Visible_true);
+            setupWindow->requestMoveToTop();
+        }
+        return true;
+    }
+    return false;
+}
+
+impHandler0(hideWindows)
+{
+    if (setupWindow != nullptr)
+        setupWindow->hideWindows();
+    return true;
+}
+
+static bool showHelpPage(const std::string &page, const bool showHide)
+{
+    if (helpWindow != nullptr)
+    {
+        if (showHide && helpWindow->isWindowVisible())
+        {
+            helpWindow->setVisible(Visible_false);
+        }
+        else
+        {
+            helpWindow->loadHelp(page);
+            helpWindow->requestMoveToTop();
+        }
+        return true;
+    }
+    return false;
+}
+
+impHandler(helpWindowShow)
+{
+    if ((chatWindow == nullptr) || !chatWindow->isInputFocused())
+        return showHelpPage("index", true);
+    if (event.tab == nullptr)
+        return showHelpPage("chatcommands", true);
+    switch (event.tab->getType())
+    {
+        case ChatTabType::PARTY:
+            return showHelpPage("chatparty", true);
+        case ChatTabType::GUILD:
+            return showHelpPage("chatguild", true);
+        case ChatTabType::WHISPER:
+            return showHelpPage("chatwhisper", true);
+        case ChatTabType::DEBUG:
+            return showHelpPage("chatdebug", true);
+        case ChatTabType::TRADE:
+            return showHelpPage("chattrade", true);
+        case ChatTabType::BATTLE:
+            return showHelpPage("chatbattle", true);
+        case ChatTabType::LANG:
+            return showHelpPage("chatlang", true);
+        case ChatTabType::GM:
+            return showHelpPage("chatgm", true);
+        case ChatTabType::CHANNEL:
+            return showHelpPage("chatchannel", true);
+        default:
+        case ChatTabType::UNKNOWN:
+        case ChatTabType::INPUT:
+            return showHelpPage("chatcommands", true);
+    }
+}
+
+impHandler0(aboutWindowShow)
+{
+    return showHelpPage("about", false);
+}
+
+static void showHideWindow(Window *const window)
+{
+    if (window != nullptr)
+    {
+        window->setVisible(fromBool(
+            !window->isWindowVisible(), Visible));
+        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 != nullptr)
+    {
+        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(whoIsOnlineWindowShow)
+{
+    showHideWindow(whoIsOnline);
+    return true;
+}
+
+impHandler0(didYouKnowWindowShow)
+{
+    showHideWindow(didYouKnowWindow);
+    return true;
+}
+
+impHandler0(questsWindowShow)
+{
+    showHideWindow(questsWindow);
+    return true;
+}
+
+impHandler0(bankWindowShow)
+{
+#ifdef TMWA_SUPPORT
+    if (Net::getNetworkType() == ServerType::TMWATHENA)
+        return false;
+#endif  // TMWA_SUPPORT
+
+    showHideWindow(bankWindow);
+    return true;
+}
+
+impHandler0(cartWindowShow)
+{
+    if (Net::getNetworkType() == ServerType::TMWATHENA ||
+        (localPlayer == nullptr) ||
+        !localPlayer->getHaveCart())
+    {
+        return false;
+    }
+
+    showHideWindow(cartWindow);
+    if (inventoryWindow != nullptr)
+        inventoryWindow->updateDropButton();
+    return true;
+}
+
+impHandler0(updaterWindowShow)
+{
+    if (updaterWindow != nullptr)
+        updaterWindow->deleteSelf();
+    else
+        DialogsManager::createUpdaterWindow();
+    return true;
+}
+
+impHandler0(quickWindowShow)
+{
+    if (setupWindow != nullptr)
+    {
+        if (setupWindow->isWindowVisible())
+            setupWindow->doCancel();
+        setupWindow->setVisible(Visible_true);
+        // TRANSLATORS: settings tab name
+        setupWindow->activateTab(_("Quick"));
+        setupWindow->requestMoveToTop();
+        return true;
+    }
+    return false;
+}
+
+impHandler0(mailWindowShow)
+{
+    showHideWindow(mailWindow);
+    return true;
+}
+
+impHandler0(serverInfoWindowShow)
+{
+    if (serverInfoWindow != nullptr &&
+        serverInfoWindow->isWindowVisible())
+    {
+        serverInfoWindow->close();
+        serverInfoWindow = nullptr;
+    }
+    else
+    {
+        serverInfoWindow = CREATEWIDGETR(ServerInfoWindow,
+            client->getCurrentServer());
+        serverInfoWindow->requestMoveToTop();
+    }
+    return true;
+}
+
+impHandler(showItems)
+{
+    const std::string args = event.args;
+    if (args.empty())
+        return false;
+
+    Being *being = nullptr;
+    if (args[0] == ':')
+    {
+        being = actorManager->findBeing(fromInt(atoi(
+            args.substr(1).c_str()), BeingId));
+        if ((being != nullptr) && being->getType() == ActorType::Monster)
+            being = nullptr;
+    }
+    else
+    {
+        being = actorManager->findBeingByName(args, ActorType::Player);
+    }
+    if (being == nullptr)
+        return true;
+    if (being == localPlayer)
+    {
+        if (equipmentWindow != nullptr &&
+            !equipmentWindow->isWindowVisible())
+        {
+            equipmentWindow->setVisible(Visible_true);
+        }
+    }
+    else
+    {
+        if (beingEquipmentWindow != nullptr)
+        {
+            beingEquipmentWindow->setBeing(being);
+            beingEquipmentWindow->setVisible(Visible_true);
+        }
+    }
+    return true;
+}
+
+}  // namespace Actions
diff --git a/src/progs/manaplus/client.cpp b/src/progs/manaplus/client.cpp
new file mode 100644
index 000000000..6e245029d
--- /dev/null
+++ b/src/progs/manaplus/client.cpp
@@ -0,0 +1,1981 @@
+/*
+ *  The ManaPlus Client
+ *  Copyright (C) 2004-2009  The Mana World Development Team
+ *  Copyright (C) 2009-2010  The Mana Developers
+ *  Copyright (C) 2011-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 "progs/manaplus/client.h"
+
+#include "chatlogger.h"
+#include "configmanager.h"
+#include "dirs.h"
+#include "eventsmanager.h"
+#include "game.h"
+#include "graphicsmanager.h"
+#include "main.h"
+#include "party.h"
+#include "settings.h"
+#include "soundmanager.h"
+#include "spellmanager.h"
+
+#include "being/localplayer.h"
+#include "being/playerinfo.h"
+#include "being/playerrelations.h"
+
+#include "const/net/net.h"
+
+#include "enums/being/attributesstrings.h"
+
+#include "fs/virtfs/fs.h"
+#include "fs/virtfs/tools.h"
+
+#include "gui/dialogsmanager.h"
+#include "gui/gui.h"
+#include "gui/skin.h"
+#include "gui/popupmanager.h"
+#include "gui/windowmanager.h"
+
+#include "gui/shortcut/dropshortcut.h"
+#include "gui/shortcut/emoteshortcut.h"
+#include "gui/shortcut/itemshortcut.h"
+#include "gui/shortcut/spellshortcut.h"
+
+#include "gui/windows/changeemaildialog.h"
+#include "gui/windows/changepassworddialog.h"
+#include "gui/windows/charselectdialog.h"
+#include "gui/windows/connectiondialog.h"
+#include "gui/windows/equipmentwindow.h"
+#include "gui/windows/logindialog.h"
+#include "gui/windows/npcdialog.h"
+#include "gui/windows/okdialog.h"
+#include "gui/windows/registerdialog.h"
+#include "gui/windows/serverdialog.h"
+#include "gui/windows/setupwindow.h"
+#include "gui/windows/updaterwindow.h"
+#include "gui/windows/quitdialog.h"
+#include "gui/windows/worldselectdialog.h"
+
+#include "gui/widgets/button.h"
+#include "gui/widgets/createwidget.h"
+#include "gui/widgets/desktop.h"
+#include "gui/widgets/windowcontainer.h"
+
+#include "input/inputmanager.h"
+#include "input/joystick.h"
+#include "input/keyboardconfig.h"
+
+#include "input/touch/touchmanager.h"
+
+#include "net/charserverhandler.h"
+#include "net/chathandler.h"
+#include "net/download.h"
+#include "net/gamehandler.h"
+#include "net/generalhandler.h"
+#include "net/guildhandler.h"
+#include "net/inventoryhandler.h"
+#include "net/ipc.h"
+#include "net/loginhandler.h"
+#include "net/net.h"
+#include "net/updatetypeoperators.h"
+#include "net/packetlimiter.h"
+#include "net/partyhandler.h"
+
+#ifdef TMWA_SUPPORT
+#include "net/tmwa/guildmanager.h"
+#endif  // TMWA_SUPPORT
+
+#include "particle/particleengine.h"
+
+#include "resources/dbmanager.h"
+#include "resources/imagehelper.h"
+
+#include "resources/dye/dyepalette.h"
+
+#include "resources/resourcemanager/resourcemanager.h"
+
+#include "resources/sprite/spritereference.h"
+
+#include "utils/checkutils.h"
+#include "utils/cpu.h"
+#include "utils/delete2.h"
+#include "utils/dumplibs.h"
+#include "utils/dumpsizes.h"
+#include "utils/env.h"
+#include "utils/fuzzer.h"
+#include "utils/gettext.h"
+#include "utils/gettexthelper.h"
+#include "utils/mrand.h"
+#ifdef ANDROID
+#include "fs/paths.h"
+#endif  // ANDROID
+#include "utils/sdlcheckutils.h"
+#include "utils/timer.h"
+
+#include "utils/translation/translationmanager.h"
+
+#include "listeners/assertlistener.h"
+#include "listeners/errorlistener.h"
+
+#ifdef USE_OPENGL
+#include "test/testlauncher.h"
+#include "test/testmain.h"
+#else  // USE_OPENGL
+#include "configuration.h"
+#endif  // USE_OPENGL
+
+#ifdef WIN32
+PRAGMA48(GCC diagnostic push)
+PRAGMA48(GCC diagnostic ignored "-Wshadow")
+#include <SDL_syswm.h>
+PRAGMA48(GCC diagnostic pop)
+#include "fs/specialfolder.h"
+#undef ERROR
+#endif  // WIN32
+
+#ifdef ANDROID
+#ifndef USE_SDL2
+PRAGMA48(GCC diagnostic push)
+PRAGMA48(GCC diagnostic ignored "-Wshadow")
+#include <SDL_screenkeyboard.h>
+PRAGMA48(GCC diagnostic pop)
+#include <fstream>
+#endif  // USE_SDL2
+#endif  // ANDROID
+
+#include <sys/stat.h>
+
+#ifdef USE_MUMBLE
+#include "mumblemanager.h"
+#endif  // USE_MUMBLE
+
+PRAGMA48(GCC diagnostic push)
+PRAGMA48(GCC diagnostic ignored "-Wshadow")
+#ifdef USE_SDL2
+#include <SDL2_framerate.h>
+#else  // USE_SDL2
+#include <SDL_framerate.h>
+#endif  // USE_SDL2
+PRAGMA48(GCC diagnostic pop)
+
+#include "debug.h"
+
+std::string errorMessage;
+LoginData loginData;
+
+Client *client = nullptr;
+
+extern FPSmanager fpsManager;
+extern int evolPacketOffset;
+
+volatile bool runCounters;
+bool isSafeMode = false;
+int serverVersion = 0;
+int packetVersion = 0;
+unsigned int tmwServerVersion = 0;
+time_t start_time;
+unsigned int mLastHost = 0;
+unsigned long mSearchHash = 0;
+int textures_count = 0;
+volatile bool isTerminate = false;
+
+namespace
+{
+    class AccountListener final : public ActionListener
+    {
+        public:
+            AccountListener()
+            { }
+
+            A_DELETE_COPY(AccountListener)
+
+            void action(const ActionEvent &event A_UNUSED) override final
+            {
+                client->setState(State::CHAR_SELECT);
+            }
+    } accountListener;
+
+    class LoginListener final : public ActionListener
+    {
+        public:
+            LoginListener()
+            { }
+
+            A_DELETE_COPY(LoginListener)
+
+            void action(const ActionEvent &event A_UNUSED) override final
+            {
+                client->setState(State::PRE_LOGIN);
+            }
+    } loginListener;
+}  // namespace
+
+Client::Client() :
+    ActionListener(),
+    mCurrentServer(),
+    mGame(nullptr),
+    mCurrentDialog(nullptr),
+    mQuitDialog(nullptr),
+    mSetupButton(nullptr),
+    mVideoButton(nullptr),
+    mHelpButton(nullptr),
+    mAboutButton(nullptr),
+    mThemesButton(nullptr),
+    mPerfomanceButton(nullptr),
+#ifdef ANDROID
+    mCloseButton(nullptr),
+#endif  // ANDROID
+    mState(State::CHOOSE_SERVER),
+    mOldState(State::START),
+    mSkin(nullptr),
+    mButtonPadding(1),
+    mButtonSpacing(3),
+    mPing(0),
+    mConfigAutoSaved(false)
+{
+    WindowManager::init();
+}
+
+void Client::testsInit()
+{
+    if (!settings.options.test.empty() &&
+        settings.options.test != "99")
+    {
+        gameInit();
+    }
+    else
+    {
+        initRand();
+        logger = new Logger;
+        Dirs::initLocalDataDir();
+        Dirs::initTempDir();
+        Dirs::initConfigDir();
+        GettextHelper::initLang();
+    }
+}
+
+void Client::gameInit()
+{
+    logger = new Logger;
+
+    initRand();
+
+    assertListener = new AssertListener;
+    // Load branding information
+    if (!settings.options.brandingPath.empty())
+        branding.init(settings.options.brandingPath);
+    setBrandingDefaults(branding);
+
+    Dirs::initRootDir();
+    Dirs::initHomeDir();
+
+    // Configure logger
+    if (!settings.options.logFileName.empty())
+    {
+        settings.logFileName = settings.options.logFileName;
+    }
+    else
+    {
+        settings.logFileName = pathJoin(settings.localDataDir,
+            "manaplus.log");
+    }
+    logger->log("Log file: " + settings.logFileName);
+    logger->setLogFile(settings.logFileName);
+
+#ifdef USE_FUZZER
+    Fuzzer::init();
+#endif  // USE_FUZZER
+
+    if (settings.options.ipc == true)
+        IPC::start();
+    if (settings.options.test.empty())
+        ConfigManager::backupConfig("config.xml");
+    ConfigManager::initConfiguration();
+    settings.init();
+    Net::loadIgnorePackets();
+    setPathsDefaults(paths);
+    initFeatures();
+    initPaths();
+    logger->log("init 4");
+    logger->setDebugLog(config.getBoolValue("debugLog"));
+    logger->setReportUnimplemented(config.getBoolValue("unimplimentedLog"));
+
+    config.incValue("runcount");
+
+#ifndef ANDROID
+    if (settings.options.test.empty())
+        ConfigManager::storeSafeParameters();
+#endif  // ANDROID
+
+    if (!VirtFs::setWriteDir(settings.localDataDir))
+    {
+        logger->error(strprintf("%s couldn't be set as home directory! "
+            "Exiting.", settings.localDataDir.c_str()));
+    }
+
+    GettextHelper::initLang();
+
+    chatLogger = new ChatLogger;
+    if (settings.options.chatLogDir.empty())
+    {
+        chatLogger->setBaseLogDir(settings.localDataDir
+            + std::string("/logs/"));
+    }
+    else
+    {
+        chatLogger->setBaseLogDir(settings.options.chatLogDir);
+    }
+
+    logger->setLogToStandardOut(config.getBoolValue("logToStandardOut"));
+
+    // Log the client version
+    logger->log1(FULL_VERSION);
+    logger->log("Start configPath: " + config.getConfigPath());
+
+    Dirs::initScreenshotDir();
+
+    updateEnv();
+    dumpLibs();
+    dumpSizes();
+
+    // Initialize SDL
+    logger->log1("Initializing SDL...");
+    if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER) < 0)
+    {
+        logger->safeError(strprintf("Could not initialize SDL: %s",
+            SDL_GetError()));
+    }
+    atexit(SDL_Quit);
+
+    PacketLimiter::initPacketLimiter();
+#ifndef USE_SDL2
+    SDL_EnableUNICODE(1);
+#endif  // USE_SDL2
+
+    WindowManager::applyKeyRepeat();
+
+    // disable unused SDL events
+#ifndef USE_SDL2
+    SDL_EventState(SDL_VIDEOEXPOSE, SDL_IGNORE);
+#endif  // USE_SDL2
+
+    SDL_EventState(SDL_SYSWMEVENT, SDL_IGNORE);
+    SDL_EventState(SDL_USEREVENT, SDL_IGNORE);
+
+#ifdef WIN32
+    Dirs::extractDataDir();
+    Dirs::mountDataDir();
+#endif  // WIN32
+
+    WindowManager::setIcon();
+    ConfigManager::checkConfigVersion();
+    logVars();
+    Cpu::detect();
+    DyePalette::initFunctions();
+#if defined(USE_OPENGL)
+#if !defined(ANDROID) && !defined(__APPLE__) && \
+    !defined(__native_client__) && !defined(UNITTESTS)
+    if (!settings.options.safeMode &&
+        settings.options.renderer < 0 &&
+        settings.options.test.empty() &&
+        !settings.options.validate &&
+        !config.getBoolValue("videodetected"))
+    {
+        graphicsManager.detectVideoSettings();
+    }
+#endif  // !defined(ANDROID) && !defined(__APPLE__) &&
+        // !defined(__native_client__) && !defined(UNITTESTS)
+#endif  // defined(USE_OPENGL)
+
+    initGraphics();
+
+    touchManager.init();
+
+#ifndef WIN32
+    Dirs::extractDataDir();
+    Dirs::mountDataDir();
+#endif  // WIN32
+
+    Dirs::updateDataPath();
+
+    // Add the main data directories to our PhysicsFS search path
+    if (!settings.options.dataPath.empty())
+    {
+        VirtFs::mountDir(settings.options.dataPath,
+            Append_false);
+    }
+
+    // Add the local data directory to PhysicsFS search path
+    VirtFs::mountDir(settings.localDataDir,
+        Append_false);
+    TranslationManager::loadCurrentLang();
+    TranslationManager::loadDictionaryLang();
+#ifdef ENABLE_CUSTOMNLS
+    TranslationManager::loadGettextLang();
+#endif  // ENABLE_CUSTOMNLS
+
+    WindowManager::initTitle();
+
+    mainGraphics->postInit();
+
+    theme = new Theme;
+    Theme::selectSkin();
+    ActorSprite::load();
+    touchManager.init();
+
+    // Initialize the item and emote shortcuts.
+    for (size_t f = 0; f < SHORTCUT_TABS; f ++)
+        itemShortcut[f] = new ItemShortcut(f);
+    emoteShortcut = new EmoteShortcut;
+    dropShortcut = new DropShortcut;
+
+    gui = new Gui;
+    gui->postInit(mainGraphics);
+    dialogsManager = new DialogsManager;
+    popupManager = new PopupManager;
+
+    initSoundManager();
+    eventsManager.init();
+
+    // Initialize keyboard
+    keyboard.init();
+    inputManager.init();
+
+    // Initialise player relations
+    playerRelations.init();
+    Joystick::init();
+    WindowManager::createWindows();
+
+    keyboard.update();
+    if (joystick != nullptr)
+        joystick->update();
+
+    // Initialize default server
+    mCurrentServer.hostname = settings.options.serverName;
+    mCurrentServer.port = settings.options.serverPort;
+    if (!settings.options.serverType.empty())
+    {
+        mCurrentServer.type = ServerInfo::parseType(
+            settings.options.serverType);
+    }
+
+    loginData.username = settings.options.username;
+    loginData.password = settings.options.password;
+    LoginDialog::savedPassword = settings.options.password;
+    loginData.remember = (serverConfig.getValue("remember", 1) != 0);
+    loginData.registerLogin = false;
+
+    if (mCurrentServer.hostname.empty())
+    {
+        mCurrentServer.hostname = branding.getValue("defaultServer", "");
+        settings.options.serverName = mCurrentServer.hostname;
+    }
+
+    if (mCurrentServer.port == 0)
+    {
+        mCurrentServer.port = CAST_U16(branding.getValue(
+            "defaultPort", CAST_S32(DEFAULT_PORT)));
+        mCurrentServer.type = ServerInfo::parseType(
+            branding.getValue("defaultServerType", "tmwathena"));
+    }
+
+    chatLogger->setServerName(mCurrentServer.hostname);
+
+    if (loginData.username.empty() && loginData.remember)
+        loginData.username = serverConfig.getValue("username", "");
+
+    if (mState != State::ERROR)
+        mState = State::CHOOSE_SERVER;
+
+    startTimers();
+
+    const int fpsLimit = config.getIntValue("fpslimit");
+    settings.limitFps = fpsLimit > 0;
+
+    SDL_initFramerate(&fpsManager);
+    WindowManager::setFramerate(fpsLimit);
+    initConfigListeners();
+
+    settings.guiAlpha = config.getFloatValue("guialpha");
+    optionChanged("fpslimit");
+
+    start_time = time(nullptr);
+
+    PlayerInfo::init();
+
+#ifdef ANDROID
+#ifndef USE_SDL2
+    WindowManager::updateScreenKeyboard(SDL_GetScreenKeyboardHeight(nullptr));
+#endif  // USE_SDL2
+#endif  // ANDROID
+
+#ifdef USE_MUMBLE
+    if (!mumbleManager)
+        mumbleManager = new MumbleManager;
+#endif  // USE_MUMBLE
+
+    mSkin = theme->load("windowmenu.xml", "");
+    if (mSkin != nullptr)
+    {
+        mButtonPadding = mSkin->getPadding();
+        mButtonSpacing = mSkin->getOption("spacing", 3);
+    }
+    if (settings.options.error)
+        inputManager.executeAction(InputAction::ERROR);
+
+    if (settings.options.validate == true)
+        runValidate();
+}
+
+Client::~Client()
+{
+    if (!settings.options.testMode)
+        gameClear();
+    else
+        testsClear();
+    CHECKLISTENERS
+}
+
+void Client::initConfigListeners()
+{
+    config.addListener("fpslimit", this);
+    config.addListener("guialpha", this);
+    config.addListener("gamma", this);
+    config.addListener("enableGamma", this);
+    config.addListener("particleEmitterSkip", this);
+    config.addListener("vsync", this);
+    config.addListener("repeateDelay", this);
+    config.addListener("repeateInterval", this);
+    config.addListener("logInput", this);
+}
+
+void Client::initSoundManager()
+{
+    // Initialize sound engine
+    try
+    {
+        if (config.getBoolValue("sound"))
+            soundManager.init();
+
+        soundManager.setSfxVolume(config.getIntValue("sfxVolume"));
+        soundManager.setMusicVolume(config.getIntValue("musicVolume"));
+    }
+    catch (const char *const err)
+    {
+        mState = State::ERROR;
+        errorMessage = err;
+        logger->log("Warning: %s", err);
+    }
+    soundManager.playMusic(branding.getValue(
+        "loginMusic",
+        "keprohm.ogg"),
+        SkipError_true);
+}
+
+void Client::initGraphics()
+{
+    WindowManager::applyVSync();
+    runCounters = config.getBoolValue("packetcounters");
+
+    graphicsManager.initGraphics();
+
+    imageHelper->postInit();
+    setConfigDefaults2(config);
+    WindowManager::applyGrabMode();
+    WindowManager::applyGamma();
+
+    mainGraphics->beginDraw();
+}
+
+void Client::testsClear()
+{
+    if (!settings.options.test.empty())
+        gameClear();
+    else
+        BeingInfo::clear();
+}
+
+void Client::gameClear()
+{
+    if (logger != nullptr)
+        logger->log1("Quitting1");
+    isTerminate = true;
+    config.removeListeners(this);
+
+    delete2(assertListener);
+
+    IPC::stop();
+    eventsManager.shutdown();
+    WindowManager::deleteWindows();
+    if (windowContainer != nullptr)
+        windowContainer->slowLogic();
+
+    stopTimers();
+    DbManager::unloadDb();
+
+    if (loginHandler != nullptr)
+        loginHandler->clearWorlds();
+
+    if (chatHandler != nullptr)
+        chatHandler->clear();
+
+    if (charServerHandler != nullptr)
+        charServerHandler->clear();
+
+    delete2(ipc);
+
+#ifdef USE_MUMBLE
+    delete2(mumbleManager);
+#endif  // USE_MUMBLE
+
+    PlayerInfo::deinit();
+
+    // Before config.write() since it writes the shortcuts to the config
+    for (unsigned f = 0; f < SHORTCUT_TABS; f ++)
+        delete2(itemShortcut[f])
+    delete2(emoteShortcut);
+    delete2(dropShortcut);
+
+    playerRelations.store();
+
+    if (logger != nullptr)
+        logger->log1("Quitting2");
+
+    delete2(mCurrentDialog);
+    delete2(popupManager);
+    delete2(dialogsManager);
+    delete2(gui);
+
+    if (inventoryHandler != nullptr)
+        inventoryHandler->clear();
+
+    if (logger != nullptr)
+        logger->log1("Quitting3");
+
+    touchManager.clear();
+
+    GraphicsManager::deleteRenderers();
+
+    if (logger != nullptr)
+        logger->log1("Quitting4");
+
+    XML::cleanupXML();
+
+    if (logger != nullptr)
+        logger->log1("Quitting5");
+
+    BeingInfo::clear();
+
+    // Shutdown sound
+    soundManager.close();
+
+    if (logger != nullptr)
+        logger->log1("Quitting6");
+
+    ActorSprite::unload();
+
+    ResourceManager::deleteInstance();
+
+    if (logger != nullptr)
+        logger->log1("Quitting8");
+
+    WindowManager::deleteIcon();
+
+    if (logger != nullptr)
+        logger->log1("Quitting9");
+
+    delete2(joystick);
+
+    keyboard.deinit();
+
+    if (logger != nullptr)
+        logger->log1("Quitting10");
+
+    soundManager.shutdown();
+    touchManager.shutdown();
+
+#ifdef DEBUG_CONFIG
+    config.enableKeyLogging();
+#endif  // DEBUG_CONFIG
+
+    config.removeOldKeys();
+    config.write();
+    serverConfig.write();
+
+    config.clear();
+    serverConfig.clear();
+
+    if (logger != nullptr)
+        logger->log1("Quitting11");
+
+#ifdef USE_PROFILER
+    Perfomance::clear();
+#endif  // USE_PROFILER
+
+#ifdef DEBUG_OPENGL_LEAKS
+    if (logger)
+        logger->log("textures left: %d", textures_count);
+#endif  // DEBUG_OPENGL_LEAKS
+
+    Graphics::cleanUp();
+
+    if (logger != nullptr)
+        logger->log1("Quitting12");
+
+    delete2(chatLogger);
+    TranslationManager::close();
+}
+
+int Client::testsExec()
+{
+#ifdef USE_OPENGL
+    if (settings.options.test.empty())
+    {
+        TestMain test;
+        return test.exec();
+    }
+    else
+    {
+        TestLauncher launcher(settings.options.test);
+        return launcher.exec();
+    }
+#else  // USE_OPENGL
+
+    return 0;
+#endif  // USE_OPENGL
+}
+
+#define ADDBUTTON(var, object) var = object; \
+    x -= var->getWidth() + mButtonSpacing; \
+    var->setPosition(x, mButtonPadding); \
+    top->add(var);
+
+void Client::stateConnectGame1()
+{
+    if ((gameHandler != nullptr) &&
+        (loginHandler != nullptr) &&
+        gameHandler->isConnected())
+    {
+        loginHandler->disconnect();
+    }
+}
+
+void Client::stateConnectServer1()
+{
+    if (mOldState == State::CHOOSE_SERVER)
+    {
+        settings.serverName = mCurrentServer.hostname;
+        ConfigManager::initServerConfig(mCurrentServer.hostname);
+        PacketLimiter::initPacketLimiter();
+        initTradeFilter();
+        Dirs::initUsersDir();
+        playerRelations.init();
+
+        // Initialize the item and emote shortcuts.
+        for (unsigned f = 0; f < SHORTCUT_TABS; f ++)
+        {
+            delete itemShortcut[f];
+            itemShortcut[f] = new ItemShortcut(f);
+        }
+        delete emoteShortcut;
+        emoteShortcut = new EmoteShortcut;
+
+        // Initialize the drop shortcuts.
+        delete dropShortcut;
+        dropShortcut = new DropShortcut;
+
+        initFeatures();
+        PlayerInfo::loadData();
+        loginData.registerUrl = mCurrentServer.registerUrl;
+        loginData.packetVersion = mCurrentServer.packetVersion;
+        if (!mCurrentServer.onlineListUrl.empty())
+            settings.onlineListUrl = mCurrentServer.onlineListUrl;
+        else
+            settings.onlineListUrl = settings.serverName;
+        settings.persistentIp = mCurrentServer.persistentIp;
+        settings.supportUrl = mCurrentServer.supportUrl;
+        settings.updateMirrors = mCurrentServer.updateMirrors;
+        settings.enableRemoteCommands = (serverConfig.getValue(
+            "enableRemoteCommands", 1) != 0);
+
+        if (settings.options.username.empty())
+        {
+            if (loginData.remember)
+                loginData.username = serverConfig.getValue("username", "");
+            else
+                loginData.username.clear();
+        }
+        else
+        {
+            loginData.username = settings.options.username;
+        }
+        settings.login = loginData.username;
+        WindowManager::updateTitle();
+
+        loginData.remember = (serverConfig.getValue("remember", 1) != 0);
+        Net::connectToServer(mCurrentServer);
+
+#ifdef USE_MUMBLE
+        if (mumbleManager)
+            mumbleManager->setServer(mCurrentServer.hostname);
+#endif  // USE_MUMBLE
+
+#ifdef TMWA_SUPPORT
+        GuildManager::init();
+#endif  // TMWA_SUPPORT
+
+        if (!mConfigAutoSaved)
+        {
+            mConfigAutoSaved = true;
+            config.write();
+        }
+    }
+    else if (mOldState != State::CHOOSE_SERVER &&
+             (loginHandler != nullptr) &&
+             loginHandler->isConnected())
+    {
+        mState = State::PRE_LOGIN;
+    }
+}
+
+void Client::stateWorldSelect1()
+{
+    if (mOldState == State::UPDATE &&
+        (loginHandler != nullptr))
+    {
+        if (loginHandler->getWorlds().size() < 2)
+            mState = State::PRE_LOGIN;
+    }
+}
+
+void Client::stateGame1()
+{
+    if (gui == nullptr)
+        return;
+
+    BasicContainer2 *const top = static_cast<BasicContainer2*>(
+        gui->getTop());
+
+    if (top == nullptr)
+        return;
+
+    CREATEWIDGETV(desktop, Desktop, nullptr);
+    top->add(desktop);
+    int x = top->getWidth() - mButtonPadding;
+    ADDBUTTON(mSetupButton, new Button(desktop,
+        // TRANSLATORS: setup tab quick button
+        _("Setup"), "Setup", this))
+    ADDBUTTON(mPerfomanceButton, new Button(desktop,
+        // TRANSLATORS: perfoamance tab quick button
+        _("Performance"), "Perfomance", this))
+    ADDBUTTON(mVideoButton, new Button(desktop,
+        // TRANSLATORS: video tab quick button
+        _("Video"), "Video", this))
+    ADDBUTTON(mThemesButton, new Button(desktop,
+        // TRANSLATORS: theme tab quick button
+        _("Theme"), "Themes", this))
+    ADDBUTTON(mAboutButton, new Button(desktop,
+        // TRANSLATORS: theme tab quick button
+        _("About"), "about", this))
+    ADDBUTTON(mHelpButton, new Button(desktop,
+        // TRANSLATORS: theme tab quick button
+        _("Help"), "help", this))
+#ifdef ANDROID
+    ADDBUTTON(mCloseButton, new Button(desktop,
+        // TRANSLATORS: close quick button
+        _("Close"), "close", this))
+#endif  // ANDROID
+
+    desktop->setSize(mainGraphics->getWidth(),
+        mainGraphics->getHeight());
+}
+
+void Client::stateSwitchLogin1()
+{
+    if (mOldState == State::GAME &&
+        (gameHandler != nullptr))
+    {
+        gameHandler->disconnect();
+    }
+}
+
+int Client::gameExec()
+{
+    int lastTickTime = tick_time;
+
+    while (mState != State::EXIT)
+    {
+        PROFILER_START();
+        if (eventsManager.handleEvents())
+            continue;
+
+        BLOCK_START("Client::gameExec 3")
+        if (generalHandler != nullptr)
+            generalHandler->flushNetwork();
+        BLOCK_END("Client::gameExec 3")
+
+        BLOCK_START("Client::gameExec 4")
+        if (gui != nullptr)
+            gui->logic();
+        cur_time = time(nullptr);
+        int k = 0;
+        while (lastTickTime != tick_time &&
+               k < 40)
+        {
+            if (mGame != nullptr)
+                mGame->logic();
+            else if (gui != nullptr)
+                gui->handleInput();
+
+            ++lastTickTime;
+            k ++;
+        }
+        soundManager.logic();
+
+        logic_count += k;
+        if (gui != nullptr)
+            gui->slowLogic();
+        if (mGame != nullptr)
+            mGame->slowLogic();
+        slowLogic();
+        BLOCK_END("Client::gameExec 4")
+
+        // This is done because at some point tick_time will wrap.
+        lastTickTime = tick_time;
+
+        // Update the screen when application is visible, delay otherwise.
+        if (!WindowManager::getIsMinimized())
+        {
+            frame_count++;
+            if (gui != nullptr)
+                gui->draw();
+            mainGraphics->updateScreen();
+        }
+        else
+        {
+            SDL_Delay(100);
+        }
+
+        BLOCK_START("~Client::SDL_framerateDelay")
+        if (settings.limitFps)
+            SDL_framerateDelay(&fpsManager);
+        BLOCK_END("~Client::SDL_framerateDelay")
+
+        BLOCK_START("Client::gameExec 6")
+        if (mState == State::CONNECT_GAME)
+        {
+            stateConnectGame1();
+        }
+        else if (mState == State::CONNECT_SERVER)
+        {
+            stateConnectServer1();
+        }
+        else if (mState == State::WORLD_SELECT)
+        {
+            stateWorldSelect1();
+        }
+        else if (mOldState == State::START ||
+                 (mOldState == State::GAME && mState != State::GAME))
+        {
+            stateGame1();
+        }
+        else if (mState == State::SWITCH_LOGIN)
+        {
+            stateSwitchLogin1();
+        }
+        BLOCK_END("Client::gameExec 6")
+
+        if (mState != mOldState)
+        {
+            BLOCK_START("Client::gameExec 7")
+            PlayerInfo::stateChange(mState);
+
+            if (mOldState == State::GAME)
+            {
+                delete2(mGame);
+                assertListener = new AssertListener;
+                Game::clearInstance();
+                ResourceManager::cleanOrphans();
+                Party::clearParties();
+                Guild::clearGuilds();
+                NpcDialog::clearDialogs();
+                if (guildHandler != nullptr)
+                    guildHandler->clear();
+                if (partyHandler != nullptr)
+                    partyHandler->clear();
+                if (chatLogger != nullptr)
+                    chatLogger->clear();
+                if (!settings.options.dataPath.empty())
+                    UpdaterWindow::unloadMods(settings.options.dataPath);
+                else
+                    UpdaterWindow::unloadMods(settings.oldUpdates);
+                if (!settings.options.skipUpdate)
+                    UpdaterWindow::unloadMods(settings.oldUpdates + "/fix/");
+            }
+            else if (mOldState == State::CHAR_SELECT)
+            {
+                if (mState != State::CHANGEPASSWORD &&
+                    charServerHandler != nullptr)
+                {
+                    charServerHandler->clear();
+                }
+            }
+
+            mOldState = mState;
+
+            // Get rid of the dialog of the previous state
+            delete2(mCurrentDialog);
+
+            // State has changed, while the quitDialog was active, it might
+            // not be correct anymore
+            if (mQuitDialog != nullptr)
+            {
+                mQuitDialog->scheduleDelete();
+                mQuitDialog = nullptr;
+            }
+            BLOCK_END("Client::gameExec 7")
+
+            BLOCK_START("Client::gameExec 8")
+            switch (mState)
+            {
+                case State::CHOOSE_SERVER:
+                {
+                    BLOCK_START("Client::gameExec STATE_CHOOSE_SERVER")
+                    logger->log1("State: CHOOSE SERVER");
+                    unloadData();
+
+                    // Allow changing this using a server choice dialog
+                    // We show the dialog box only if the command-line
+                    // options weren't set.
+                    if (settings.options.serverName.empty() &&
+                        settings.options.serverPort == 0 &&
+                        !branding.getValue("onlineServerList", "a").empty())
+                    {
+                        // Don't allow an alpha opacity
+                        // lower than the default value
+                        theme->setMinimumOpacity(0.8F);
+
+                        CREATEWIDGETV(mCurrentDialog, ServerDialog,
+                            &mCurrentServer,
+                            settings.configDir);
+                    }
+                    else
+                    {
+                        mState = State::CONNECT_SERVER;
+
+                        // Reset options so that cancelling or connect
+                        // timeout will show the server dialog.
+                        settings.options.serverName.clear();
+                        settings.options.serverPort = 0;
+                    }
+                    BLOCK_END("Client::gameExec STATE_CHOOSE_SERVER")
+                    break;
+                }
+
+                case State::CONNECT_SERVER:
+                    BLOCK_START("Client::gameExec State::CONNECT_SERVER")
+                    logger->log1("State: CONNECT SERVER");
+                    loginData.updateHosts.clear();
+                    CREATEWIDGETV(mCurrentDialog, ConnectionDialog,
+                        // TRANSLATORS: connection dialog header
+                        _("Connecting to server"),
+                        State::SWITCH_SERVER);
+                    TranslationManager::loadCurrentLang();
+                    TranslationManager::loadDictionaryLang();
+                    BLOCK_END("Client::gameExec State::CONNECT_SERVER")
+                    break;
+
+                case State::PRE_LOGIN:
+                    logger->log1("State: PRE_LOGIN");
+                    break;
+
+                case State::LOGIN:
+                    BLOCK_START("Client::gameExec State::LOGIN")
+                    logger->log1("State: LOGIN");
+                    // Don't allow an alpha opacity
+                    // lower than the default value
+                    theme->setMinimumOpacity(0.8F);
+
+                    if (packetVersion == 0)
+                    {
+                        packetVersion = loginData.packetVersion;
+                        if (packetVersion != 0)
+                        {
+                            loginHandler->updatePacketVersion();
+                            logger->log("Preconfigured packet version: %d",
+                                packetVersion);
+                        }
+                    }
+
+                    loginData.updateType = static_cast<UpdateTypeT>(
+                        serverConfig.getValue("updateType", 0));
+
+                    mSearchHash = Net::Download::adlerBuffer(
+                        const_cast<char*>(mCurrentServer.hostname.c_str()),
+                        CAST_S32(mCurrentServer.hostname.size()));
+                    if (settings.options.username.empty() ||
+                        settings.options.password.empty())
+                    {
+                        CREATEWIDGETV(mCurrentDialog, LoginDialog,
+                            loginData,
+                            &mCurrentServer,
+                            &settings.options.updateHost);
+                    }
+                    else
+                    {
+                        mState = State::LOGIN_ATTEMPT;
+                        // Clear the password so that when login fails, the
+                        // dialog will show up next time.
+                        settings.options.password.clear();
+                    }
+                    BLOCK_END("Client::gameExec State::LOGIN")
+                    break;
+
+                case State::LOGIN_ATTEMPT:
+                    BLOCK_START("Client::gameExec State::LOGIN_ATTEMPT")
+                    logger->log1("State: LOGIN ATTEMPT");
+                    CREATEWIDGETV(mCurrentDialog, ConnectionDialog,
+                        // TRANSLATORS: connection dialog header
+                        _("Logging in"),
+                        State::SWITCH_SERVER);
+                    if (loginHandler != nullptr)
+                        loginHandler->loginOrRegister(&loginData);
+                    BLOCK_END("Client::gameExec State::LOGIN_ATTEMPT")
+                    break;
+
+                case State::WORLD_SELECT:
+                    BLOCK_START("Client::gameExec State::WORLD_SELECT")
+                    logger->log1("State: WORLD SELECT");
+                    {
+                        TranslationManager::loadCurrentLang();
+                        TranslationManager::loadDictionaryLang();
+                        if (loginHandler == nullptr)
+                        {
+                            BLOCK_END("Client::gameExec State::WORLD_SELECT")
+                            break;
+                        }
+                        Worlds worlds = loginHandler->getWorlds();
+
+                        if (worlds.empty())
+                        {
+                            // Trust that the netcode knows what it's doing
+                            mState = State::UPDATE;
+                        }
+                        else if (worlds.size() == 1)
+                        {
+                            loginHandler->chooseServer(
+                                0, mCurrentServer.persistentIp);
+                            mState = State::UPDATE;
+                        }
+                        else
+                        {
+                            CREATEWIDGETV(mCurrentDialog, WorldSelectDialog,
+                                worlds);
+                            if (settings.options.chooseDefault)
+                            {
+                                static_cast<WorldSelectDialog*>(mCurrentDialog)
+                                    ->action(ActionEvent(nullptr, "ok"));
+                            }
+                        }
+                    }
+                    BLOCK_END("Client::gameExec State::WORLD_SELECT")
+                    break;
+
+                case State::WORLD_SELECT_ATTEMPT:
+                    BLOCK_START("Client::gameExec State::WORLD_SELECT_ATTEMPT")
+                    logger->log1("State: WORLD SELECT ATTEMPT");
+                    CREATEWIDGETV(mCurrentDialog, ConnectionDialog,
+                        // TRANSLATORS: connection dialog header
+                        _("Entering game world"),
+                        State::WORLD_SELECT);
+                    BLOCK_END("Client::gameExec State::WORLD_SELECT_ATTEMPT")
+                    break;
+
+                case State::UPDATE:
+                    BLOCK_START("Client::gameExec State::UPDATE")
+                    logger->log1("State: UPDATE");
+
+                    // Determine which source to use for the update host
+                    if (!settings.options.updateHost.empty())
+                        settings.updateHost = settings.options.updateHost;
+                    else
+                        settings.updateHost = loginData.updateHost;
+                    Dirs::initUpdatesDir();
+
+                    if (!settings.oldUpdates.empty())
+                        UpdaterWindow::unloadUpdates(settings.oldUpdates);
+
+                    if (settings.options.skipUpdate)
+                    {
+                        mState = State::LOAD_DATA;
+                        settings.oldUpdates.clear();
+                        UpdaterWindow::loadDirMods(settings.options.dataPath);
+                    }
+                    else if ((loginData.updateType & UpdateType::Skip) != 0)
+                    {
+                        settings.oldUpdates = pathJoin(settings.localDataDir,
+                            settings.updatesDir);
+                        UpdaterWindow::loadLocalUpdates(settings.oldUpdates);
+                        mState = State::LOAD_DATA;
+                    }
+                    else
+                    {
+                        settings.oldUpdates = pathJoin(settings.localDataDir,
+                            settings.updatesDir);
+                        CREATEWIDGETV(mCurrentDialog, UpdaterWindow,
+                            settings.updateHost,
+                            settings.oldUpdates,
+                            settings.options.dataPath.empty(),
+                            loginData.updateType);
+                    }
+                    BLOCK_END("Client::gameExec State::UPDATE")
+                    break;
+
+                case State::LOAD_DATA:
+                {
+                    BLOCK_START("Client::gameExec State::LOAD_DATA")
+                    logger->log1("State: LOAD DATA");
+
+                    loadData();
+
+                    mState = State::GET_CHARACTERS;
+                    BLOCK_END("Client::gameExec State::LOAD_DATA")
+                    break;
+                }
+                case State::GET_CHARACTERS:
+                    BLOCK_START("Client::gameExec State::GET_CHARACTERS")
+                    logger->log1("State: GET CHARACTERS");
+                    CREATEWIDGETV(mCurrentDialog, ConnectionDialog,
+                        // TRANSLATORS: connection dialog header
+                        _("Requesting characters"),
+                        State::SWITCH_SERVER);
+                    if (charServerHandler != nullptr)
+                        charServerHandler->requestCharacters();
+                    BLOCK_END("Client::gameExec State::GET_CHARACTERS")
+                    break;
+
+                case State::CHAR_SELECT:
+                    BLOCK_START("Client::gameExec State::CHAR_SELECT")
+                    logger->log1("State: CHAR SELECT");
+                    // Don't allow an alpha opacity
+                    // lower than the default value
+                    theme->setMinimumOpacity(0.8F);
+
+                    settings.login = loginData.username;
+                    WindowManager::updateTitle();
+
+                    CREATEWIDGETV(mCurrentDialog, CharSelectDialog,
+                        loginData);
+
+                    if (!(static_cast<CharSelectDialog*>(mCurrentDialog))
+                        ->selectByName(settings.options.character,
+                        CharSelectDialog::Choose))
+                    {
+                        (static_cast<CharSelectDialog*>(mCurrentDialog))
+                            ->selectByName(
+                            serverConfig.getValue("lastCharacter", ""),
+                            settings.options.chooseDefault ?
+                            CharSelectDialog::Choose :
+                            CharSelectDialog::Focus);
+                    }
+
+                    // Choosing character on the command line should work only
+                    // once, clear it so that 'switch character' works.
+                    settings.options.character.clear();
+                    BLOCK_END("Client::gameExec State::CHAR_SELECT")
+                    break;
+
+                case State::CONNECT_GAME:
+                    BLOCK_START("Client::gameExec State::CONNECT_GAME")
+                    logger->log1("State: CONNECT GAME");
+                    CREATEWIDGETV(mCurrentDialog, ConnectionDialog,
+                        // TRANSLATORS: connection dialog header
+                        _("Connecting to the game server"),
+                        State::CHOOSE_SERVER);
+                    if (gameHandler != nullptr)
+                        gameHandler->connect();
+                    BLOCK_END("Client::gameExec State::CONNECT_GAME")
+                    break;
+
+                case State::CHANGE_MAP:
+                    BLOCK_START("Client::gameExec State::CHANGE_MAP")
+                    logger->log1("State: CHANGE_MAP");
+                    CREATEWIDGETV(mCurrentDialog, ConnectionDialog,
+                        // TRANSLATORS: connection dialog header
+                        _("Changing game servers"),
+                        State::SWITCH_CHARACTER);
+                    if (gameHandler != nullptr)
+                        gameHandler->connect();
+                    BLOCK_END("Client::gameExec State::CHANGE_MAP")
+                    break;
+
+                case State::GAME:
+                    BLOCK_START("Client::gameExec State::GAME")
+                    if (localPlayer != nullptr)
+                    {
+                        logger->log("Memorizing selected character %s",
+                            localPlayer->getName().c_str());
+                        serverConfig.setValue("lastCharacter",
+                            localPlayer->getName());
+#ifdef USE_MUMBLE
+                        if (mumbleManager)
+                            mumbleManager->setPlayer(localPlayer->getName());
+#endif  // USE_MUMBLE
+                    }
+
+                    // Fade out logon-music here too to give the desired effect
+                    // of "flowing" into the game.
+                    soundManager.fadeOutMusic(1000);
+
+                    // Allow any alpha opacity
+                    theme->setMinimumOpacity(-1.0F);
+
+                    if (chatLogger != nullptr)
+                        chatLogger->setServerName(settings.serverName);
+
+#ifdef ANDROID
+                    delete2(mCloseButton);
+#endif  // ANDROID
+
+                    delete2(mSetupButton);
+                    delete2(mVideoButton);
+                    delete2(mThemesButton);
+                    delete2(mAboutButton);
+                    delete2(mHelpButton);
+                    delete2(mPerfomanceButton);
+                    delete2(desktop);
+
+                    mCurrentDialog = nullptr;
+
+                    logger->log1("State: GAME");
+                    if (generalHandler != nullptr)
+                        generalHandler->reloadPartially();
+                    mGame = new Game;
+                    BLOCK_END("Client::gameExec State::GAME")
+                    break;
+
+                case State::LOGIN_ERROR:
+                    BLOCK_START("Client::gameExec State::LOGIN_ERROR")
+                    logger->log1("State: LOGIN ERROR");
+                    CREATEWIDGETV(mCurrentDialog, OkDialog,
+                        // TRANSLATORS: error dialog header
+                        _("Error"),
+                        errorMessage,
+                        // TRANSLATORS: ok dialog button
+                        _("Close"),
+                        DialogType::ERROR,
+                        Modal_true,
+                        ShowCenter_true,
+                        nullptr,
+                        260);
+                    mCurrentDialog->addActionListener(&loginListener);
+                    mCurrentDialog = nullptr;  // OkDialog deletes itself
+                    BLOCK_END("Client::gameExec State::LOGIN_ERROR")
+                    break;
+
+                case State::ACCOUNTCHANGE_ERROR:
+                    BLOCK_START("Client::gameExec State::ACCOUNTCHANGE_ERROR")
+                    logger->log1("State: ACCOUNT CHANGE ERROR");
+                    CREATEWIDGETV(mCurrentDialog, OkDialog,
+                        // TRANSLATORS: error dialog header
+                        _("Error"),
+                        errorMessage,
+                        // TRANSLATORS: ok dialog button
+                        _("Close"),
+                        DialogType::ERROR,
+                        Modal_true,
+                        ShowCenter_true,
+                        nullptr,
+                        260);
+                    mCurrentDialog->addActionListener(&accountListener);
+                    mCurrentDialog = nullptr;  // OkDialog deletes itself
+                    BLOCK_END("Client::gameExec State::ACCOUNTCHANGE_ERROR")
+                    break;
+
+                case State::REGISTER_PREP:
+                    BLOCK_START("Client::gameExec State::REGISTER_PREP")
+                    logger->log1("State: REGISTER_PREP");
+                    CREATEWIDGETV(mCurrentDialog, ConnectionDialog,
+                        // TRANSLATORS: connection dialog header
+                        _("Requesting registration details"),
+                        State::LOGIN);
+                    loginHandler->getRegistrationDetails();
+                    BLOCK_END("Client::gameExec State::REGISTER_PREP")
+                    break;
+
+                case State::REGISTER:
+                    logger->log1("State: REGISTER");
+                    CREATEWIDGETV(mCurrentDialog, RegisterDialog,
+                        loginData);
+                    break;
+
+                case State::REGISTER_ATTEMPT:
+                    BLOCK_START("Client::gameExec State::REGISTER_ATTEMPT")
+                    logger->log("Username is %s", loginData.username.c_str());
+                    if (loginHandler != nullptr)
+                        loginHandler->registerAccount(&loginData);
+                    BLOCK_END("Client::gameExec State::REGISTER_ATTEMPT")
+                    break;
+
+                case State::CHANGEPASSWORD:
+                    BLOCK_START("Client::gameExec State::CHANGEPASSWORD")
+                    logger->log1("State: CHANGE PASSWORD");
+                    CREATEWIDGETV(mCurrentDialog, ChangePasswordDialog,
+                        loginData);
+                    mCurrentDialog->setVisible(Visible_true);
+                    BLOCK_END("Client::gameExec State::CHANGEPASSWORD")
+                    break;
+
+                case State::CHANGEPASSWORD_ATTEMPT:
+                    BLOCK_START("Client::gameExec "
+                        "State::CHANGEPASSWORD_ATTEMPT")
+                    logger->log1("State: CHANGE PASSWORD ATTEMPT");
+                    if (loginHandler != nullptr)
+                    {
+                        loginHandler->changePassword(loginData.password,
+                            loginData.newPassword);
+                    }
+                    BLOCK_END("Client::gameExec State::CHANGEPASSWORD_ATTEMPT")
+                    break;
+
+                case State::CHANGEPASSWORD_SUCCESS:
+                    BLOCK_START("Client::gameExec "
+                        "State::CHANGEPASSWORD_SUCCESS")
+                    logger->log1("State: CHANGE PASSWORD SUCCESS");
+                    CREATEWIDGETV(mCurrentDialog, OkDialog,
+                        // TRANSLATORS: password change message header
+                        _("Password Change"),
+                        // TRANSLATORS: password change message text
+                        _("Password changed successfully!"),
+                        // TRANSLATORS: ok dialog button
+                        _("OK"),
+                        DialogType::ERROR,
+                        Modal_true,
+                        ShowCenter_true,
+                        nullptr,
+                        260);
+                    mCurrentDialog->addActionListener(&accountListener);
+                    mCurrentDialog = nullptr;  // OkDialog deletes itself
+                    loginData.password = loginData.newPassword;
+                    loginData.newPassword.clear();
+                    BLOCK_END("Client::gameExec State::CHANGEPASSWORD_SUCCESS")
+                    break;
+
+                case State::CHANGEEMAIL:
+                    logger->log1("State: CHANGE EMAIL");
+                    CREATEWIDGETV(mCurrentDialog,
+                        ChangeEmailDialog,
+                        loginData);
+                    mCurrentDialog->setVisible(Visible_true);
+                    break;
+
+                case State::CHANGEEMAIL_ATTEMPT:
+                    logger->log1("State: CHANGE EMAIL ATTEMPT");
+                    if (loginHandler != nullptr)
+                        loginHandler->changeEmail(loginData.email);
+                    break;
+
+                case State::CHANGEEMAIL_SUCCESS:
+                    logger->log1("State: CHANGE EMAIL SUCCESS");
+                    CREATEWIDGETV(mCurrentDialog, OkDialog,
+                        // TRANSLATORS: email change message header
+                        _("Email Change"),
+                        // TRANSLATORS: email change message text
+                        _("Email changed successfully!"),
+                        // TRANSLATORS: ok dialog button
+                        _("OK"),
+                        DialogType::ERROR,
+                        Modal_true,
+                        ShowCenter_true,
+                        nullptr,
+                        260);
+                    mCurrentDialog->addActionListener(&accountListener);
+                    mCurrentDialog = nullptr;  // OkDialog deletes itself
+                    break;
+
+                case State::SWITCH_SERVER:
+                    BLOCK_START("Client::gameExec State::SWITCH_SERVER")
+                    logger->log1("State: SWITCH SERVER");
+
+                    if (loginHandler != nullptr)
+                        loginHandler->disconnect();
+                    if (gameHandler != nullptr)
+                    {
+                        gameHandler->disconnect();
+                        gameHandler->clear();
+                    }
+                    settings.serverName.clear();
+                    settings.login.clear();
+                    WindowManager::updateTitle();
+                    serverConfig.write();
+                    serverConfig.unload();
+                    if (setupWindow != nullptr)
+                        setupWindow->externalUnload();
+
+                    mState = State::CHOOSE_SERVER;
+                    BLOCK_END("Client::gameExec State::SWITCH_SERVER")
+                    break;
+
+                case State::SWITCH_LOGIN:
+                    BLOCK_START("Client::gameExec State::SWITCH_LOGIN")
+                    logger->log1("State: SWITCH LOGIN");
+
+                    if (loginHandler != nullptr)
+                    {
+                        loginHandler->logout();
+                        loginHandler->disconnect();
+                    }
+                    if (gameHandler != nullptr)
+                        gameHandler->disconnect();
+                    if (loginHandler != nullptr)
+                        loginHandler->connect();
+
+                    settings.login.clear();
+                    WindowManager::updateTitle();
+                    mState = State::LOGIN;
+                    BLOCK_END("Client::gameExec State::SWITCH_LOGIN")
+                    break;
+
+                case State::SWITCH_CHARACTER:
+                    BLOCK_START("Client::gameExec State::SWITCH_CHARACTER")
+                    logger->log1("State: SWITCH CHARACTER");
+
+                    // Done with game
+                    if (gameHandler != nullptr)
+                        gameHandler->disconnect();
+
+                    settings.login.clear();
+                    WindowManager::updateTitle();
+                    mState = State::GET_CHARACTERS;
+                    BLOCK_END("Client::gameExec State::SWITCH_CHARACTER")
+                    break;
+
+                case State::LOGOUT_ATTEMPT:
+                    logger->log1("State: LOGOUT ATTEMPT");
+                    break;
+
+                case State::WAIT:
+                    logger->log1("State: WAIT");
+                    break;
+
+                case State::EXIT:
+                    BLOCK_START("Client::gameExec State::EXIT")
+                    logger->log1("State: EXIT");
+                    Net::unload();
+                    BLOCK_END("Client::gameExec State::EXIT")
+                    break;
+
+                case State::FORCE_QUIT:
+                    BLOCK_START("Client::gameExec State::FORCE_QUIT")
+                    logger->log1("State: FORCE QUIT");
+                    if (generalHandler != nullptr)
+                        generalHandler->unload();
+                    mState = State::EXIT;
+                    BLOCK_END("Client::gameExec State::FORCE_QUIT")
+                  break;
+
+                case State::ERROR:
+                    BLOCK_START("Client::gameExec State::ERROR")
+                    config.write();
+                    if (mOldState == State::GAME)
+                        serverConfig.write();
+                    logger->log1("State: ERROR");
+                    logger->log("Error: %s\n", errorMessage.c_str());
+                    mCurrentDialog = DialogsManager::openErrorDialog(
+                        // TRANSLATORS: error message header
+                        _("Error"),
+                        errorMessage,
+                        Modal_true);
+                    mCurrentDialog->addActionListener(&errorListener);
+                    mCurrentDialog = nullptr;  // OkDialog deletes itself
+                    gameHandler->disconnect();
+                    BLOCK_END("Client::gameExec State::ERROR")
+                    break;
+
+                case State::AUTORECONNECT_SERVER:
+                    // ++++++
+                    break;
+
+                case State::START:
+                default:
+                    mState = State::FORCE_QUIT;
+                    break;
+            }
+            BLOCK_END("Client::gameExec 8")
+        }
+        PROFILER_END();
+    }
+
+    return 0;
+}
+
+void Client::optionChanged(const std::string &name)
+{
+    if (name == "fpslimit")
+    {
+        const int fpsLimit = config.getIntValue("fpslimit");
+        settings.limitFps = fpsLimit > 0;
+        WindowManager::setFramerate(fpsLimit);
+    }
+    else if (name == "guialpha" ||
+             name == "enableGuiOpacity")
+    {
+        const float alpha = config.getFloatValue("guialpha");
+        settings.guiAlpha = alpha;
+        ImageHelper::setEnableAlpha(alpha != 1.0F &&
+            config.getBoolValue("enableGuiOpacity"));
+    }
+    else if (name == "gamma" ||
+             name == "enableGamma")
+    {
+        WindowManager::applyGamma();
+    }
+    else if (name == "particleEmitterSkip")
+    {
+        ParticleEngine::emitterSkip =
+            config.getIntValue("particleEmitterSkip") + 1;
+    }
+    else if (name == "vsync")
+    {
+        WindowManager::applyVSync();
+    }
+    else if (name == "repeateInterval" ||
+             name == "repeateDelay")
+    {
+        WindowManager::applyKeyRepeat();
+    }
+}
+
+void Client::action(const ActionEvent &event)
+{
+    std::string tab;
+    const std::string &eventId = event.getId();
+
+    if (eventId == "close")
+    {
+        setState(State::FORCE_QUIT);
+        return;
+    }
+    if (eventId == "Setup")
+    {
+        tab.clear();
+    }
+    else if (eventId == "help")
+    {
+        inputManager.executeAction(InputAction::WINDOW_HELP);
+        return;
+    }
+    else if (eventId == "about")
+    {
+        inputManager.executeAction(InputAction::WINDOW_ABOUT);
+        return;
+    }
+    else if (eventId == "Video")
+    {
+        tab = "Video";
+    }
+    else if (eventId == "Themes")
+    {
+        tab = "Theme";
+    }
+    else if (eventId == "Perfomance")
+    {
+        tab = "Perfomance";
+    }
+    else
+    {
+        return;
+    }
+
+    if (setupWindow != nullptr)
+    {
+        setupWindow->setVisible(fromBool(
+            !setupWindow->isWindowVisible(), Visible));
+        if (setupWindow->isWindowVisible())
+        {
+            if (!tab.empty())
+                setupWindow->activateTab(tab);
+            setupWindow->requestMoveToTop();
+        }
+    }
+}
+
+void Client::initFeatures()
+{
+    features.init(paths.getStringValue("featuresFile"),
+        UseVirtFs_true,
+        SkipError_true);
+    setFeaturesDefaults(features);
+    settings.fixDeadAnimation = features.getBoolValue("fixDeadAnimation");
+}
+
+void Client::initPaths()
+{
+    settings.gmCommandSymbol = paths.getStringValue("gmCommandSymbol");
+    settings.gmCharCommandSymbol = paths.getStringValue("gmCharCommandSymbol");
+    settings.linkCommandSymbol = paths.getStringValue("linkCommandSymbol");
+    if (settings.linkCommandSymbol.empty())
+        settings.linkCommandSymbol = "=";
+    settings.overweightPercent = paths.getIntValue("overweightPercent");
+    settings.playerNameOffset = paths.getIntValue(
+        "playerNameOffset");
+    settings.playerBadgeAtRightOffset = paths.getIntValue(
+        "playerBadgeAtRightOffset");
+    settings.unknownSkillsAutoTab = paths.getBoolValue("unknownSkillsAutoTab");
+    settings.enableNewMailSystem = paths.getBoolValue("enableNewMailSystem");
+}
+
+void Client::initTradeFilter()
+{
+    const std::string tradeListName =
+        settings.serverConfigDir + "/tradefilter.txt";
+
+    std::ofstream tradeFile;
+    struct stat statbuf;
+
+    if ((stat(tradeListName.c_str(), &statbuf) != 0) ||
+        !S_ISREG(statbuf.st_mode))
+    {
+        tradeFile.open(tradeListName.c_str(),
+            std::ios::out);
+        if (tradeFile.is_open())
+        {
+            tradeFile << ": sell" << std::endl;
+            tradeFile << ": buy" << std::endl;
+            tradeFile << ": trade" << std::endl;
+            tradeFile << "i sell" << std::endl;
+            tradeFile << "i buy" << std::endl;
+            tradeFile << "i trade" << std::endl;
+            tradeFile << "i trading" << std::endl;
+            tradeFile << "i am buy" << std::endl;
+            tradeFile << "i am sell" << std::endl;
+            tradeFile << "i am trade" << std::endl;
+            tradeFile << "i am trading" << std::endl;
+            tradeFile << "i'm buy" << std::endl;
+            tradeFile << "i'm sell" << std::endl;
+            tradeFile << "i'm trade" << std::endl;
+            tradeFile << "i'm trading" << std::endl;
+        }
+        else
+        {
+            reportAlways("Error opening file for writing: %s",
+                tradeListName.c_str());
+        }
+        tradeFile.close();
+    }
+}
+
+bool Client::isTmw()
+{
+    const std::string &name = settings.serverName;
+    if (name == "server.themanaworld.org" ||
+        name == "themanaworld.org" ||
+        name == "167.114.129.72")
+    {
+        return true;
+    }
+    return false;
+}
+
+void Client::moveButtons(const int width)
+{
+    if (mSetupButton != nullptr)
+    {
+        int x = width - mSetupButton->getWidth() - mButtonPadding;
+        mSetupButton->setPosition(x, mButtonPadding);
+#ifndef WIN32
+        x -= mPerfomanceButton->getWidth() + mButtonSpacing;
+        mPerfomanceButton->setPosition(x, mButtonPadding);
+
+        x -= mVideoButton->getWidth() + mButtonSpacing;
+        mVideoButton->setPosition(x, mButtonPadding);
+
+        x -= mThemesButton->getWidth() + mButtonSpacing;
+        mThemesButton->setPosition(x, mButtonPadding);
+
+        x -= mAboutButton->getWidth() + mButtonSpacing;
+        mAboutButton->setPosition(x, mButtonPadding);
+
+        x -= mHelpButton->getWidth() + mButtonSpacing;
+        mHelpButton->setPosition(x, mButtonPadding);
+#ifdef ANDROID
+        x -= mCloseButton->getWidth() + mButtonSpacing;
+        mCloseButton->setPosition(x, mButtonPadding);
+#endif  // ANDROID
+#endif  // WIN32
+    }
+}
+
+void Client::windowRemoved(const Window *const window)
+{
+    if (mCurrentDialog == window)
+        mCurrentDialog = nullptr;
+}
+
+void Client::logVars()
+{
+#ifdef ANDROID
+    logger->log("APPDIR: %s", getenv("APPDIR"));
+    logger->log("DATADIR2: %s", getSdStoragePath().c_str());
+#endif  // ANDROID
+}
+
+void Client::slowLogic()
+{
+    if ((gameHandler == nullptr) ||
+        !gameHandler->mustPing())
+    {
+        return;
+    }
+
+    if (get_elapsed_time1(mPing) > 1500)
+    {
+        mPing = tick_time;
+        if (mState == State::UPDATE ||
+            mState == State::LOGIN ||
+            mState == State::LOGIN_ATTEMPT ||
+            mState == State::REGISTER ||
+            mState == State::REGISTER_ATTEMPT)
+        {
+            if (loginHandler != nullptr)
+                loginHandler->ping();
+            if (generalHandler != nullptr)
+                generalHandler->flushSend();
+        }
+        else if (mState == State::CHAR_SELECT)
+        {
+            if (charServerHandler != nullptr)
+                charServerHandler->ping();
+            if (generalHandler != nullptr)
+                generalHandler->flushSend();
+        }
+    }
+}
+
+void Client::loadData()
+{
+    // If another data path has been set,
+    // we don't load any other files...
+    if (settings.options.dataPath.empty())
+    {
+        // Add customdata directory
+        VirtFs::searchAndAddArchives(
+            "customdata/",
+            "zip",
+            Append_false);
+    }
+
+    if (!settings.options.skipUpdate)
+    {
+        VirtFs::searchAndAddArchives(
+            settings.updatesDir + "/local/",
+            "zip",
+            Append_false);
+
+        VirtFs::mountDir(pathJoin(
+            settings.localDataDir,
+            settings.updatesDir,
+            "local/"),
+            Append_false);
+    }
+
+    logger->log("Init paths");
+    paths.init("paths.xml", UseVirtFs_true);
+    setPathsDefaults(paths);
+    initPaths();
+    if (SpriteReference::Empty == nullptr)
+    {
+        SpriteReference::Empty = new SpriteReference(
+            paths.getStringValue("spriteErrorFile"),
+            0);
+    }
+
+    if (BeingInfo::unknown == nullptr)
+        BeingInfo::unknown = new BeingInfo;
+
+    initFeatures();
+    TranslationManager::loadCurrentLang();
+    TranslationManager::loadDictionaryLang();
+    PlayerInfo::stateChange(mState);
+
+    delete spellManager;
+    spellManager = new SpellManager;
+    delete spellShortcut;
+    spellShortcut = new SpellShortcut;
+
+    AttributesEnum::init();
+    DbManager::loadDb();
+    EquipmentWindow::prepareSlotNames();
+
+    ActorSprite::load();
+
+    if (desktop != nullptr)
+        desktop->reloadWallpaper();
+}
+
+void Client::unloadData()
+{
+    DbManager::unloadDb();
+    mCurrentServer.supportUrl.clear();
+    settings.supportUrl.clear();
+    if (settings.options.dataPath.empty())
+    {
+        // Add customdata directory
+        VirtFs::searchAndRemoveArchives(
+            "customdata/",
+            "zip");
+    }
+
+    if (!settings.oldUpdates.empty())
+    {
+        UpdaterWindow::unloadUpdates(settings.oldUpdates);
+        settings.oldUpdates.clear();
+    }
+
+    if (!settings.options.skipUpdate)
+    {
+        VirtFs::searchAndRemoveArchives(
+            pathJoin(settings.updatesDir, "local/"),
+            "zip");
+
+        VirtFs::unmountDirSilent(pathJoin(
+            settings.localDataDir,
+            settings.updatesDir,
+            "local/"));
+    }
+
+    ResourceManager::clearCache();
+
+    loginData.clearUpdateHost();
+    serverVersion = 0;
+    packetVersion = 0;
+    tmwServerVersion = 0;
+    evolPacketOffset = 0;
+}
+
+void Client::runValidate()
+{
+    loadData();
+    WindowManager::createValidateWindows();
+
+    WindowManager::deleteValidateWindows();
+    unloadData();
+    delete2(client);
+    VirtFs::deinit();
+    exit(0);
+}
diff --git a/src/progs/manaplus/client.h b/src/progs/manaplus/client.h
new file mode 100644
index 000000000..af537bb68
--- /dev/null
+++ b/src/progs/manaplus/client.h
@@ -0,0 +1,167 @@
+/*
+ *  The ManaPlus Client
+ *  Copyright (C) 2004-2009  The Mana World Development Team
+ *  Copyright (C) 2009-2010  The Mana Developers
+ *  Copyright (C) 2011-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/>.
+ */
+
+#ifndef PROGS_MANAPLUS_CLIENT_H
+#define PROGS_MANAPLUS_CLIENT_H
+
+#include "enums/state.h"
+
+#include "listeners/actionlistener.h"
+#include "listeners/configlistener.h"
+
+#include "net/serverinfo.h"
+
+#include "localconsts.h"
+
+class Button;
+class Game;
+class LoginData;
+class Skin;
+class Window;
+class QuitDialog;
+
+extern bool isSafeMode;
+extern int serverVersion;
+extern unsigned int tmwServerVersion;
+extern time_t start_time;
+extern int textures_count;
+
+extern std::string errorMessage;
+extern LoginData loginData;
+
+/**
+ * The core part of the client. This class initializes all subsystems, runs
+ * the event loop, and shuts everything down again.
+ */
+class Client final : public ConfigListener,
+                     public ActionListener
+{
+    public:
+        Client();
+
+        A_DELETE_COPY(Client)
+
+        ~Client();
+
+        void gameInit();
+
+        void testsInit();
+
+        int gameExec();
+
+        static int testsExec();
+
+        void setState(const StateT state)
+        { mState = state; }
+
+        StateT getState() const noexcept2 A_WARN_UNUSED
+        { return mState; }
+
+        static bool isTmw() A_WARN_UNUSED;
+
+        void optionChanged(const std::string &name) override final;
+
+        void action(const ActionEvent &event) override final;
+
+        static void initTradeFilter();
+
+        void moveButtons(const int width);
+
+        void windowRemoved(const Window *const window);
+
+        void slowLogic();
+
+        ServerInfo &getCurrentServer()
+        { return mCurrentServer; }
+
+    private:
+        void initSoundManager();
+
+        void initConfigListeners();
+
+        static void initGraphics();
+
+        static void initFeatures();
+
+        static void initPaths();
+
+        void gameClear();
+
+        void testsClear();
+
+#ifdef ANDROID
+        static void logVars();
+#else  // ANDROID
+
+        static void logVars() A_CONST;
+#endif  // ANDROID
+
+        void stateConnectGame1();
+
+        void stateConnectServer1();
+
+        void stateWorldSelect1();
+
+        void stateGame1();
+
+        void stateSwitchLogin1();
+
+        void loadData();
+
+        void unloadData();
+
+        void runValidate()
+#ifndef BAD_CILKPLUS
+        __attribute__ ((noreturn))
+#endif  // BAD_CILKPLUS
+;
+
+        ServerInfo mCurrentServer;
+
+        Game *mGame;
+        Window *mCurrentDialog;
+        QuitDialog *mQuitDialog;
+        Button *mSetupButton;
+        Button *mVideoButton;
+        Button *mHelpButton;
+        Button *mAboutButton;
+        Button *mThemesButton;
+        Button *mPerfomanceButton;
+#ifdef ANDROID
+        Button *mCloseButton;
+#endif  // ANDROID
+
+        StateT mState;
+        StateT mOldState;
+
+        Skin *mSkin;
+        int mButtonPadding;
+        int mButtonSpacing;
+        int mPing;
+        bool mConfigAutoSaved;
+};
+
+extern Client *client;
+extern unsigned int mLastHost;
+extern unsigned long mSearchHash;
+
+#endif  // PROGS_MANAPLUS_CLIENT_H
diff --git a/src/progs/manaplus/gui/viewport.cpp b/src/progs/manaplus/gui/viewport.cpp
new file mode 100644
index 000000000..de7571c7c
--- /dev/null
+++ b/src/progs/manaplus/gui/viewport.cpp
@@ -0,0 +1,1148 @@
+/*
+ *  The ManaPlus Client
+ *  Copyright (C) 2004-2009  The Mana World Development Team
+ *  Copyright (C) 2009-2010  The Mana Developers
+ *  Copyright (C) 2011-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 "progs/manaplus/gui/viewport.h"
+
+#include "actormanager.h"
+#include "configuration.h"
+#include "game.h"
+#include "settings.h"
+#include "sdlshared.h"
+#include "textmanager.h"
+
+#include "being/flooritem.h"
+#include "being/localplayer.h"
+#include "being/playerinfo.h"
+
+#include "enums/resources/map/blockmask.h"
+#include "enums/resources/map/mapitemtype.h"
+
+#include "gui/gui.h"
+#include "gui/popupmanager.h"
+#include "gui/userpalette.h"
+
+#include "gui/fonts/font.h"
+
+#include "gui/popups/beingpopup.h"
+#include "gui/popups/popupmenu.h"
+#include "gui/popups/textpopup.h"
+
+#include "gui/windows/ministatuswindow.h"
+
+#include "input/inputmanager.h"
+
+#include "utils/checkutils.h"
+#include "utils/foreach.h"
+
+#include "resources/map/map.h"
+#include "resources/map/mapitem.h"
+#include "resources/map/speciallayer.h"
+
+#include "debug.h"
+
+Viewport *viewport = nullptr;
+
+extern volatile int tick_time;
+
+Viewport::Viewport() :
+    WindowContainer(nullptr),
+    MouseListener(),
+    ConfigListener(),
+    mMouseX(0),
+    mMouseY(0),
+    mMap(nullptr),
+    mHoverBeing(nullptr),
+    mHoverItem(nullptr),
+    mHoverSign(nullptr),
+    mScrollRadius(config.getIntValue("ScrollRadius")),
+    mScrollLaziness(config.getIntValue("ScrollLaziness")),
+    mScrollCenterOffsetX(config.getIntValue("ScrollCenterOffsetX")),
+    mScrollCenterOffsetY(config.getIntValue("ScrollCenterOffsetY")),
+    mMousePressX(0),
+    mMousePressY(0),
+    mPixelViewX(0),
+    mPixelViewY(0),
+    mMidTileX(0),
+    mMidTileY(0),
+    mViewXmax(0),
+    mViewYmax(0),
+    mLocalWalkTime(-1),
+    mCameraRelativeX(0),
+    mCameraRelativeY(0),
+    mShowBeingPopup(config.getBoolValue("showBeingPopup")),
+    mSelfMouseHeal(config.getBoolValue("selfMouseHeal")),
+    mEnableLazyScrolling(config.getBoolValue("enableLazyScrolling")),
+    mMouseDirectionMove(config.getBoolValue("mouseDirectionMove")),
+    mLongMouseClick(config.getBoolValue("longmouseclick")),
+    mAllowMoveByMouse(config.getBoolValue("allowMoveByMouse")),
+    mMouseClicked(false),
+    mPlayerFollowMouse(false)
+{
+    setOpaque(Opaque_false);
+    addMouseListener(this);
+
+    config.addListener("ScrollLaziness", this);
+    config.addListener("ScrollRadius", this);
+    config.addListener("showBeingPopup", this);
+    config.addListener("selfMouseHeal", this);
+    config.addListener("enableLazyScrolling", this);
+    config.addListener("mouseDirectionMove", this);
+    config.addListener("longmouseclick", this);
+    config.addListener("allowMoveByMouse", this);
+
+    setFocusable(true);
+    updateMidVars();
+}
+
+Viewport::~Viewport()
+{
+    config.removeListeners(this);
+    CHECKLISTENERS
+}
+
+void Viewport::setMap(Map *const map)
+{
+    if ((mMap != nullptr) && (map != nullptr))
+        map->setDrawLayersFlags(mMap->getDrawLayersFlags());
+    mMap = map;
+    updateMaxVars();
+}
+
+void Viewport::draw(Graphics *const graphics)
+{
+    BLOCK_START("Viewport::draw 1")
+    static int lastTick = tick_time;
+
+    if ((mMap == nullptr) || (localPlayer == nullptr))
+    {
+        graphics->setColor(Color(64, 64, 64));
+        graphics->fillRectangle(
+                Rect(0, 0, getWidth(), getHeight()));
+        BLOCK_END("Viewport::draw 1")
+        return;
+    }
+
+    // Avoid freaking out when tick_time overflows
+    if (tick_time < lastTick)
+        lastTick = tick_time;
+
+    // Calculate viewpoint
+
+    const int player_x = localPlayer->mPixelX - mMidTileX;
+    const int player_y = localPlayer->mPixelY - mMidTileY;
+
+    if (mScrollLaziness < 1)
+        mScrollLaziness = 1;  // Avoids division by zero
+
+    if (mEnableLazyScrolling)
+    {
+        int cnt = 0;
+
+        // Apply lazy scrolling
+        while (lastTick < tick_time && cnt < mapTileSize)
+        {
+            if (player_x > mPixelViewX + mScrollRadius)
+            {
+                mPixelViewX += CAST_S32(
+                    static_cast<float>(player_x
+                    - mPixelViewX - mScrollRadius) /
+                    static_cast<float>(mScrollLaziness));
+            }
+            if (player_x < mPixelViewX - mScrollRadius)
+            {
+                mPixelViewX += CAST_S32(
+                    static_cast<float>(player_x
+                    - mPixelViewX + mScrollRadius) /
+                    static_cast<float>(mScrollLaziness));
+            }
+            if (player_y > mPixelViewY + mScrollRadius)
+            {
+                mPixelViewY += CAST_S32(
+                    static_cast<float>(player_y
+                    - mPixelViewY - mScrollRadius) /
+                    static_cast<float>(mScrollLaziness));
+            }
+            if (player_y < mPixelViewY - mScrollRadius)
+            {
+                mPixelViewY += CAST_S32(
+                    static_cast<float>(player_y
+                    - mPixelViewY + mScrollRadius) /
+                    static_cast<float>(mScrollLaziness));
+            }
+            lastTick ++;
+            cnt ++;
+        }
+
+        // Auto center when player is off screen
+        if (cnt > 30 || player_x - mPixelViewX
+            > graphics->mWidth / 2 || mPixelViewX
+            - player_x > graphics->mWidth / 2 || mPixelViewY
+            - player_y > graphics->getHeight() / 2 ||  player_y
+            - mPixelViewY > graphics->getHeight() / 2)
+        {
+            if (player_x <= 0 || player_y <= 0)
+            {
+                logger->log("incorrect player position: %d, %d, %d, %d",
+                    player_x, player_y, mPixelViewX, mPixelViewY);
+                logger->log("tile position: %d, %d",
+                    localPlayer->getTileX(), localPlayer->getTileY());
+            }
+            mPixelViewX = player_x;
+            mPixelViewY = player_y;
+        }
+    }
+    else
+    {
+        mPixelViewX = player_x;
+        mPixelViewY = player_y;
+    }
+
+    if (mPixelViewX < 0)
+        mPixelViewX = 0;
+    if (mPixelViewY < 0)
+        mPixelViewY = 0;
+    if (mPixelViewX > mViewXmax)
+        mPixelViewX = mViewXmax;
+    if (mPixelViewY > mViewYmax)
+        mPixelViewY = mViewYmax;
+
+    // Draw tiles and sprites
+    mMap->draw(graphics, mPixelViewX, mPixelViewY);
+
+    const MapTypeT drawType = settings.mapDrawType;
+    if (drawType != MapType::NORMAL)
+    {
+        if (drawType != MapType::SPECIAL4)
+        {
+            mMap->drawCollision(graphics, mPixelViewX,
+                mPixelViewY, drawType);
+        }
+        if (drawType == MapType::DEBUGTYPE)
+            drawDebugPath(graphics);
+    }
+
+    if (localPlayer->getCheckNameSetting())
+    {
+        localPlayer->setCheckNameSetting(false);
+        localPlayer->setName(localPlayer->getName());
+    }
+
+    // Draw text
+    if (textManager != nullptr)
+        textManager->draw(graphics, mPixelViewX, mPixelViewY);
+
+    // Draw player names, speech, and emotion sprite as needed
+    const ActorSprites &actors = actorManager->getAll();
+    FOR_EACH (ActorSpritesIterator, it, actors)
+    {
+        if ((*it)->getType() == ActorType::FloorItem)
+            continue;
+        Being *const b = static_cast<Being*>(*it);
+        b->drawEmotion(graphics, mPixelViewX, mPixelViewY);
+        b->drawSpeech(mPixelViewX, mPixelViewY);
+    }
+
+    if (miniStatusWindow != nullptr)
+        miniStatusWindow->drawIcons(graphics);
+
+    // Draw contained widgets
+    WindowContainer::draw(graphics);
+    BLOCK_END("Viewport::draw 1")
+}
+
+void Viewport::safeDraw(Graphics *const graphics)
+{
+    Viewport::draw(graphics);
+}
+
+void Viewport::logic()
+{
+    BLOCK_START("Viewport::logic")
+    // Make the player follow the mouse position
+    // if the mouse is dragged elsewhere than in a window.
+    Gui::getMouseState(mMouseX, mMouseY);
+    BLOCK_END("Viewport::logic")
+}
+
+void Viewport::followMouse()
+{
+    if (gui == nullptr)
+        return;
+    const MouseStateType button = Gui::getMouseState(mMouseX, mMouseY);
+    // If the left button is dragged
+    if (mPlayerFollowMouse && ((button & SDL_BUTTON(1)) != 0))
+    {
+        // We create a mouse event and send it to mouseDragged.
+        const MouseEvent event(nullptr,
+            MouseEventType::DRAGGED,
+            MouseButton::LEFT,
+            mMouseX,
+            mMouseY,
+            0);
+
+        walkByMouse(event);
+    }
+}
+
+void Viewport::drawDebugPath(Graphics *const graphics)
+{
+    if (localPlayer == nullptr ||
+        userPalette == nullptr ||
+        actorManager == nullptr ||
+        mMap == nullptr ||
+        gui == nullptr)
+    {
+        return;
+    }
+
+    Gui::getMouseState(mMouseX, mMouseY);
+
+    static Path debugPath;
+    static Vector lastMouseDestination = Vector(0.0F, 0.0F);
+    const int mousePosX = mMouseX + mPixelViewX;
+    const int mousePosY = mMouseY + mPixelViewY;
+    Vector mouseDestination(mousePosX, mousePosY);
+
+    if (mouseDestination.x != lastMouseDestination.x
+        || mouseDestination.y != lastMouseDestination.y)
+    {
+        debugPath = mMap->findPath(
+            CAST_S32(localPlayer->mPixelX - mapTileSize / 2) / mapTileSize,
+            CAST_S32(localPlayer->mPixelY - mapTileSize) / mapTileSize,
+            mousePosX / mapTileSize,
+            mousePosY / mapTileSize,
+            localPlayer->getBlockWalkMask(),
+            500);
+        lastMouseDestination = mouseDestination;
+    }
+    drawPath(graphics, debugPath, userPalette->getColorWithAlpha(
+        UserColorId::ROAD_POINT));
+
+    const ActorSprites &actors = actorManager->getAll();
+    FOR_EACH (ActorSpritesConstIterator, it, actors)
+    {
+        const Being *const being = dynamic_cast<const Being*>(*it);
+        if ((being != nullptr) && being != localPlayer)
+        {
+            const Path &beingPath = being->getPath();
+            drawPath(graphics, beingPath, userPalette->getColorWithAlpha(
+                UserColorId::ROAD_POINT));
+        }
+    }
+}
+
+void Viewport::drawPath(Graphics *const graphics,
+                        const Path &path,
+                        const Color &color) const
+{
+    graphics->setColor(color);
+    Font *const font = getFont();
+
+    int cnt = 1;
+    FOR_EACH (Path::const_iterator, i, path)
+    {
+        const int squareX = i->x * mapTileSize - mPixelViewX + 12;
+        const int squareY = i->y * mapTileSize - mPixelViewY + 12;
+
+        graphics->fillRectangle(Rect(squareX, squareY, 8, 8));
+        if (mMap != nullptr)
+        {
+            const std::string str = toString(cnt);
+            font->drawString(graphics,
+                color, color,
+                str,
+                squareX + 4 - font->getWidth(str) / 2,
+                squareY + 12);
+        }
+        cnt ++;
+    }
+}
+
+bool Viewport::openContextMenu(const MouseEvent &event)
+{
+    mPlayerFollowMouse = false;
+    const int eventX = event.getX();
+    const int eventY = event.getY();
+    if (popupMenu == nullptr)
+        return false;
+    if (mHoverBeing != nullptr)
+    {
+        validateSpeed();
+        if (actorManager != nullptr)
+        {
+            STD_VECTOR<ActorSprite*> beings;
+            const int x = mMouseX + mPixelViewX;
+            const int y = mMouseY + mPixelViewY;
+            actorManager->findBeingsByPixel(beings, x, y, AllPlayers_true);
+            if (beings.size() > 1)
+                popupMenu->showPopup(eventX, eventY, beings);
+            else
+                popupMenu->showPopup(eventX, eventY, mHoverBeing);
+            return true;
+        }
+    }
+    else if (mHoverItem != nullptr)
+    {
+        validateSpeed();
+        popupMenu->showPopup(eventX, eventY, mHoverItem);
+        return true;
+    }
+    else if (mHoverSign != nullptr)
+    {
+        validateSpeed();
+        popupMenu->showPopup(eventX, eventY, mHoverSign);
+        return true;
+    }
+    else if (settings.cameraMode != 0u)
+    {
+        if (mMap == nullptr)
+            return false;
+        popupMenu->showMapPopup(eventX, eventY,
+            (mMouseX + mPixelViewX) / mMap->getTileWidth(),
+            (mMouseY + mPixelViewY) / mMap->getTileHeight(),
+            false);
+        return true;
+    }
+    return false;
+}
+
+bool Viewport::leftMouseAction()
+{
+    const bool stopAttack = inputManager.isActionActive(
+        InputAction::STOP_ATTACK);
+    // Interact with some being
+    if (mHoverBeing != nullptr)
+    {
+        if (!mHoverBeing->isAlive())
+            return true;
+
+        if (mHoverBeing->canTalk())
+        {
+            validateSpeed();
+            mHoverBeing->talkTo();
+            return true;
+        }
+
+        const ActorTypeT type = mHoverBeing->getType();
+        switch (type)
+        {
+            case ActorType::Player:
+                validateSpeed();
+                if (actorManager != nullptr)
+                {
+#ifdef TMWA_SUPPORT
+                    if (localPlayer != mHoverBeing || mSelfMouseHeal)
+                        actorManager->heal(mHoverBeing);
+#endif  // TMWA_SUPPORT
+
+                    if (localPlayer == mHoverBeing &&
+                        mHoverItem != nullptr)
+                    {
+                        localPlayer->pickUp(mHoverItem);
+                    }
+                    return true;
+                }
+                break;
+            case ActorType::Monster:
+            case ActorType::Npc:
+            case ActorType::SkillUnit:
+                if (!stopAttack)
+                {
+                    if (localPlayer->withinAttackRange(mHoverBeing) ||
+                        inputManager.isActionActive(InputAction::ATTACK))
+                    {
+                        validateSpeed();
+                        if (!mStatsReUpdated && localPlayer != mHoverBeing)
+                        {
+                            localPlayer->attack(mHoverBeing,
+                                !inputManager.isActionActive(
+                                InputAction::STOP_ATTACK));
+                            return true;
+                        }
+                    }
+                    else if (!inputManager.isActionActive(
+                             InputAction::ATTACK))
+                    {
+                        validateSpeed();
+                        if (!mStatsReUpdated && localPlayer != mHoverBeing)
+                        {
+                            localPlayer->setGotoTarget(mHoverBeing);
+                            return true;
+                        }
+                    }
+                }
+                break;
+            case ActorType::FloorItem:
+            case ActorType::Portal:
+            case ActorType::Pet:
+            case ActorType::Mercenary:
+            case ActorType::Homunculus:
+            case ActorType::Elemental:
+                break;
+            case ActorType::Unknown:
+            case ActorType::Avatar:
+            default:
+                reportAlways("Left click on unknown actor type: %d",
+                    CAST_S32(type));
+                break;
+        }
+    }
+    // Picks up a item if we clicked on one
+    if (mHoverItem != nullptr)
+    {
+        validateSpeed();
+        localPlayer->pickUp(mHoverItem);
+    }
+    else if (stopAttack)
+    {
+        if (mMap != nullptr)
+        {
+            const int mouseTileX = (mMouseX + mPixelViewX)
+                / mMap->getTileWidth();
+            const int mouseTileY = (mMouseY + mPixelViewY)
+                / mMap->getTileHeight();
+            inputManager.executeChatCommand(InputAction::PET_MOVE,
+                strprintf("%d %d", mouseTileX, mouseTileY),
+                nullptr);
+        }
+        return true;
+    }
+    // Just walk around
+    else if (!inputManager.isActionActive(InputAction::ATTACK) &&
+             localPlayer->canMove())
+    {
+        validateSpeed();
+        localPlayer->stopAttack();
+        localPlayer->cancelFollow();
+        mPlayerFollowMouse = mAllowMoveByMouse;
+        if (mPlayerFollowMouse)
+        {
+            // Make the player go to the mouse position
+            followMouse();
+        }
+    }
+    return false;
+}
+
+void Viewport::mousePressed(MouseEvent &event)
+{
+    if (event.getSource() != this || event.isConsumed())
+        return;
+
+    // Check if we are alive and kickin'
+    if ((mMap == nullptr) || (localPlayer == nullptr))
+        return;
+
+    // Check if we are busy
+    // if commented, allow context menu if npc dialog open
+    if (PlayerInfo::isTalking())
+    {
+        mMouseClicked = false;
+        return;
+    }
+
+    mMouseClicked = true;
+
+    mMousePressX = event.getX();
+    mMousePressY = event.getY();
+    const MouseButtonT eventButton = event.getButton();
+    const int pixelX = mMousePressX + mPixelViewX;
+    const int pixelY = mMousePressY + mPixelViewY;
+
+    // Right click might open a popup
+    if (eventButton == MouseButton::RIGHT)
+    {
+        if (openContextMenu(event))
+            return;
+    }
+
+    // If a popup is active, just remove it
+    if (PopupManager::isPopupMenuVisible())
+    {
+        mPlayerFollowMouse = false;
+        PopupManager::hidePopupMenu();
+        return;
+    }
+
+    // Left click can cause different actions
+    if (!mLongMouseClick && eventButton == MouseButton::LEFT)
+    {
+        if (leftMouseAction())
+        {
+            mPlayerFollowMouse = false;
+            return;
+        }
+    }
+    else if (eventButton == MouseButton::MIDDLE)
+    {
+        mPlayerFollowMouse = false;
+        validateSpeed();
+        // Find the being nearest to the clicked position
+        if (actorManager != nullptr)
+        {
+            Being *const target = actorManager->findNearestLivingBeing(
+                pixelX, pixelY, 20, ActorType::Monster, nullptr);
+
+            if (target != nullptr)
+                localPlayer->setTarget(target);
+        }
+    }
+}
+
+void Viewport::getMouseTile(int &destX, int &destY) const
+{
+    getMouseTile(mMouseX, mMouseY, destX, destY);
+}
+
+void Viewport::getMouseTile(const int x, const int y,
+                            int &destX, int &destY) const
+{
+    if (mMap == nullptr)
+        return;
+    const int tw = mMap->getTileWidth();
+    const int th = mMap->getTileHeight();
+    destX = CAST_S32(x + mPixelViewX)
+        / static_cast<float>(tw);
+
+    if (mMap->isHeightsPresent())
+    {
+        const int th2 = th / 2;
+        const int clickY = y + mPixelViewY - th2;
+        destY = y + mPixelViewY;
+        int newDiffY = 1000000;
+        const int heightTiles = mainGraphics->mHeight / th;
+        const int tileViewY = mPixelViewY / th;
+        for (int f = tileViewY; f < tileViewY + heightTiles; f ++)
+        {
+            if (!mMap->getWalk(destX,
+                f,
+                BlockMask::WALL |
+                BlockMask::AIR |
+                BlockMask::WATER |
+                BlockMask::PLAYERWALL))
+            {
+                continue;
+            }
+
+            const int offset = mMap->getHeightOffset(
+                destX, f) * th2;
+            const int pixelF = f * th;
+            const int diff = abs(clickY + offset - pixelF);
+            if (diff < newDiffY)
+            {
+                destY = pixelF;
+                newDiffY = diff;
+            }
+        }
+        destY /= 32;
+    }
+    else
+    {
+        destY = CAST_S32((y + mPixelViewY) / static_cast<float>(th));
+    }
+}
+
+void Viewport::walkByMouse(const MouseEvent &event)
+{
+    if ((mMap == nullptr) || (localPlayer == nullptr))
+        return;
+    if (mPlayerFollowMouse
+        && !inputManager.isActionActive(InputAction::STOP_ATTACK)
+        && !inputManager.isActionActive(InputAction::UNTARGET))
+    {
+        if (!mMouseDirectionMove)
+            mPlayerFollowMouse = false;
+        if (mLocalWalkTime != localPlayer->getActionTime())
+        {
+            mLocalWalkTime = cur_time;
+            localPlayer->unSetPickUpTarget();
+            int playerX = localPlayer->getTileX();
+            int playerY = localPlayer->getTileY();
+            if (mMouseDirectionMove)
+            {
+                const int width = mainGraphics->mWidth / 2;
+                const int height = mainGraphics->mHeight / 2;
+                const float wh = static_cast<float>(width)
+                    / static_cast<float>(height);
+                int x = event.getX() - width;
+                int y = event.getY() - height;
+                if ((x == 0) && (y == 0))
+                    return;
+                const int x2 = abs(x);
+                const int y2 = abs(y);
+                const float diff = 2;
+                int dx = 0;
+                int dy = 0;
+                if (x2 > y2)
+                {
+                    if (y2 != 0 &&
+                        static_cast<float>(x2) / static_cast<float>(y2) /
+                        wh > diff)
+                    {
+                        y = 0;
+                    }
+                }
+                else
+                {
+                    if ((x2 != 0) && y2 * wh / x2 > diff)
+                        x = 0;
+                }
+                if (x > 0)
+                    dx = 1;
+                else if (x < 0)
+                    dx = -1;
+                if (y > 0)
+                    dy = 1;
+                else if (y < 0)
+                    dy = -1;
+
+                if (mMap->getWalk(playerX + dx,
+                    playerY + dy,
+                    BlockMask::WALL |
+                    BlockMask::AIR |
+                    BlockMask::WATER |
+                    BlockMask::PLAYERWALL))
+                {
+                    localPlayer->navigateTo(playerX + dx, playerY + dy);
+                }
+                else
+                {
+                    if ((dx != 0) && (dy != 0))
+                    {
+                        // try avoid diagonal collision
+                        if (x2 > y2)
+                        {
+                            if (mMap->getWalk(playerX + dx,
+                                playerY,
+                                BlockMask::WALL |
+                                BlockMask::AIR |
+                                BlockMask::WATER |
+                                BlockMask::PLAYERWALL))
+                            {
+                                dy = 0;
+                            }
+                            else
+                            {
+                                dx = 0;
+                            }
+                        }
+                        else
+                        {
+                            if (mMap->getWalk(playerX,
+                                playerY + dy,
+                                BlockMask::WALL |
+                                BlockMask::AIR |
+                                BlockMask::WATER |
+                                BlockMask::PLAYERWALL))
+                            {
+                                dx = 0;
+                            }
+                            else
+                            {
+                                dy = 0;
+                            }
+                        }
+                    }
+                    else
+                    {
+                        // try avoid vertical or horisontal collision
+                        if (dx == 0)
+                        {
+                            if (mMap->getWalk(playerX + 1,
+                                playerY + dy,
+                                BlockMask::WALL |
+                                BlockMask::AIR |
+                                BlockMask::WATER |
+                                BlockMask::PLAYERWALL))
+                            {
+                                dx = 1;
+                            }
+                            if (mMap->getWalk(playerX - 1,
+                                playerY + dy,
+                                BlockMask::WALL |
+                                BlockMask::AIR |
+                                BlockMask::WATER |
+                                BlockMask::PLAYERWALL))
+                            {
+                                dx = -1;
+                            }
+                        }
+                        if (dy == 0)
+                        {
+                            if (mMap->getWalk(playerX + dx,
+                                playerY + 1,
+                                BlockMask::WALL |
+                                BlockMask::AIR |
+                                BlockMask::WATER |
+                                BlockMask::PLAYERWALL))
+                            {
+                                dy = 1;
+                            }
+                            if (mMap->getWalk(playerX + dx,
+                                playerY - 1,
+                                BlockMask::WALL |
+                                BlockMask::AIR |
+                                BlockMask::WATER |
+                                BlockMask::PLAYERWALL))
+                            {
+                                dy = -1;
+                            }
+                        }
+                    }
+                    localPlayer->navigateTo(playerX + dx, playerY + dy);
+                }
+            }
+            else
+            {
+                int destX;
+                int destY;
+                getMouseTile(event.getX(), event.getY(),
+                    destX, destY);
+                if (playerX != destX || playerY != destY)
+                {
+                    if (!localPlayer->navigateTo(destX, destY))
+                    {
+                        if (playerX > destX)
+                            playerX --;
+                        else if (playerX < destX)
+                            playerX ++;
+                        if (playerY > destY)
+                            playerY --;
+                        else if (playerY < destY)
+                            playerY ++;
+                        if (mMap->getWalk(playerX, playerY, 0))
+                            localPlayer->navigateTo(playerX, playerY);
+                    }
+                }
+            }
+        }
+    }
+}
+
+void Viewport::mouseDragged(MouseEvent &event)
+{
+    if (event.getSource() != this || event.isConsumed())
+    {
+        mPlayerFollowMouse = false;
+        return;
+    }
+    if (mAllowMoveByMouse &&
+        mMouseClicked &&
+        (localPlayer != nullptr) &&
+        localPlayer->canMove())
+    {
+        if (abs(event.getX() - mMousePressX) > 32
+            || abs(event.getY() - mMousePressY) > 32)
+        {
+            mPlayerFollowMouse = true;
+        }
+
+        walkByMouse(event);
+    }
+}
+
+void Viewport::mouseReleased(MouseEvent &event)
+{
+    mPlayerFollowMouse = false;
+    mLocalWalkTime = -1;
+    if (mLongMouseClick && mMouseClicked)
+    {
+        mMouseClicked = false;
+        if (event.getSource() != this || event.isConsumed())
+            return;
+        const MouseButtonT eventButton = event.getButton();
+        if (eventButton == MouseButton::LEFT)
+        {
+            // long button press
+            if ((gui != nullptr) && gui->isLongPress())
+            {
+                if (openContextMenu(event))
+                {
+                    gui->resetClickCount();
+                    return;
+                }
+            }
+            else
+            {
+                if (leftMouseAction())
+                    return;
+            }
+            walkByMouse(event);
+        }
+    }
+}
+
+void Viewport::optionChanged(const std::string &name)
+{
+    if (name == "ScrollLaziness")
+        mScrollLaziness = config.getIntValue("ScrollLaziness");
+    else if (name == "ScrollRadius")
+        mScrollRadius = config.getIntValue("ScrollRadius");
+    else if (name == "showBeingPopup")
+        mShowBeingPopup = config.getBoolValue("showBeingPopup");
+    else if (name == "selfMouseHeal")
+        mSelfMouseHeal = config.getBoolValue("selfMouseHeal");
+    else if (name == "enableLazyScrolling")
+        mEnableLazyScrolling = config.getBoolValue("enableLazyScrolling");
+    else if (name == "mouseDirectionMove")
+        mMouseDirectionMove = config.getBoolValue("mouseDirectionMove");
+    else if (name == "longmouseclick")
+        mLongMouseClick = config.getBoolValue("longmouseclick");
+    else if (name == "allowMoveByMouse")
+        mAllowMoveByMouse = config.getBoolValue("allowMoveByMouse");
+}
+
+void Viewport::mouseMoved(MouseEvent &event)
+{
+    // Check if we are on the map
+    if (mMap == nullptr ||
+        localPlayer == nullptr ||
+        actorManager == nullptr)
+    {
+        return;
+    }
+
+    if (mMouseDirectionMove)
+        mPlayerFollowMouse = false;
+
+    const int x = mMouseX + mPixelViewX;
+    const int y = mMouseY + mPixelViewY;
+
+    ActorTypeT type = ActorType::Unknown;
+    mHoverBeing = actorManager->findBeingByPixel(x, y, AllPlayers_true);
+    if (mHoverBeing != nullptr)
+        type = mHoverBeing->getType();
+    if ((mHoverBeing != nullptr)
+        && (type == ActorType::Player
+        || type == ActorType::Npc
+        || type == ActorType::Homunculus
+        || type == ActorType::Mercenary
+        || type == ActorType::Pet))
+    {
+        PopupManager::hideTextPopup();
+        if (mShowBeingPopup && (beingPopup != nullptr))
+            beingPopup->show(mMouseX, mMouseY, mHoverBeing);
+    }
+    else
+    {
+        PopupManager::hideBeingPopup();
+    }
+
+    mHoverItem = actorManager->findItem(x / mMap->getTileWidth(),
+        y / mMap->getTileHeight());
+
+    if ((mHoverBeing == nullptr) && (mHoverItem == nullptr))
+    {
+        const SpecialLayer *const specialLayer = mMap->getSpecialLayer();
+        if (specialLayer != nullptr)
+        {
+            const int mouseTileX = (mMouseX + mPixelViewX)
+                / mMap->getTileWidth();
+            const int mouseTileY = (mMouseY + mPixelViewY)
+                / mMap->getTileHeight();
+
+            mHoverSign = specialLayer->getTile(mouseTileX, mouseTileY);
+            if (mHoverSign != nullptr &&
+                mHoverSign->getType() != MapItemType::EMPTY)
+            {
+                if (!mHoverSign->getComment().empty())
+                {
+                    PopupManager::hideBeingPopup();
+                    if (textPopup != nullptr)
+                    {
+                        textPopup->show(mMouseX, mMouseY,
+                            mHoverSign->getComment());
+                    }
+                }
+                else
+                {
+                    if (PopupManager::isTextPopupVisible())
+                        PopupManager::hideTextPopup();
+                }
+                gui->setCursorType(Cursor::CURSOR_UP);
+                return;
+            }
+        }
+    }
+    if (!event.isConsumed() &&
+        PopupManager::isTextPopupVisible())
+    {
+        PopupManager::hideTextPopup();
+    }
+
+    if (mHoverBeing != nullptr)
+    {
+        switch (type)
+        {
+            case ActorType::Npc:
+            case ActorType::Monster:
+            case ActorType::Portal:
+            case ActorType::Pet:
+            case ActorType::Mercenary:
+            case ActorType::Homunculus:
+            case ActorType::SkillUnit:
+            case ActorType::Elemental:
+                gui->setCursorType(mHoverBeing->getHoverCursor());
+                break;
+
+            case ActorType::Avatar:
+            case ActorType::FloorItem:
+            case ActorType::Unknown:
+            case ActorType::Player:
+            default:
+                gui->setCursorType(Cursor::CURSOR_POINTER);
+                break;
+        }
+    }
+    // Item mouseover
+    else if (mHoverItem != nullptr)
+    {
+        gui->setCursorType(mHoverItem->getHoverCursor());
+    }
+    else
+    {
+        gui->setCursorType(Cursor::CURSOR_POINTER);
+    }
+}
+
+void Viewport::toggleMapDrawType()
+{
+    settings.mapDrawType = static_cast<MapTypeT>(
+        CAST_S32(settings.mapDrawType) + 1);
+    if (settings.mapDrawType > MapType::BLACKWHITE)
+        settings.mapDrawType = MapType::NORMAL;
+    if (mMap != nullptr)
+        mMap->setDrawLayersFlags(settings.mapDrawType);
+}
+
+void Viewport::toggleCameraMode()
+{
+    settings.cameraMode ++;
+    if (settings.cameraMode > 1)
+        settings.cameraMode = 0;
+    if (settings.cameraMode == 0u)
+    {
+        mCameraRelativeX = 0;
+        mCameraRelativeY = 0;
+        updateMidVars();
+    }
+    UpdateStatusListener::distributeEvent();
+}
+
+void Viewport::clearHover(const ActorSprite *const actor)
+{
+    if (mHoverBeing == actor)
+        mHoverBeing = nullptr;
+
+    if (mHoverItem == actor)
+        mHoverItem = nullptr;
+}
+
+void Viewport::cleanHoverItems()
+{
+    mHoverBeing = nullptr;
+    mHoverItem = nullptr;
+    mHoverSign = nullptr;
+}
+
+void Viewport::moveCamera(const int dx, const int dy)
+{
+    mCameraRelativeX += dx;
+    mCameraRelativeY += dy;
+    updateMidVars();
+}
+
+void Viewport::moveCameraToActor(const BeingId actorId,
+                                 const int x, const int y)
+{
+    if ((localPlayer == nullptr) || (actorManager == nullptr))
+        return;
+
+    const Actor *const actor = actorManager->findBeing(actorId);
+    if (actor == nullptr)
+        return;
+    settings.cameraMode = 1;
+    mCameraRelativeX = actor->mPixelX - localPlayer->mPixelX + x;
+    mCameraRelativeY = actor->mPixelY - localPlayer->mPixelY + y;
+    updateMidVars();
+}
+
+void Viewport::moveCameraToPosition(const int x, const int y)
+{
+    if (localPlayer == nullptr)
+        return;
+
+    settings.cameraMode = 1;
+    mCameraRelativeX = x - localPlayer->mPixelX;
+    mCameraRelativeY = y - localPlayer->mPixelY;
+    updateMidVars();
+}
+
+void Viewport::moveCameraRelative(const int x, const int y)
+{
+    settings.cameraMode = 1;
+    mCameraRelativeX += x;
+    mCameraRelativeY += y;
+    updateMidVars();
+}
+
+void Viewport::returnCamera()
+{
+    settings.cameraMode = 0;
+    mCameraRelativeX = 0;
+    mCameraRelativeY = 0;
+    updateMidVars();
+}
+
+void Viewport::validateSpeed()
+{
+    if (!inputManager.isActionActive(InputAction::TARGET_ATTACK) &&
+        !inputManager.isActionActive(InputAction::ATTACK))
+    {
+        if (Game::instance() != nullptr)
+            Game::instance()->setValidSpeed();
+    }
+}
+
+void Viewport::updateMidVars()
+{
+    mMidTileX = (mainGraphics->mWidth + mScrollCenterOffsetX) / 2
+        - mCameraRelativeX;
+    mMidTileY = (mainGraphics->mHeight + mScrollCenterOffsetY) / 2
+        - mCameraRelativeY;
+}
+
+void Viewport::updateMaxVars()
+{
+    if (mMap == nullptr)
+        return;
+    mViewXmax = mMap->getWidth() * mMap->getTileWidth()
+        - mainGraphics->mWidth;
+    mViewYmax = mMap->getHeight() * mMap->getTileHeight()
+        - mainGraphics->mHeight;
+}
+
+void Viewport::videoResized()
+{
+    updateMidVars();
+    updateMaxVars();
+}
diff --git a/src/progs/manaplus/gui/viewport.h b/src/progs/manaplus/gui/viewport.h
new file mode 100644
index 000000000..62982fc89
--- /dev/null
+++ b/src/progs/manaplus/gui/viewport.h
@@ -0,0 +1,249 @@
+/*
+ *  The ManaPlus Client
+ *  Copyright (C) 2004-2009  The Mana World Development Team
+ *  Copyright (C) 2009-2010  The Mana Developers
+ *  Copyright (C) 2011-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/>.
+ */
+
+#ifndef PROGS_MANAPLUS_GUI_VIEWPORT_H
+#define PROGS_MANAPLUS_GUI_VIEWPORT_H
+
+#include "position.h"
+
+#include "enums/simpletypes/beingid.h"
+
+#include "gui/widgets/windowcontainer.h"
+
+#include "listeners/mouselistener.h"
+
+class ActorSprite;
+class Being;
+class FloorItem;
+class Graphics;
+class Map;
+class MapItem;
+
+/**
+ * The viewport on the map. Displays the current map and handles mouse input
+ * and the popup menu.
+ */
+class Viewport final : public WindowContainer,
+                       public MouseListener,
+                       public ConfigListener
+{
+    public:
+        /**
+         * Constructor.
+         */
+        Viewport();
+
+        A_DELETE_COPY(Viewport)
+
+        /**
+         * Destructor.
+         */
+        ~Viewport();
+
+        /**
+         * Sets the map displayed by the viewport.
+         */
+        void setMap(Map *const map);
+
+        /**
+         * Draws the viewport.
+         */
+        void draw(Graphics *const graphics) override final A_NONNULL(2);
+
+        void safeDraw(Graphics *const graphics) override final A_NONNULL(2);
+
+        /**
+         * Implements player to keep following mouse.
+         */
+        void logic() override final;
+
+        /**
+         * Toggles whether the path debug graphics are shown. normal,
+         * debug with all images and grid, debug with out big images
+         * and with out grid.
+         */
+        void toggleMapDrawType();
+
+        void toggleCameraMode();
+
+        /**
+         * Handles mouse press on map.
+         */
+        void mousePressed(MouseEvent &event) override final;
+
+        /**
+         * Handles mouse move on map
+         */
+        void mouseDragged(MouseEvent &event) override final;
+
+        /**
+         * Handles mouse button release on map.
+         */
+        void mouseReleased(MouseEvent &event) override final;
+
+        /**
+         * Handles mouse move on map.
+         */
+        void mouseMoved(MouseEvent &event) override final;
+
+        /**
+         * A relevant config option changed.
+         */
+        void optionChanged(const std::string &name) override final;
+
+        /**
+         * Returns camera x offset in pixels.
+         */
+        int getCameraX() const noexcept2 A_WARN_UNUSED
+        { return mPixelViewX; }
+
+        /**
+         * Returns camera y offset in pixels.
+         */
+        int getCameraY() const noexcept2 A_WARN_UNUSED
+        { return mPixelViewY; }
+
+        /**
+         * Changes viewpoint by relative pixel coordinates.
+         */
+        void scrollBy(const int x, const int y)
+        { mPixelViewX += x; mPixelViewY += y; }
+
+        /**
+         * Clear all hover item, being etc
+         */
+        void cleanHoverItems();
+
+        Map *getMap() const noexcept2 A_WARN_UNUSED
+        { return mMap; }
+
+        void moveCamera(const int dx, const int dy);
+
+        int getCameraRelativeX() const noexcept2 A_WARN_UNUSED
+        { return mCameraRelativeX; }
+
+        int getCameraRelativeY() const noexcept2 A_WARN_UNUSED
+        { return mCameraRelativeY; }
+
+        void setCameraRelativeX(const int n)
+        { mCameraRelativeX = n; updateMidVars(); }
+
+        void setCameraRelativeY(const int n)
+        { mCameraRelativeY = n; updateMidVars(); }
+
+        void moveCameraToActor(const BeingId actorId,
+                               const int x = 0,
+                               const int y = 0);
+
+        void moveCameraToPosition(const int x, const int y);
+
+        void moveCameraRelative(const int x, const int y);
+
+        void returnCamera();
+
+        void getMouseTile(int &destX, int &destY) const;
+
+        void videoResized();
+
+        int mMouseX;                /**< Current mouse position in pixels. */
+        int mMouseY;                /**< Current mouse position in pixels. */
+
+    protected:
+        friend class ActorManager;
+
+        /// Clears any matching hovers
+        void clearHover(const ActorSprite *const actor);
+
+        void updateMidVars();
+
+        void updateMaxVars();
+
+        static void validateSpeed();
+
+    private:
+        /**
+         * Finds a path from the player to the mouse, and draws it. This is for
+         * debug purposes.
+         */
+        void drawDebugPath(Graphics *const graphics) A_NONNULL(2);
+
+        /**
+         * Draws the given path.
+         */
+        void drawPath(Graphics *const graphics,
+                      const Path &path,
+                      const Color &color = Color(255, 0, 0))
+                      const A_NONNULL(2);
+
+        bool leftMouseAction();
+
+        bool openContextMenu(const MouseEvent &event);
+
+        void walkByMouse(const MouseEvent &event);
+
+        void getMouseTile(const int x,
+                          const int y,
+                          int &destX,
+                          int &destY) const;
+
+        /**
+         * Make the player go to the mouse position.
+         */
+        void followMouse();
+
+        Map *mMap;                   /**< The current map. */
+
+        Being *mHoverBeing;          /**< Being mouse is currently over. */
+        FloorItem *mHoverItem;       /**< FloorItem mouse is currently over. */
+        MapItem *mHoverSign;         /**< Map sign mouse is currently over. */
+
+        int mScrollRadius;
+        int mScrollLaziness;
+        int mScrollCenterOffsetX;
+        int mScrollCenterOffsetY;
+        int mMousePressX;
+        int mMousePressY;
+        int mPixelViewX;            /**< Current viewpoint in pixels. */
+        int mPixelViewY;            /**< Current viewpoint in pixels. */
+        int mMidTileX;
+        int mMidTileY;
+        int mViewXmax;
+        int mViewYmax;
+
+        time_t mLocalWalkTime;
+
+        int mCameraRelativeX;
+        int mCameraRelativeY;
+
+        bool mShowBeingPopup;
+        bool mSelfMouseHeal;
+        bool mEnableLazyScrolling;
+        bool mMouseDirectionMove;
+        bool mLongMouseClick;
+        bool mAllowMoveByMouse;
+        bool mMouseClicked;
+        bool mPlayerFollowMouse;
+};
+
+extern Viewport *viewport;           /**< The viewport. */
+
+#endif  // PROGS_MANAPLUS_GUI_VIEWPORT_H