TmwAthena::ChatRecv Namespace Reference

Functions
void	processChat (Net::MessageIn &msg)
void	processChatContinue (std::string chatMsg)
void	processGmChat (Net::MessageIn &msg)
void	processWhisper (Net::MessageIn &msg)
void	processWhisperResponse (Net::MessageIn &msg)
void	processWhisperContinue (const std::string &nick, std::string chatMsg)
void	processBeingChat (Net::MessageIn &msg)
void	processScriptMessage (Net::MessageIn &msg)

Variables
std::string	mShopRequestName

Function Documentation

processBeingChat()

void TmwAthena::ChatRecv::processBeingChat

(

Net::MessageIn &

msg

)

Definition at line 336 of file chatrecv.cpp.

{
    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")
}

References actorManager, BLOCK_END, BLOCK_START, ChatMsgType::BY_OTHER, CAST_S32, chatWindow, PlayerRelationsManager::checkPermissionSilently(), ActorManager::findBeing(), GENERAL_CHANNEL, Being::getName(), ActorManager::getSeenPlayerById(), Being::getType(), PlayerRelationsManager::hasPermission(), Net::ServerFeatures::haveIncompleteChatMessages(), IgnoreRecord_false, Actions::msg(), ActorType::Player, playerRelations, removeColors(), ChatWindow::resortChatLog(), serverFeatures, Being::setSpeech(), Being::setTalkTime(), PlayerRelation::SPEECH_FLOAT, PlayerRelation::SPEECH_LOG, Catch::toString(), Catch::trim(), and TryRemoveColors_true.

processChat()

void TmwAthena::ChatRecv::processChat

(

Net::MessageIn &

msg

)

Definition at line 60 of file chatrecv.cpp.

{
    BLOCK_START("ChatRecv::processChat")
    const int chatMsgLength = msg.readInt16("len") - 4;
    if (chatMsgLength <= 0)
    {
        BLOCK_END("ChatRecv::processChat")
        return;
    }
 
    processChatContinue(msg.readRawString(chatMsgLength, "message"));
}

References BLOCK_END, BLOCK_START, Actions::msg(), and EAthena::ChatRecv::processChatContinue().

processChatContinue()

void TmwAthena::ChatRecv::processChatContinue

(

std::string

chatMsg

)

Definition at line 73 of file chatrecv.cpp.

{
    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")
}

References actorManager, BLOCK_END, ChatMsgType::BY_PLAYER, chatWindow, cur_time, GENERAL_CHANNEL, IgnoreRecord_false, localPlayer, Ea::ChatRecv::mMotdTime, Ea::ChatRecv::mShowMotd, Ea::ChatRecv::mSkipping, ActorManager::parseLevels(), ChatWindow::resortChatLog(), Being::setSpeech(), Catch::trim(), and TryRemoveColors_true.

processGmChat()

void TmwAthena::ChatRecv::processGmChat

(

Net::MessageIn &

msg

)

Definition at line 125 of file chatrecv.cpp.

{
    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")
}

References ChatWindow::addGlobalMessage(), BLOCK_END, BLOCK_START, chatWindow, localChatTab, and Actions::msg().

processScriptMessage()

void TmwAthena::ChatRecv::processScriptMessage

(

Net::MessageIn &

msg

)

Definition at line 414 of file chatrecv.cpp.

{
    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);
}

References ChatMsgType::BY_SERVER, ChatTab::chatLog(), IgnoreRecord_false, localChatTab, Actions::msg(), and TryRemoveColors_true.

processWhisper()

void TmwAthena::ChatRecv::processWhisper

(

Net::MessageIn &

msg

)

Definition at line 148 of file chatrecv.cpp.

{
    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"));
}

References BLOCK_END, BLOCK_START, Actions::msg(), and EAthena::ChatRecv::processWhisperContinue().

processWhisperContinue()

void TmwAthena::ChatRecv::processWhisperContinue	(	const std::string &	nick,
		std::string	chatMsg
	)

Definition at line 171 of file chatrecv.cpp.

{
    // 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")
}

References _, ChatWindow::addWhisper(), BLOCK_END, ShopWindow::BUY, ChatMsgType::BY_OTHER, ChatMsgType::BY_SERVER, ChatTab::chatLog(), chatWindow, config, debugMsg, Configuration::getBoolValue(), GuildManager::getEnableGuildBot(), ShopWindow::giveList(), gmChatTab, guildManager, PlayerRelationsManager::hasPermission(), IgnoreRecord_false, localChatTab, mShopRequestName, playerRelations, GuildManager::processGuildMessage(), ShopWindow::processRequest(), ShopWindow::SELL, shopWindow, ShopWindow::showList(), strprintf(), strStartWith(), PlayerRelation::TRADE, TryRemoveColors_true, and PlayerRelation::WHISPER.

processWhisperResponse()

void TmwAthena::ChatRecv::processWhisperResponse

(

Net::MessageIn &

msg

)

Definition at line 163 of file chatrecv.cpp.

{
    BLOCK_START("ChatRecv::processWhisperResponse")
 
    const uint8_t type = msg.readUInt8("response");
    Ea::ChatRecv::processWhisperResponseContinue(msg, type);
}

References BLOCK_START, Actions::msg(), and Ea::ChatRecv::processWhisperResponseContinue().

Variable Documentation

mShopRequestName

std::string TmwAthena::ChatRecv::mShopRequestName

Definition at line 57 of file chatrecv.cpp.

Referenced by processWhisperContinue(), TmwAthena::BuySellHandler::requestBuyList(), and TmwAthena::BuySellHandler::requestSellList().