summaryrefslogtreecommitdiff
path: root/src/commands.cpp
diff options
context:
space:
mode:
authorAndrei Karas <akaras@inbox.ru>2012-11-27 02:59:26 +0300
committerAndrei Karas <akaras@inbox.ru>2012-11-27 23:32:12 +0300
commit1fd495484bb43a1e0b0d088874d7bc588d8d38c9 (patch)
tree1c975620150a8e30196379748871338fa89720ac /src/commands.cpp
parent42d107be2ecb0cf81c1a291bb4e63e78094bd62e (diff)
downloadplus-1fd495484bb43a1e0b0d088874d7bc588d8d38c9.tar.gz
plus-1fd495484bb43a1e0b0d088874d7bc588d8d38c9.tar.bz2
plus-1fd495484bb43a1e0b0d088874d7bc588d8d38c9.tar.xz
plus-1fd495484bb43a1e0b0d088874d7bc588d8d38c9.zip
Simplify command handlers.
Diffstat (limited to 'src/commands.cpp')
-rw-r--r--src/commands.cpp1210
1 files changed, 1210 insertions, 0 deletions
diff --git a/src/commands.cpp b/src/commands.cpp
new file mode 100644
index 000000000..31e3d3fe2
--- /dev/null
+++ b/src/commands.cpp
@@ -0,0 +1,1210 @@
+/*
+ * The ManaPlus Client
+ * Copyright (C) 2008-2009 The Mana World Development Team
+ * Copyright (C) 2009-2010 The Mana Developers
+ * Copyright (C) 2011-2012 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 "commandhandler.h"
+
+#include "auctionmanager.h"
+#include "actorspritemanager.h"
+#include "channelmanager.h"
+#include "channel.h"
+#include "client.h"
+#include "configuration.h"
+#include "game.h"
+#include "guildmanager.h"
+#include "localplayer.h"
+#include "main.h"
+#include "party.h"
+
+#include "gui/chatwindow.h"
+#include "gui/helpwindow.h"
+#include "gui/gui.h"
+#include "gui/outfitwindow.h"
+#include "gui/shopwindow.h"
+#include "gui/socialwindow.h"
+#include "gui/tradewindow.h"
+#include "gui/sdlfont.h"
+
+#include "gui/widgets/channeltab.h"
+#include "gui/widgets/whispertab.h"
+
+#include "net/adminhandler.h"
+#include "net/beinghandler.h"
+#include "net/chathandler.h"
+#include "net/gamehandler.h"
+#include "net/guildhandler.h"
+#include "net/net.h"
+#include "net/partyhandler.h"
+#include "net/playerhandler.h"
+#include "net/tradehandler.h"
+
+#if defined USE_OPENGL
+#include "normalopenglgraphics.h"
+#endif
+
+#ifdef DEBUG_DUMP_LEAKS1
+#include "resources/image.h"
+#include "resources/resource.h"
+#include "resources/resourcemanager.h"
+#include "resources/subimage.h"
+#endif
+
+#include "utils/gettext.h"
+#include "utils/process.h"
+
+#include "debug.h"
+
+#define impHandler(name) void name(const std::string &args, ChatTab *const tab)
+#define impHandler0(name) void name(const std::string &args A_UNUSED, \
+ ChatTab *const tab A_UNUSED)
+#define impHandler1(name) void name(const std::string &args, \
+ ChatTab *const tab A_UNUSED)
+#define impHandler2(name) void name(const std::string &args A_UNUSED, \
+ ChatTab *const tab)
+
+extern std::string tradePartnerName;
+
+namespace Commands
+{
+
+static void outString(ChatTab *const tab, const std::string &str,
+ const std::string &def)
+{
+ if (!tab)
+ {
+ Net::getChatHandler()->me(def);
+ return;
+ }
+
+ switch (tab->getType())
+ {
+ case ChatTab::TAB_PARTY:
+ {
+ Net::getPartyHandler()->chat(str);
+ break;
+ }
+ case ChatTab::TAB_GUILD:
+ {
+ if (!player_node)
+ return;
+ const Guild *const guild = player_node->getGuild();
+ if (guild)
+ {
+ if (guild->getServerGuild())
+ Net::getGuildHandler()->chat(guild->getId(), str);
+ else if (guildManager)
+ guildManager->chat(str);
+ }
+ break;
+ }
+ default:
+ Net::getChatHandler()->me(def);
+ break;
+ }
+}
+
+static void changeRelation(const std::string &args,
+ const PlayerRelation::Relation relation,
+ const std::string &relationText,
+ ChatTab *const tab)
+{
+ if (args.empty())
+ {
+ if (tab)
+ tab->chatLog(_("Please specify a name."), BY_SERVER);
+ return;
+ }
+
+ if (player_relations.getRelation(args) == relation)
+ {
+ if (tab)
+ {
+ tab->chatLog(strprintf(_("Player already %s!"),
+ relationText.c_str()), BY_SERVER);
+ }
+ return;
+ }
+ else
+ {
+ player_relations.setRelation(args, relation);
+ }
+
+ if (player_relations.getRelation(args) == relation)
+ {
+ if (tab)
+ {
+ tab->chatLog(strprintf(_("Player successfully %s!"),
+ relationText.c_str()), BY_SERVER);
+ }
+ }
+ else
+ {
+ if (tab)
+ {
+ tab->chatLog(strprintf(_("Player could not be %s!"),
+ relationText.c_str()), BY_SERVER);
+ }
+ }
+}
+
+static bool parse2Int(const std::string &args, int &x, int &y)
+{
+ bool isValid = false;
+ const size_t pos = args.find(" ");
+ if (pos != std::string::npos)
+ {
+ if (pos + 1 < args.length())
+ {
+ x = atoi(args.substr(0, pos).c_str());
+ y = atoi(args.substr(pos + 1, args.length()).c_str());
+ isValid = true;
+ }
+ }
+ return isValid;
+}
+
+static void outStringNormal(ChatTab *const tab,
+ const std::string &str,
+ const std::string &def)
+{
+ if (!player_node)
+ return;
+
+ if (!tab)
+ {
+ Net::getChatHandler()->talk(str);
+ return;
+ }
+
+ switch (tab->getType())
+ {
+ case ChatTab::TAB_PARTY:
+ {
+ Net::getPartyHandler()->chat(str);
+ break;
+ }
+ case ChatTab::TAB_GUILD:
+ {
+ if (!player_node)
+ return;
+ const Guild *const guild = player_node->getGuild();
+ if (guild)
+ {
+ if (guild->getServerGuild())
+ Net::getGuildHandler()->chat(guild->getId(), str);
+ else if (guildManager)
+ guildManager->chat(str);
+ }
+ break;
+ }
+ case ChatTab::TAB_WHISPER:
+ {
+ const WhisperTab *const whisper
+ = static_cast<WhisperTab *const>(tab);
+ tab->chatLog(player_node->getName(), str);
+ Net::getChatHandler()->privateMessage(whisper->getNick(), str);
+ break;
+ }
+ default:
+ Net::getChatHandler()->talk(def);
+ break;
+ }
+}
+
+
+impHandler1(announce)
+{
+ Net::getAdminHandler()->announce(args);
+}
+
+impHandler0(help)
+{
+ if (!helpWindow)
+ return;
+
+ if (!tab)
+ {
+ helpWindow->loadHelp("chatcommands");
+ helpWindow->requestMoveToTop();
+ return;
+ }
+ switch (tab->getType())
+ {
+ case ChatTab::TAB_PARTY:
+ {
+ helpWindow->loadHelp("chatparty");
+ break;
+ }
+ case ChatTab::TAB_GUILD:
+ {
+ helpWindow->loadHelp("chatguild");
+ break;
+ }
+ default:
+ helpWindow->loadHelp("chatcommands");
+ break;
+ }
+ helpWindow->requestMoveToTop();
+}
+
+impHandler2(where)
+{
+ std::ostringstream where;
+ where << Game::instance()->getCurrentMapName() << ", coordinates: "
+ << ((player_node->getPixelX() - 16) / 32) << ", "
+ << ((player_node->getPixelY() - 32) / 32);
+
+ tab->chatLog(where.str(), BY_SERVER);
+}
+
+impHandler0(who)
+{
+ Net::getChatHandler()->who();
+}
+
+impHandler(msg)
+{
+ std::string recvnick("");
+ std::string msg("");
+
+ 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())
+ msg = 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())
+ msg = args.substr(pos + 1, args.length());
+ }
+ else
+ {
+ recvnick = std::string(args);
+ msg = "";
+ }
+ }
+
+ trim(msg);
+
+ if (msg.length() > 0)
+ {
+ std::string playerName = player_node->getName();
+ std::string tempNick = recvnick;
+
+ toLower(playerName);
+ toLower(tempNick);
+
+ if (tempNick.compare(playerName) == 0 || args.empty())
+ return;
+
+ chatWindow->addWhisper(recvnick, msg, BY_PLAYER);
+ }
+ else
+ tab->chatLog(_("Cannot send empty whispers!"), BY_SERVER);
+}
+
+impHandler(query)
+{
+ if (chatWindow)
+ {
+ if (chatWindow->addWhisperTab(args, true))
+ {
+ chatWindow->saveState();
+ return;
+ }
+ }
+
+ tab->chatLog(strprintf(_("Cannot create a whisper tab for nick \"%s\"! "
+ "It either already exists, or is you."),
+ args.c_str()), BY_SERVER);
+}
+
+impHandler0(clear)
+{
+ if (chatWindow)
+ chatWindow->clearTab();
+}
+
+impHandler(join)
+{
+ if (!tab)
+ return;
+
+ const size_t pos = args.find(' ');
+ const std::string name(args, 0, pos);
+ const std::string password(args, pos + 1);
+ tab->chatLog(strprintf(_("Requesting to join channel %s."), name.c_str()));
+ Net::getChatHandler()->enterChannel(name, password);
+}
+
+impHandler0(listChannels)
+{
+ Net::getChatHandler()->channelList();
+}
+
+impHandler(createParty)
+{
+ if (!tab)
+ return;
+
+ if (args.empty())
+ tab->chatLog(_("Party name is missing."), BY_SERVER);
+ else
+ Net::getPartyHandler()->create(args);
+}
+
+impHandler(createGuild)
+{
+ if (!tab)
+ return;
+
+ if (args.empty())
+ tab->chatLog(_("Guild name is missing."), BY_SERVER);
+ else
+ Net::getGuildHandler()->create(args);
+}
+
+impHandler(party)
+{
+ if (!tab)
+ return;
+
+ if (args != "")
+ Net::getPartyHandler()->invite(args);
+ else
+ tab->chatLog(_("Please specify a name."), BY_SERVER);
+}
+
+impHandler(me)
+{
+ outString(tab, strprintf("*%s*", args.c_str()), args);
+}
+
+impHandler(toggle)
+{
+ if (args.empty())
+ {
+ if (chatWindow && tab)
+ {
+ tab->chatLog(chatWindow->getReturnTogglesChat() ?
+ _("Return toggles chat.") : _("Message closes chat."));
+ }
+ return;
+ }
+
+ switch (parseBoolean(args))
+ {
+ case 1:
+ if (tab)
+ tab->chatLog(_("Return now toggles chat."));
+ if (chatWindow)
+ chatWindow->setReturnTogglesChat(true);
+ return;
+ case 0:
+ if (tab)
+ tab->chatLog(_("Message now closes chat."));
+ if (chatWindow)
+ chatWindow->setReturnTogglesChat(false);
+ return;
+ case -1:
+ if (tab)
+ tab->chatLog(strprintf(BOOLEAN_OPTIONS, "toggle"));
+ return;
+ default:
+ return;
+ }
+}
+
+impHandler0(present)
+{
+ if (chatWindow)
+ chatWindow->doPresent();
+}
+
+impHandler1(ignore)
+{
+ changeRelation(args, PlayerRelation::IGNORED, "ignored", tab);
+}
+
+impHandler(beFriend)
+{
+ changeRelation(args, PlayerRelation::FRIEND, _("friend"), tab);
+}
+
+impHandler(disregard)
+{
+ changeRelation(args, PlayerRelation::DISREGARDED, _("disregarded"), tab);
+}
+
+impHandler(neutral)
+{
+ changeRelation(args, PlayerRelation::NEUTRAL, _("neutral"), tab);
+}
+
+impHandler(unignore)
+{
+ if (args.empty())
+ {
+ if (tab)
+ tab->chatLog(_("Please specify a name."), BY_SERVER);
+ return;
+ }
+
+ if (player_relations.getRelation(args) != PlayerRelation::NEUTRAL
+ && player_relations.getRelation(args) != PlayerRelation::FRIEND)
+ {
+ player_relations.setRelation(args, PlayerRelation::NEUTRAL);
+ }
+ else
+ {
+ if (tab)
+ tab->chatLog(_("Player wasn't ignored!"), BY_SERVER);
+ return;
+ }
+
+ if (tab)
+ {
+ if (player_relations.getRelation(args) == PlayerRelation::NEUTRAL)
+ tab->chatLog(_("Player no longer ignored!"), BY_SERVER);
+ else
+ tab->chatLog(_("Player could not be unignored!"), BY_SERVER);
+ }
+}
+
+impHandler(blackList)
+{
+ changeRelation(args, PlayerRelation::BLACKLISTED, _("blacklisted"), tab);
+}
+
+impHandler(enemy)
+{
+ changeRelation(args, PlayerRelation::ENEMY2, _("enemy"), tab);
+}
+
+impHandler(erase)
+{
+ if (args.empty())
+ {
+ if (tab)
+ tab->chatLog(_("Please specify a name."), BY_SERVER);
+ return;
+ }
+
+ if (player_relations.getRelation(args) == PlayerRelation::ERASED)
+ {
+ if (tab)
+ tab->chatLog(_("Player already erased!"), BY_SERVER);
+ return;
+ }
+ else
+ {
+ player_relations.setRelation(args, PlayerRelation::ERASED);
+ }
+
+ if (tab)
+ {
+ if (player_relations.getRelation(args) == PlayerRelation::ERASED)
+ tab->chatLog(_("Player successfully erased!"), BY_SERVER);
+ else
+ tab->chatLog(_("Player could not be erased!"), BY_SERVER);
+ }
+}
+
+impHandler0(quit)
+{
+// quit();
+}
+
+impHandler0(showAll)
+{
+ if (actorSpriteManager)
+ actorSpriteManager->printAllToChat();
+}
+
+impHandler1(move)
+{
+ int x = 0;
+ int y = 0;
+
+ if (player_node && parse2Int(args, x, y))
+ player_node->moveTo(x, y);
+}
+
+impHandler1(navigate)
+{
+ if (!player_node)
+ return;
+
+ int x = 0;
+ int y = 0;
+
+ if (parse2Int(args, x, y))
+ player_node->navigateTo(x, y);
+ else
+ player_node->navigateClean();
+}
+
+impHandler1(target)
+{
+ if (!actorSpriteManager || !player_node)
+ return;
+
+ Being *const target = actorSpriteManager->findNearestByName(args);
+ if (target)
+ player_node->setTarget(target);
+}
+
+impHandler0(attackHuman)
+{
+ if (!actorSpriteManager || !player_node)
+ return;
+
+ Being *const target = actorSpriteManager->findNearestLivingBeing(
+ player_node, 10, ActorSprite::PLAYER);
+ if (target)
+ {
+ if (player_node->checAttackPermissions(target))
+ {
+ player_node->setTarget(target);
+ player_node->attack2(target, true);
+ }
+ }
+}
+
+
+impHandler0(closeAll)
+{
+ if (chatWindow)
+ {
+ chatWindow->removeAllWhispers();
+ chatWindow->saveState();
+ }
+}
+
+impHandler0(ignoreAll)
+{
+ if (chatWindow)
+ {
+ chatWindow->ignoreAllWhispers();
+ chatWindow->saveState();
+ }
+}
+
+impHandler1(outfit)
+{
+ if (outfitWindow)
+ {
+ if (!args.empty())
+ {
+ const std::string op = args.substr(0, 1);
+ if (op == "n")
+ outfitWindow->wearNextOutfit(true);
+ else if (op == "p")
+ outfitWindow->wearPreviousOutfit(true);
+ else
+ outfitWindow->wearOutfit(atoi(args.c_str()) - 1, false, true);
+ }
+ else
+ {
+ outfitWindow->wearOutfit(atoi(args.c_str()) - 1, false, true);
+ }
+ }
+}
+
+impHandler1(emote)
+{
+ if (player_node)
+ player_node->emote(static_cast<uint8_t>(atoi(args.c_str())));
+}
+
+impHandler1(away)
+{
+ if (player_node)
+ player_node->setAway(args);
+}
+
+impHandler1(pseudoAway)
+{
+ if (player_node)
+ {
+ player_node->setPseudoAway(args);
+ player_node->updateStatus();
+ }
+}
+
+impHandler(follow)
+{
+ if (!player_node)
+ return;
+
+ if (!args.empty())
+ {
+ player_node->setFollow(args);
+ }
+ else if (tab && tab->getType() == ChatTab::TAB_WHISPER)
+ {
+ player_node->setFollow(static_cast<WhisperTab*>(tab)->getNick());
+ }
+}
+
+impHandler(imitation)
+{
+ if (!player_node)
+ return;
+
+ if (!args.empty())
+ player_node->setImitate(args);
+ else if (tab && tab->getType() == ChatTab::TAB_WHISPER)
+ player_node->setImitate(static_cast<WhisperTab*>(tab)->getNick());
+ else
+ player_node->setImitate("");
+}
+
+impHandler1(heal)
+{
+ if (!actorSpriteManager)
+ return;
+
+ if (!args.empty())
+ {
+ const Being *const being = actorSpriteManager->findBeingByName(
+ args, Being::PLAYER);
+ if (being)
+ actorSpriteManager->heal(being);
+ }
+ else
+ {
+ actorSpriteManager->heal(player_node);
+ }
+}
+
+impHandler1(hack)
+{
+ Net::getChatHandler()->sendRaw(args);
+}
+
+impHandler1(mail)
+{
+ if (auctionManager && auctionManager->getEnableAuctionBot())
+ auctionManager->sendMail(args);
+}
+
+impHandler0(priceLoad)
+{
+ if (shopWindow)
+ shopWindow->loadList();
+}
+
+impHandler0(priceSave)
+{
+ if (shopWindow)
+ shopWindow->saveList();
+}
+
+impHandler0(disconnect)
+{
+ Net::getGameHandler()->disconnect2();
+}
+
+impHandler1(undress)
+{
+ if (!actorSpriteManager)
+ return;
+
+ Being *const target = actorSpriteManager->findNearestByName(args);
+ if (target)
+ Net::getBeingHandler()->undress(target);
+}
+
+impHandler1(attack)
+{
+ if (!player_node || !actorSpriteManager)
+ return;
+
+ Being *const target = actorSpriteManager->findNearestByName(args);
+ if (target)
+ player_node->setTarget(target);
+ player_node->attack2(player_node->getTarget(), true);
+}
+
+impHandler1(trade)
+{
+ if (!actorSpriteManager)
+ return;
+
+ Being *const being = actorSpriteManager->findBeingByName(
+ args, Being::PLAYER);
+ if (being)
+ {
+ Net::getTradeHandler()->request(being);
+ tradePartnerName = being->getName();
+ if (tradeWindow)
+ tradeWindow->clear();
+ }
+}
+
+impHandler0(dirs)
+{
+ if (!player_node || !debugChatTab)
+ return;
+
+ debugChatTab->chatLog("config directory: "
+ + Client::getConfigDirectory());
+ debugChatTab->chatLog("logs directory: "
+ + Client::getLocalDataDirectory());
+ debugChatTab->chatLog("screenshots directory: "
+ + Client::getScreenshotDirectory());
+ debugChatTab->chatLog("temp directory: "
+ + Client::getTempDirectory());
+}
+
+impHandler2(info)
+{
+ switch (tab->getType())
+ {
+ case ChatTab::TAB_GUILD:
+ {
+ if (!player_node)
+ return;
+ const Guild *const guild = player_node->getGuild();
+ if (guild)
+ Net::getGuildHandler()->info(guild->getId());
+ break;
+ }
+ default:
+ break;
+ }
+}
+
+impHandler1(wait)
+{
+ if (player_node)
+ player_node->waitFor(args);
+}
+
+impHandler0(uptime)
+{
+ if (!debugChatTab)
+ return;
+
+ if (cur_time < start_time)
+ {
+ debugChatTab->chatLog(strprintf(_("Client uptime: %s"), "unknown"));
+ }
+ else
+ {
+ std::string str;
+ int timeDiff = cur_time - start_time;
+
+ const int weeks = timeDiff / 60 / 60 / 24 / 7;
+ if (weeks > 0)
+ {
+ str = strprintf(ngettext("%d week", "%d weeks", weeks), weeks);
+ timeDiff -= weeks * 60 * 60 * 24 * 7;
+ }
+
+ const int days = timeDiff / 60 / 60 / 24;
+ if (days > 0)
+ {
+ if (!str.empty())
+ str += ", ";
+ str += strprintf(ngettext("%d day", "%d days", days), days);
+ timeDiff -= days * 60 * 60 * 24;
+ }
+ const int hours = timeDiff / 60 / 60;
+ if (hours > 0)
+ {
+ if (!str.empty())
+ str += ", ";
+ str += strprintf(ngettext("%d hour", "%d hours", hours), hours);
+ timeDiff -= hours * 60 * 60;
+ }
+ const int min = timeDiff / 60;
+ if (min > 0)
+ {
+ if (!str.empty())
+ str += ", ";
+ str += strprintf(ngettext("%d minute", "%d minutes", min), min);
+ timeDiff -= min * 60;
+ }
+
+ if (timeDiff > 0)
+ {
+ if (!str.empty())
+ str += ", ";
+ str += strprintf(ngettext("%d second", "%d seconds",
+ timeDiff), timeDiff);
+ }
+ debugChatTab->chatLog(strprintf(_("Client uptime: %s"), str.c_str()));
+ }
+}
+
+impHandler1(addPriorityAttack)
+{
+ if (!actorSpriteManager
+ || actorSpriteManager->isInPriorityAttackList(args))
+ {
+ return;
+ }
+
+ actorSpriteManager->removeAttackMob(args);
+ actorSpriteManager->addPriorityAttackMob(args);
+
+ if (socialWindow)
+ socialWindow->updateAttackFilter();
+}
+
+impHandler1(addAttack)
+{
+ if (!actorSpriteManager || actorSpriteManager->isInAttackList(args))
+ return;
+
+ actorSpriteManager->removeAttackMob(args);
+ actorSpriteManager->addAttackMob(args);
+
+ if (socialWindow)
+ socialWindow->updateAttackFilter();
+}
+
+impHandler1(removeAttack)
+{
+ if (!actorSpriteManager || args.empty()
+ || !actorSpriteManager->isInAttackList(args))
+ {
+ return;
+ }
+
+ actorSpriteManager->removeAttackMob(args);
+
+ if (socialWindow)
+ socialWindow->updateAttackFilter();
+}
+
+impHandler1(addIgnoreAttack)
+{
+ if (!actorSpriteManager || actorSpriteManager->isInIgnoreAttackList(args))
+ return;
+
+ actorSpriteManager->removeAttackMob(args);
+ actorSpriteManager->addIgnoreAttackMob(args);
+
+ if (socialWindow)
+ socialWindow->updateAttackFilter();
+}
+
+impHandler0(cacheInfo)
+{
+ if (!chatWindow || !debugChatTab)
+ return;
+
+ SDLFont *const font = dynamic_cast<SDLFont *const>(chatWindow->getFont());
+ if (!font)
+ return;
+
+ const std::list<SDLTextChunk> *const cache = font->getCache();
+ if (!cache)
+ return;
+
+ int all = 0;
+ debugChatTab->chatLog(_("font cache size"));
+ std::string str;
+ for (int f = 0; f < 256; f ++)
+ {
+ if (!cache[f].empty())
+ {
+ all += static_cast<int>(cache[f].size());
+ str += strprintf("%d: %u, ", f,
+ static_cast<unsigned int>(cache[f].size()));
+ }
+ }
+ debugChatTab->chatLog(str);
+ debugChatTab->chatLog(strprintf("%s %d", _("Cache size:"), all));
+#ifdef DEBUG_FONT_COUNTERS
+ debugChatTab->chatLog("");
+ debugChatTab->chatLog(strprintf("%s %d",
+ _("Created:"), font->getCreateCounter()));
+ debugChatTab->chatLog(strprintf("%s %d",
+ _("Deleted:"), font->getDeleteCounter()));
+#endif
+}
+
+impHandler0(serverIgnoreAll)
+{
+ Net::getChatHandler()->ignoreAll();
+}
+
+impHandler0(serverUnIgnoreAll)
+{
+ Net::getChatHandler()->unIgnoreAll();
+}
+
+impHandler2(dumpGraphics)
+{
+ std::string str;
+ str = strprintf ("%s,%s,%dX%dX%d,", PACKAGE_OS, SMALL_VERSION,
+ mainGraphics->getWidth(), mainGraphics->getHeight(),
+ mainGraphics->getBpp());
+
+ if (mainGraphics->getFullScreen())
+ str += "F";
+ else
+ str += "W";
+ if (mainGraphics->getHWAccel())
+ str += "H";
+ else
+ str += "S";
+
+ if (mainGraphics->getDoubleBuffer())
+ str += "D";
+ else
+ str += "_";
+
+#if defined USE_OPENGL
+ str += strprintf(",%d", mainGraphics->getOpenGL());
+#else
+ str += ",0";
+#endif
+
+ str += strprintf(",%f,", static_cast<double>(Client::getGuiAlpha()));
+ str += config.getBoolValue("adjustPerfomance") ? "1" : "0";
+ str += config.getBoolValue("alphaCache") ? "1" : "0";
+ str += config.getBoolValue("enableMapReduce") ? "1" : "0";
+ str += config.getBoolValue("beingopacity") ? "1" : "0";
+ str += ",";
+ str += config.getBoolValue("enableAlphaFix") ? "1" : "0";
+ str += config.getBoolValue("disableAdvBeingCaching") ? "1" : "0";
+ str += config.getBoolValue("disableBeingCaching") ? "1" : "0";
+ str += config.getBoolValue("particleeffects") ? "1" : "0";
+
+ str += strprintf(",%d-%d", fps, config.getIntValue("fpslimit"));
+ outStringNormal(tab, str, str);
+}
+
+impHandler2(dumpTests)
+{
+ std::string str = config.getStringValue("testInfo");
+ outStringNormal(tab, str, str);
+}
+
+impHandler1(setDrop)
+{
+ if (player_node)
+ player_node->setQuickDropCounter(atoi(args.c_str()));
+}
+
+impHandler0(error)
+{
+ int *ptr = nullptr;
+ logger->log("test %d", *ptr);
+}
+
+impHandler(url)
+{
+ if (tab)
+ {
+ std::string url = args;
+ if (!strStartWith(url, "http"))
+ url = "http://" + url;
+ std::string str = strprintf("[@@%s |%s@@]", url.c_str(), args.c_str());
+ outStringNormal(tab, str, str);
+ }
+}
+
+impHandler1(open)
+{
+ std::string url = args;
+ if (!strStartWith(url, "http"))
+ url = "http://" + url;
+ openBrowser(url);
+}
+
+#ifdef DEBUG_DUMP_LEAKS1
+void showRes(std::string str, ResourceManager::Resources *res);
+
+void showRes(std::string str, ResourceManager::Resources *res)
+{
+ if (!res)
+ return;
+
+ if (debugChatTab)
+ debugChatTab->chatLog(str + toString(res->size()));
+ logger->log(str + toString(res->size()));
+ ResourceManager::ResourceIterator iter = res->begin();
+ ResourceManager::ResourceIterator iter_end = res->end();
+ while (iter != iter_end)
+ {
+ if (iter->second && iter->second->getRefCount())
+ {
+ std::string type = " ";
+ std::string isNew = "N";
+ if (iter->second->getDumped())
+ isNew = "O";
+ else
+ iter->second->setDumped(true);
+
+ SubImage *const subImage = dynamic_cast<SubImage *const>(
+ iter->second);
+ Image *const image = dynamic_cast<Image *const>(iter->second);
+ int id = 0;
+ if (subImage)
+ type = "S";
+ else if (image)
+ type = "I";
+ if (image)
+ id = image->getGLImage();
+ logger->log("Resource %s%s: %s (%d) id=%d", type.c_str(),
+ isNew.c_str(), iter->second->getIdPath().c_str(),
+ iter->second->getRefCount(), id);
+ }
+ ++ iter;
+ }
+}
+
+impHandler1(dump)
+{
+ if (!debugChatTab)
+ return;
+
+ ResourceManager *resman = ResourceManager::getInstance();
+
+ if (!args.empty())
+ {
+ ResourceManager::Resources *res = resman->getResources();
+ showRes(_("Resource images:"), res);
+ res = resman->getOrphanedResources();
+ showRes(_("Resource orphaned images:"), res);
+ }
+ else
+ {
+ ResourceManager::Resources *res = resman->getResources();
+ debugChatTab->chatLog(_("Resource images:") + toString(res->size()));
+ res = resman->getOrphanedResources();
+ debugChatTab->chatLog(_("Resource orphaned images:")
+ + toString(res->size()));
+ }
+}
+
+#elif defined ENABLE_MEM_DEBUG
+impHandler0(dump)
+{
+ check_leaks();
+}
+#else
+impHandler0(dump)
+{
+}
+#endif
+
+
+impHandler0(dumpOGL)
+{
+#if defined USE_OPENGL && !defined ANDROID
+ NormalOpenGLGraphics::dumpSettings();
+#endif
+}
+
+void replaceVars(std::string &str)
+{
+ if (!player_node || !actorSpriteManager)
+ return;
+
+ if (str.find("<PLAYER>") != std::string::npos)
+ {
+ const Being *target = player_node->getTarget();
+ if (!target || target->getType() != ActorSprite::PLAYER)
+ {
+ target = actorSpriteManager->findNearestLivingBeing(
+ player_node, 20, ActorSprite::PLAYER);
+ }
+ if (target)
+ replaceAll(str, "<PLAYER>", target->getName());
+ else
+ replaceAll(str, "<PLAYER>", "");
+ }
+ if (str.find("<MONSTER>") != std::string::npos)
+ {
+ const Being *target = player_node->getTarget();
+ if (!target || target->getType() != ActorSprite::MONSTER)
+ {
+ target = actorSpriteManager->findNearestLivingBeing(
+ player_node, 20, ActorSprite::MONSTER);
+ }
+ if (target)
+ replaceAll(str, "<MONSTER>", target->getName());
+ else
+ replaceAll(str, "<MONSTER>", "");
+ }
+ if (str.find("<PEOPLE>") != std::string::npos)
+ {
+ StringVect names;
+ std::string newStr = "";
+ actorSpriteManager->getPlayerNames(names, false);
+ for (StringVectCIter it = names.begin(), it_end = names.end();
+ it != it_end; ++ it)
+ {
+ if (*it != player_node->getName())
+ newStr += *it + ",";
+ }
+ if (newStr[newStr.size() - 1] == ',')
+ newStr = newStr.substr(0, newStr.size() - 1);
+ if (!newStr.empty())
+ replaceAll(str, "<PEOPLE>", newStr);
+ else
+ replaceAll(str, "<PEOPLE>", "");
+ }
+ if (str.find("<PARTY>") != std::string::npos)
+ {
+ StringVect names;
+ std::string newStr = "";
+ const Party *party = nullptr;
+ if (player_node->isInParty() && (party = player_node->getParty()))
+ {
+ party->getNames(names);
+ for (StringVectCIter it = names.begin(), it_end = names.end();
+ it != it_end; ++ it)
+ {
+ if (*it != player_node->getName())
+ newStr += *it + ",";
+ }
+ if (newStr[newStr.size() - 1] == ',')
+ newStr = newStr.substr(0, newStr.size() - 1);
+ if (!newStr.empty())
+ replaceAll(str, "<PARTY>", newStr);
+ else
+ replaceAll(str, "<PARTY>", "");
+ }
+ else
+ {
+ replaceAll(str, "<PARTY>", "");
+ }
+ }
+}
+
+}