AddonChannelCommandHandler Class Reference

#include "Chat.h"

Inheritance diagram for AddonChannelCommandHandler:

Public Member Functions
bool	ParseCommands (std::string_view str) override
void	SendSysMessage (std::string_view str, bool escapeCharacters) override
bool	IsHumanReadable () const override
	ChatHandler (WorldSession *session)
	ChatHandler ()
virtual void	SendSysMessage (std::string_view str, bool escapeCharacters=false)
void	SendSysMessage (uint32 entry)
Public Member Functions inherited from ChatHandler
	ChatHandler (WorldSession *session)
virtual	~ChatHandler ()
void	SendNotification (std::string_view str)
template<typename... Args>
void	SendNotification (uint32 strId, Args &&... args)
template<typename... Args>
void	SendNotification (char const *fmt, Args &&... args)
void	SendGMText (std::string_view str)
template<typename... Args>
void	SendGMText (uint32 strId, Args &&... args)
template<typename... Args>
void	SendGMText (char const *fmt, Args &&... args)
void	SendWorldText (std::string_view str)
template<typename... Args>
void	SendWorldText (uint32 strId, Args &&... args)
template<typename... Args>
void	SendWorldText (char const *fmt, Args &&... args)
void	SendWorldTextOptional (std::string_view str, uint32 flag)
template<typename... Args>
void	SendWorldTextOptional (uint32 strId, uint32 flag, Args &&... args)
template<typename... Args>
void	SendWorldTextOptional (char const *fmt, uint32 flag, Args &&... args)
virtual char const *	GetAcoreString (uint32 entry) const
virtual void	SendSysMessage (std::string_view str, bool escapeCharacters=false)
void	SendSysMessage (uint32 entry)
void	PSendSysMessage (std::string_view str, bool escapeCharacters=false)
template<typename... Args>
void	PSendSysMessage (char const *fmt, Args &&... args)
template<typename... Args>
void	PSendSysMessage (uint32 entry, Args &&... args)
template<typename... Args>
std::string	PGetParseString (uint32 entry, Args &&... args) const
std::string const *	GetModuleString (std::string module, uint32 id) const
template<typename... Args>
void	PSendModuleSysMessage (std::string module, uint32 id, Args &&... args)
template<typename... Args>
std::string	PGetParseModuleString (std::string module, uint32 id, Args &&... args) const
void	SendErrorMessage (uint32 entry)
void	SendErrorMessage (std::string_view str, bool escapeCharacters)
template<typename... Args>
void	SendErrorMessage (char const *fmt, Args &&... args)
template<typename... Args>
void	SendErrorMessage (uint32 entry, Args &&... args)
bool	_ParseCommands (std::string_view text)
virtual bool	ParseCommands (std::string_view text)
void	SendGlobalSysMessage (const char *str)
virtual bool	IsHumanReadable () const
virtual std::string	GetNameLink () const
virtual bool	needReportToTarget (Player *chr) const
virtual LocaleConstant	GetSessionDbcLocale () const
virtual int	GetSessionDbLocaleIndex () const
bool	HasLowerSecurity (Player *target, ObjectGuid guid=ObjectGuid::Empty, bool strong=false)
bool	HasLowerSecurityAccount (WorldSession *target, uint32 account, bool strong=false)
void	SendGlobalGMSysMessage (const char *str)
Player *	getSelectedPlayer () const
Creature *	getSelectedCreature () const
Unit *	getSelectedUnit () const
WorldObject *	getSelectedObject () const
Player *	getSelectedPlayerOrSelf () const
virtual bool	HasSession () const
void	DoForAllValidSessions (std::function< void(Player *)> exec)
char *	extractKeyFromLink (char *text, char const *linkType, char **something1=nullptr)
char *	extractKeyFromLink (char *text, char const *const *linkTypes, int *found_idx, char **something1=nullptr)
char *	extractQuotedArg (char *args)
uint32	extractSpellIdFromLink (char *text)
ObjectGuid::LowType	extractLowGuidFromLink (char *text, HighGuid &guidHigh)
bool	GetPlayerGroupAndGUIDByName (const char *cname, Player *&player, Group *&group, ObjectGuid &guid, bool offline=false)
std::string	extractPlayerNameFromLink (char *text)
bool	extractPlayerTarget (char *args, Player **player, ObjectGuid *player_guid=nullptr, std::string *player_name=nullptr)
std::string	playerLink (std::string const &name) const
std::string	GetNameLink (Player *chr) const
GameObject *	GetNearbyGameObject () const
GameObject *	GetObjectFromPlayerMapByDbGuid (ObjectGuid::LowType lowguid)
Creature *	GetCreatureFromPlayerMapByDbGuid (ObjectGuid::LowType lowguid)
bool	HasSentErrorMessage () const
void	SetSentErrorMessage (bool val)
bool	IsConsole () const
Player *	GetPlayer () const
WorldSession *	GetSession ()
bool	IsAvailable (uint32 securityLevel) const

