[WIP] renamed the client to ManaVerse

removed evol, since its not developed anymore... only leads to confusing players
removed that anoying 'broken nick detected' message (regulare player don't care what crap the server sends)
updated copyright -2020 for manaplus

1 files changed, 2224 insertions, 0 deletions

diff --git a/src/progs/manaverse/actions/commands.cpp b/src/progs/manaverse/actions/commands.cpp
new file mode 100644
index 000000000..ec6e65f75
--- /dev/null
+++ b/src/progs/manaverse/actions/commands.cpp
@@ -0,0 +1,2224 @@
+/*
+ *  The ManaPlus Client
+ *  Copyright (C) 2012-2020  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"
+
+#ifdef HAVE_MALLOC_TRIM
+#include <malloc.h>
+#endif
+
+#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,
+                IgnoreRecord_false,
+                TryRemoveColors_true);
+            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,
+                IgnoreRecord_false,
+                TryRemoveColors_true);
+        }
+        else
+        {
+            // TRANSLATORS: unignore command
+            event.tab->chatLog(str2,
+                ChatMsgType::BY_SERVER,
+                IgnoreRecord_false,
+                TryRemoveColors_true);
+        }
+    }
+}
+
+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,
+                IgnoreRecord_false,
+                TryRemoveColors_true);
+            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,
+                IgnoreRecord_false,
+                TryRemoveColors_true);
+        }
+        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,
+                IgnoreRecord_false,
+                TryRemoveColors_true);
+        }
+        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,
+        ActorType::Unknown);
+    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,
+        ActorType::Unknown);
+    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, "ftp") &&
+            !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") && !strStartWith(url, "ftp"))
+        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, true);
+        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)
+    {
+        if (emoteShortcut != nullptr)
+        {
+            const int emotion = event.action - InputAction::HOMUN_EMOTE_1;
+            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,
+                    IgnoreRecord_false,
+                    TryRemoveColors_true);
+                return true;
+            case PartyShare::NO:
+                // TRANSLATORS: chat message
+                tab->chatLog(_("Item sharing disabled."),
+                    ChatMsgType::BY_SERVER,
+                    IgnoreRecord_false,
+                    TryRemoveColors_true);
+                return true;
+            case PartyShare::NOT_POSSIBLE:
+                // TRANSLATORS: chat message
+                tab->chatLog(_("Item sharing not possible."),
+                    ChatMsgType::BY_SERVER,
+                    IgnoreRecord_false,
+                    TryRemoveColors_true);
+                return true;
+            case PartyShare::UNKNOWN:
+                // TRANSLATORS: chat message
+                tab->chatLog(_("Item sharing unknown."),
+                    ChatMsgType::BY_SERVER,
+                    IgnoreRecord_false,
+                    TryRemoveColors_true);
+                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,
+                IgnoreRecord_false,
+                TryRemoveColors_true);
+            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,
+                    IgnoreRecord_false,
+                    TryRemoveColors_true);
+                return true;
+            case PartyShare::NO:
+                // TRANSLATORS: chat message
+                tab->chatLog(_("Experience sharing disabled."),
+                    ChatMsgType::BY_SERVER,
+                    IgnoreRecord_false,
+                    TryRemoveColors_true);
+                return true;
+            case PartyShare::NOT_POSSIBLE:
+                // TRANSLATORS: chat message
+                tab->chatLog(_("Experience sharing not possible."),
+                    ChatMsgType::BY_SERVER,
+                    IgnoreRecord_false,
+                    TryRemoveColors_true);
+                return true;
+            case PartyShare::UNKNOWN:
+                // TRANSLATORS: chat message
+                tab->chatLog(_("Experience sharing unknown."),
+                    ChatMsgType::BY_SERVER,
+                    IgnoreRecord_false,
+                    TryRemoveColors_true);
+                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,
+                IgnoreRecord_false,
+                TryRemoveColors_true);
+            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,
+                    IgnoreRecord_false,
+                    TryRemoveColors_true);
+                return true;
+            case PartyShare::NO:
+                // TRANSLATORS: chat message
+                tab->chatLog(_("Auto item sharing disabled."),
+                    ChatMsgType::BY_SERVER,
+                    IgnoreRecord_false,
+                    TryRemoveColors_true);
+                return true;
+            case PartyShare::NOT_POSSIBLE:
+                // TRANSLATORS: chat message
+                tab->chatLog(_("Auto item sharing not possible."),
+                    ChatMsgType::BY_SERVER,
+                    IgnoreRecord_false,
+                    TryRemoveColors_true);
+                return true;
+            case PartyShare::UNKNOWN:
+                // TRANSLATORS: chat message
+                tab->chatLog(_("Auto item sharing unknown."),
+                    ChatMsgType::BY_SERVER,
+                    IgnoreRecord_false,
+                    TryRemoveColors_true);
+                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,
+                IgnoreRecord_false,
+                TryRemoveColors_true);
+            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, true);
+    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;
+}
+
+impHandler0(trimMemory)
+{
+#ifdef HAVE_MALLOC_TRIM
+    malloc_trim(0);
+#else
+    // TRANSLATORS: chat error about trim command
+    localChatTab->chatLog(_("Trim memory not supported"),
+        ChatMsgType::BY_SERVER,
+        IgnoreRecord_false,
+        TryRemoveColors_true);
+#endif
+    return true;
+}
+
+}  // namespace Actions