chatrecv.cpp

Go to the documentation of this file.

/*
 * The ManaPlus Client
 * Copyright (C) 2004-2009 The Mana World Development Team
 * Copyright (C) 2009-2010 The Mana Developers
 * Copyright (C) 2011-2019 The ManaPlus Developers
 * Copyright (C) 2019-2021 Andrei Karas
 *
 * 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 "net/tmwa/chatrecv.h"
 
#include "actormanager.h"
#include "configuration.h"
 
#include "being/localplayer.h"
#include "being/playerrelation.h"
#include "being/playerrelations.h"
 
#include "const/gui/chat.h"
 
#include "gui/widgets/tabs/chat/gmtab.h"
 
#include "gui/windows/chatwindow.h"
#include "gui/windows/shopwindow.h"
 
#include "net/serverfeatures.h"
 
#include "net/ea/chatrecv.h"
 
#include "net/messagein.h"
 
#include "net/tmwa/guildmanager.h"
 
#include "utils/gettext.h"
 
#include "debug.h"
 
namespace TmwAthena
{
 
namespace ChatRecv
{
 std::string mShopRequestName;
} // namespace ChatRecv
 
void ChatRecv::processChat(Net::MessageIn &msg)
{
 BLOCK_START("ChatRecv::processChat")
 const int chatMsgLength = msg.readInt16("len") - 4;
 if (chatMsgLength <= 0)
 {
 BLOCK_END("ChatRecv::processChat")
 return;
 }
 
 processChatContinue(msg.readRawString(chatMsgLength, "message"));
}
 
void ChatRecv::processChatContinue(std::string chatMsg)
{
 const size_t pos = chatMsg.find(" : ", 0);
 
 bool allow(true);
 if (chatWindow != nullptr)
 {
 allow = chatWindow->resortChatLog(chatMsg,
 ChatMsgType::BY_PLAYER,
 GENERAL_CHANNEL,
 IgnoreRecord_false,
 TryRemoveColors_true);
 }
 
 const std::string senseStr("You sense the following: ");
 if ((actorManager != nullptr) && (chatMsg.find(senseStr) == 0U))
 {
 actorManager->parseLevels(
 chatMsg.substr(senseStr.size()));
 }
 
 if (pos == std::string::npos &&
 !Ea::ChatRecv::mShowMotd &&
 Ea::ChatRecv::mSkipping)
 {
 // skip motd from "new" tmw server
 if (Ea::ChatRecv::mMotdTime == 0)
 {
 Ea::ChatRecv::mMotdTime = cur_time + 1;
 }
 else if (Ea::ChatRecv::mMotdTime == cur_time ||
 Ea::ChatRecv::mMotdTime < cur_time)
 {
 Ea::ChatRecv::mSkipping = false;
 }
 BLOCK_END("ChatRecv::processChat")
 return;
 }
 
 if (pos != std::string::npos)
 chatMsg.erase(0, pos + 3);
 
 trim(chatMsg);
 
 if (localPlayer != nullptr)
 {
 if ((chatWindow != nullptr || Ea::ChatRecv::mShowMotd) && allow)
 localPlayer->setSpeech(chatMsg);
 }
 BLOCK_END("ChatRecv::processChat")
}
 
void ChatRecv::processGmChat(Net::MessageIn &msg)
{
 BLOCK_START("ChatRecv::processChat")
 const int chatMsgLength = msg.readInt16("len") - 4;
 if (chatMsgLength <= 0)
 {
 BLOCK_END("ChatRecv::processChat")
 return;
 }
 
 if (localChatTab != nullptr &&
 chatWindow != nullptr)
 {
 std::string chatMsg = msg.readRawString(chatMsgLength, "message");
 chatWindow->addGlobalMessage(chatMsg);
 }
 else
 {
 msg.readRawString(chatMsgLength, "message");
 }
 BLOCK_END("ChatRecv::processChat")
}
 
void ChatRecv::processWhisper(Net::MessageIn &msg)
{
 BLOCK_START("ChatRecv::processWhisper")
 const int chatMsgLength = msg.readInt16("len") - 28;
 std::string nick = msg.readString(24, "nick");
 
 if (chatMsgLength <= 0)
 {
 BLOCK_END("ChatRecv::processWhisper")
 return;
 }
 
 processWhisperContinue(nick, msg.readString(chatMsgLength, "message"));
}
 
void ChatRecv::processWhisperResponse(Net::MessageIn &msg)
{
 BLOCK_START("ChatRecv::processWhisperResponse")
 
 const uint8_t type = msg.readUInt8("response");
 Ea::ChatRecv::processWhisperResponseContinue(msg, type);
}
 
void ChatRecv::processWhisperContinue(const std::string &nick,
 std::string chatMsg)
{
 // ignoring future whisper messages
 if (chatMsg.find("\302\202G") == 0 || chatMsg.find("\302\202A") == 0)
 {
 BLOCK_END("ChatRecv::processWhisper")
 return;
 }
 // remove first unicode space if this is may be whisper command.
 if (chatMsg.find("\302\202!") == 0)
 chatMsg = chatMsg.substr(2);
 
 if (nick != "Server")
 {
 if ((guildManager != nullptr) && GuildManager::getEnableGuildBot()
 && nick == "guild" && guildManager->processGuildMessage(chatMsg))
 {
 BLOCK_END("ChatRecv::processWhisper")
 return;
 }
 
 if (playerRelations.hasPermission(nick, PlayerRelation::WHISPER))
 {
 const bool tradeBot = config.getBoolValue("tradebot");
 const bool showMsg = !config.getBoolValue("hideShopMessages");
 if (playerRelations.hasPermission(nick, PlayerRelation::TRADE))
 {
 if (shopWindow != nullptr)
 { // commands to shop from player
 if (chatMsg.find("!selllist ") == 0)
 {
 if (tradeBot)
 {
 if (showMsg && (chatWindow != nullptr))
 {
 chatWindow->addWhisper(nick,
 chatMsg,
 ChatMsgType::BY_OTHER);
 }
 shopWindow->giveList(nick, ShopWindow::SELL);
 }
 }
 else if (chatMsg.find("!buylist ") == 0)
 {
 if (tradeBot)
 {
 if (showMsg && chatWindow != nullptr)
 {
 chatWindow->addWhisper(nick,
 chatMsg,
 ChatMsgType::BY_OTHER);
 }
 shopWindow->giveList(nick, ShopWindow::BUY);
 }
 }
 else if (chatMsg.find("!buyitem ") == 0)
 {
 if (showMsg && chatWindow != nullptr)
 {
 chatWindow->addWhisper(nick,
 chatMsg,
 ChatMsgType::BY_OTHER);
 }
 if (tradeBot)
 {
 shopWindow->processRequest(nick, chatMsg,
 ShopWindow::BUY);
 }
 }
 else if (chatMsg.find("!sellitem ") == 0)
 {
 if (showMsg && chatWindow != nullptr)
 {
 chatWindow->addWhisper(nick,
 chatMsg,
 ChatMsgType::BY_OTHER);
 }
 if (tradeBot)
 {
 shopWindow->processRequest(nick, chatMsg,
 ShopWindow::SELL);
 }
 }
 else if (chatMsg.length() > 3
 && chatMsg.find("\302\202") == 0)
 {
 chatMsg = chatMsg.erase(0, 2);
 if (mShopRequestName != nick)
 {
 debugMsg(strprintf(
 // TRANSLATORS: message about spam player
 _("Detected spam from: %s"),
 nick.c_str()))
 BLOCK_END("ChatRecv::processWhisper")
 return;
 }
 mShopRequestName.clear();
 if (showMsg && chatWindow != nullptr)
 {
 chatWindow->addWhisper(nick,
 chatMsg,
 ChatMsgType::BY_OTHER);
 }
 if (chatMsg.find("B1") == 0 || chatMsg.find("S1") == 0)
 ShopWindow::showList(nick, chatMsg);
 }
 else if (chatWindow != nullptr)
 {
 chatWindow->addWhisper(nick,
 chatMsg,
 ChatMsgType::BY_OTHER);
 }
 }
 else if (chatWindow != nullptr)
 {
 chatWindow->addWhisper(nick,
 chatMsg,
 ChatMsgType::BY_OTHER);
 }
 }
 else
 {
 if (chatWindow != nullptr &&
 (showMsg ||
 (chatMsg.find("!selllist") != 0 &&
 chatMsg.find("!buylist") != 0)))
 {
 chatWindow->addWhisper(nick,
 chatMsg,
 ChatMsgType::BY_OTHER);
 }
 }
 }
 }
 else if (localChatTab != nullptr)
 {
 if ((gmChatTab != nullptr) && strStartWith(chatMsg, "[GM] "))
 {
 chatMsg = chatMsg.substr(5);
 const size_t pos = chatMsg.find(": ", 0);
 if (pos == std::string::npos)
 {
 gmChatTab->chatLog(chatMsg,
 ChatMsgType::BY_SERVER,
 IgnoreRecord_false,
 TryRemoveColors_true);
 }
 else
 {
 gmChatTab->chatLog(chatMsg.substr(0, pos),
 chatMsg.substr(pos + 2));
 }
 }
 else
 {
 localChatTab->chatLog(chatMsg,
 ChatMsgType::BY_SERVER,
 IgnoreRecord_false,
 TryRemoveColors_true);
 }
 }
 BLOCK_END("ChatRecv::processWhisper")
}
 
void ChatRecv::processBeingChat(Net::MessageIn &msg)
{
 if (actorManager == nullptr)
 return;
 
 BLOCK_START("ChatRecv::processBeingChat")
 const int chatMsgLength = msg.readInt16("len") - 8;
 const BeingId beingId = msg.readBeingId("being id");
 Being *const being = actorManager->findBeing(beingId);
 
 if (chatMsgLength <= 0)
 {
 BLOCK_END("ChatRecv::processBeingChat")
 return;
 }
 
 std::string chatMsg = msg.readRawString(chatMsgLength, "message");
 
 if ((being != nullptr) && being->getType() == ActorType::Player)
 being->setTalkTime();
 
 const size_t pos = chatMsg.find(" : ", 0);
 std::string sender_name = ((pos == std::string::npos)
 ? "" : chatMsg.substr(0, pos));
 
 if (serverFeatures->haveIncompleteChatMessages())
 {
 // work around for "new" tmw server
 if (being != nullptr)
 sender_name = being->getName();
 if (sender_name.empty())
 {
 sender_name = "?" + toString(CAST_S32(beingId));
 const std::string name = actorManager->getSeenPlayerById(beingId);
 if (!name.empty())
 sender_name.append(" ").append(name);
 }
 }
 else if ((being != nullptr) &&
 sender_name != being->getName() &&
 being->getType() == ActorType::Player)
 {
 if (!being->getName().empty())
 sender_name = being->getName();
 }
 else
 {
 chatMsg.erase(0, pos + 3);
 }
 
 trim(chatMsg);
 
 bool allow(true);
 // We use getIgnorePlayer instead of ignoringPlayer here
 // because ignorePlayer' side effects are triggered
 // right below for Being::IGNORE_SPEECH_FLOAT.
 if ((playerRelations.checkPermissionSilently(sender_name,
 PlayerRelation::SPEECH_LOG) != 0U) &&
 (chatWindow != nullptr))
 {
 allow = chatWindow->resortChatLog(
 removeColors(sender_name).append(" : ").append(chatMsg),
 ChatMsgType::BY_OTHER,
 GENERAL_CHANNEL,
 IgnoreRecord_false,
 TryRemoveColors_true);
 }
 
 if (allow &&
 (being != nullptr) &&
 playerRelations.hasPermission(sender_name,
 PlayerRelation::SPEECH_FLOAT))
 {
 being->setSpeech(chatMsg);
 }
 BLOCK_END("ChatRecv::processBeingChat")
}
 
void ChatRecv::processScriptMessage(Net::MessageIn &msg)
{
 const int sz = msg.readInt16("len") - 5;
 msg.readUInt8("message type");
 const std::string message = msg.readString(sz, "message");
 localChatTab->chatLog(message,
 ChatMsgType::BY_SERVER,
 IgnoreRecord_false,
 TryRemoveColors_true);
}
 
} // namespace TmwAthena