Private Member Functions
void	Send (std::string const &msg)
void	SendAck ()
void	SendOK ()
void	SendFailed ()

Private Attributes
std::string	echo
bool	hadAck = false
bool	humanReadable = false

Additional Inherited Members
Static Public Member Functions inherited from ChatHandler
static std::size_t	BuildChatPacket (WorldPacket &data, ChatMsg chatType, Language language, ObjectGuid senderGUID, ObjectGuid receiverGUID, std::string_view message, uint8 chatTag, std::string const &senderName="", std::string const &receiverName="", uint32 achievementId=0, bool gmMessage=false, std::string const &channelName="")
static std::size_t	BuildChatPacket (WorldPacket &data, ChatMsg chatType, Language language, WorldObject const *sender, WorldObject const *receiver, std::string_view message, uint32 achievementId=0, std::string const &channelName="", LocaleConstant locale=DEFAULT_LOCALE)
static char *	LineFromMessage (char *&pos)
Protected Member Functions inherited from ChatHandler
	ChatHandler ()

Detailed Description

Member Function Documentation

ChatHandler() [1/2]

ChatHandler::ChatHandler ( )

inlineexplicit

: m_session(nullptr), sentErrorMessage(false) {}      // for CLI subclass

ChatHandler() [2/2]

ChatHandler::ChatHandler ( WorldSession *  session )

inlineexplicit

: m_session(session), sentErrorMessage(false) {}

IsHumanReadable()

bool AddonChannelCommandHandler::IsHumanReadable ( ) const

inlineoverridevirtual

Reimplemented from ChatHandler.

{ return humanReadable; }

ParseCommands()

bool AddonChannelCommandHandler::ParseCommands ( std::string_view  str )

overridevirtual

Reimplemented from ChatHandler.

{
    if (memcmp(str.data(), "AzerothCore\t", 12))
        return false;
    char opcode = str[12];
    if (!opcode) // str[12] is opcode
        return false;
    if (!str[13] || !str[14] || !str[15] || !str[16]) // str[13] through str[16] is 4-character command counter
        return false;
    echo = str.substr(13);
 
    switch (opcode)
    {
        case 'p': // p Ping
            SendAck();
            return true;
        case 'h': // h Issue human-readable command
        case 'i': // i Issue command
            if (!str[17])
                return false;
            humanReadable = (opcode == 'h');
            if (_ParseCommands(str.substr(17))) // actual command starts at str[17]
            {
                if (!hadAck)
                    SendAck();
                if (HasSentErrorMessage())
                    SendFailed();
                else
                    SendOK();
            }
            else
            {
                SendSysMessage(LANG_CMD_INVALID);
                SendFailed();
            }
            return true;
        default:
            return false;
    }
}

References ChatHandler::_ParseCommands(), echo, hadAck, ChatHandler::HasSentErrorMessage(), humanReadable, LANG_CMD_INVALID, SendAck(), SendFailed(), SendOK(), and SendSysMessage().

Send()

void AddonChannelCommandHandler::Send ( std::string const &  msg )

private

{
    WorldPacket data;
    ChatHandler::BuildChatPacket(data, CHAT_MSG_WHISPER, LANG_ADDON, GetSession()->GetPlayer(), GetSession()->GetPlayer(), msg);
    GetSession()->SendPacket(&data);
}

References ChatHandler::BuildChatPacket(), CHAT_MSG_WHISPER, ChatHandler::GetPlayer(), ChatHandler::GetSession(), LANG_ADDON, and WorldSession::SendPacket().

Referenced by SendAck(), SendFailed(), SendOK(), and SendSysMessage().

SendAck()

void AddonChannelCommandHandler::SendAck ( )

private

{
    ASSERT(echo.size());
    std::string ack = "AzerothCore\ta";
    ack.resize(18);
    memcpy(&ack[13], echo.data(), 4);
    ack[17] = '\0';
    Send(ack);
    hadAck = true;
}

References ASSERT, echo, hadAck, and Send().

Referenced by ParseCommands(), and SendSysMessage().

SendFailed()

void AddonChannelCommandHandler::SendFailed ( )

private

{
    ASSERT(echo.size());
    std::string fail = "AzerothCore\tf";
    fail.resize(18);
    memcpy(&fail[13], echo.data(), 4);
    fail[17] = '\0';
    Send(fail);
}

References ASSERT, echo, and Send().

Referenced by ParseCommands().

SendOK()

void AddonChannelCommandHandler::SendOK ( )

private

{
    ASSERT(echo.size());
    std::string ok = "AzerothCore\to";
    ok.resize(18);
    memcpy(&ok[13], echo.data(), 4);
    ok[17] = '\0';
    Send(ok);
}

References ASSERT, echo, and Send().

Referenced by ParseCommands().

SendSysMessage() [1/3]

void AddonChannelCommandHandler::SendSysMessage ( std::string_view  str, bool  escapeCharacters  )

overridevirtual

Reimplemented from ChatHandler.

{
    ASSERT(echo.size());
    if (!hadAck)
        SendAck();
 
    std::string msg = "AzerothCore\tm";
    msg.append(echo.data(), 4);
    std::string body(str);
    if (escapeCharacters)
        boost::replace_all(body, "|", "||");
    std::size_t pos, lastpos;
    for (lastpos = 0, pos = body.find('\n', lastpos); pos != std::string::npos; lastpos = pos + 1, pos = body.find('\n', lastpos))
    {
        std::string line(msg);
        line.append(body, lastpos, pos - lastpos);
        Send(line);
    }
    msg.append(body, lastpos, pos - lastpos);
    Send(msg);
}

References ASSERT, echo, hadAck, Send(), and SendAck().

Referenced by ParseCommands().

SendSysMessage() [2/3]

void ChatHandler::SendSysMessage ( std::string_view  str, bool  escapeCharacters = false  )

virtual

Reimplemented from ChatHandler.

{
    std::string msg{ str };
 
    // Replace every "|" with "||" in msg
    if (escapeCharacters && msg.find('|') != std::string::npos)
    {
        std::vector<std::string_view> tokens = Acore::Tokenize(msg, '|', true);
        std::ostringstream stream;
 
        for (std::size_t i = 0; i < tokens.size() - 1; ++i)
            stream << tokens[i] << "||";
 
        stream << tokens[tokens.size() - 1];
 
        msg = stream.str();
    }
 
    WorldPacket data;
    for (std::string_view line : Acore::Tokenize(str, '\n', true))
    {
        BuildChatPacket(data, CHAT_MSG_SYSTEM, LANG_UNIVERSAL, nullptr, nullptr, line);
        m_session->SendPacket(&data);
    }
}

SendSysMessage() [3/3]

void ChatHandler::SendSysMessage

(

uint32

entry

)

{
    SendSysMessage(GetAcoreString(entry));
}

References ChatHandler::BuildChatPacket(), CHAT_MSG_SYSTEM, LANG_UNIVERSAL, ChatHandler::m_session, and WorldSession::SendPacket().

Member Data Documentation

echo

std::string AddonChannelCommandHandler::echo

private

Referenced by ParseCommands(), SendAck(), SendFailed(), SendOK(), and SendSysMessage().

hadAck

bool AddonChannelCommandHandler::hadAck = false

private

Referenced by ParseCommands(), SendAck(), and SendSysMessage().

humanReadable

bool AddonChannelCommandHandler::humanReadable = false

private

Referenced by ParseCommands().