コード例 #1
0
ファイル: ChannelHandler.cpp プロジェクト: master312/AscEmu
void WorldSession::HandleChannelJoin(WorldPacket& recvPacket)
{
    CHECK_INWORLD_RETURN

    CHECK_PACKET_SIZE(recvPacket, 1);
    std::string channelname, pass;
    uint32 channel_id;

    recvPacket >> channel_id;
    recvPacket.readBit();       // has voice
    recvPacket.readBit();       // zone update

    uint8 channelLength = recvPacket.readBits(8);
    uint8 passwordLength = recvPacket.readBits(8);

    channelname = recvPacket.ReadString(channelLength);
    pass = recvPacket.ReadString(passwordLength);

    if (sWorld.settings.gm.gmClientChannelName.size() && !stricmp(sWorld.settings.gm.gmClientChannelName.c_str(), channelname.c_str()) && !GetPermissionCount())
        return;

    Channel* channel = channelmgr.GetCreateChannel(channelname.c_str(), _player, channel_id);
    if (channel == nullptr)
        return;

    channel->AttemptJoin(_player, pass.c_str());
    LogDebugFlag(LF_OPCODE, "ChannelJoin %s", channelname.c_str());
}
コード例 #2
0
ファイル: MailHandler.cpp プロジェクト: armm77/AscEmu
void WorldSession::HandleSendMail(WorldPacket& recvData)
{
    MailMessage msg;
    ObjectGuid mailbox;
    uint32_t unk1, unk2;
    uint64_t money, COD;

    std::vector< Item* > items;
    Item* pItem;

    recvData >> unk1;
    recvData >> unk2;

    recvData >> COD;
    recvData >> money;

    uint32_t bodyLength = recvData.readBits(12);
    uint32_t subjectLength = recvData.readBits(9);

    uint8_t items_count = static_cast<uint8_t>(recvData.readBits(5));              // attached items count

    if (items_count > MAIL_MAX_ITEM_SLOT)
    {
        SendMailError(MAIL_ERR_TOO_MANY_ATTACHMENTS);
        return;
    }

    mailbox[0] = recvData.readBit();

    ObjectGuid itemGUIDs[MAIL_MAX_ITEM_SLOT];

    for (uint8_t i = 0; i < items_count; ++i)
    {
        itemGUIDs[i][2] = recvData.readBit();
        itemGUIDs[i][6] = recvData.readBit();
        itemGUIDs[i][3] = recvData.readBit();
        itemGUIDs[i][7] = recvData.readBit();
        itemGUIDs[i][1] = recvData.readBit();
        itemGUIDs[i][0] = recvData.readBit();
        itemGUIDs[i][4] = recvData.readBit();
        itemGUIDs[i][5] = recvData.readBit();
    }

    mailbox[3] = recvData.readBit();
    mailbox[4] = recvData.readBit();
    uint32_t receiverLength = recvData.readBits(7);
    mailbox[2] = recvData.readBit();
    mailbox[6] = recvData.readBit();
    mailbox[1] = recvData.readBit();
    mailbox[7] = recvData.readBit();
    mailbox[5] = recvData.readBit();

    recvData.ReadByteSeq(mailbox[4]);

    for (uint8_t i = 0; i < items_count; ++i)
    {
        recvData.ReadByteSeq(itemGUIDs[i][6]);
        recvData.ReadByteSeq(itemGUIDs[i][1]);
        recvData.ReadByteSeq(itemGUIDs[i][7]);
        recvData.ReadByteSeq(itemGUIDs[i][2]);
        recvData.read_skip<uint8_t>();            // item slot in mail, not used
        recvData.ReadByteSeq(itemGUIDs[i][3]);
        recvData.ReadByteSeq(itemGUIDs[i][0]);
        recvData.ReadByteSeq(itemGUIDs[i][4]);
        recvData.ReadByteSeq(itemGUIDs[i][5]);
    }

    recvData.ReadByteSeq(mailbox[7]);
    recvData.ReadByteSeq(mailbox[3]);
    recvData.ReadByteSeq(mailbox[6]);
    recvData.ReadByteSeq(mailbox[5]);

    std::string subject = recvData.ReadString(subjectLength);
    std::string receiver = recvData.ReadString(receiverLength);

    recvData.ReadByteSeq(mailbox[2]);
    recvData.ReadByteSeq(mailbox[0]);

    std::string body = recvData.ReadString(bodyLength);

    recvData.ReadByteSeq(mailbox[1]);

    // Search for the recipient
    PlayerInfo* player_info = ObjectMgr::getSingleton().GetPlayerInfoByName(receiver.c_str());
    if (!player_info)
    {
        SendMailError(MAIL_ERR_RECIPIENT_NOT_FOUND);
        return;
    }

    for (uint8_t i = 0; i < items_count; ++i)
    {
        pItem = _player->GetItemInterface()->GetItemByGUID(itemGUIDs[i]);
        if (pItem == nullptr || pItem->isSoulbound() || pItem->hasFlags(ITEM_FLAG_CONJURED))
        {
            SendMailError(MAIL_ERR_INTERNAL_ERROR);
            return;
        }
        if (pItem->isAccountbound() && GetAccountId() != player_info->acct) // don't mail account-bound items to another account
        {
            WorldPacket data(SMSG_SEND_MAIL_RESULT, 16);
            data << uint32_t(0);
            data << uint32_t(0);
            data << uint32_t(MAIL_ERR_BAG_FULL);
            data << uint32_t(INV_ERR_ARTEFACTS_ONLY_FOR_OWN_CHARACTERS);
            SendPacket(&data);
            return;
        }

        items.push_back(pItem);
    }

    if (receiver.empty())
        return;

    bool interfaction = false;
    if (sMailSystem.MailOption(MAIL_FLAG_CAN_SEND_TO_OPPOSITE_FACTION) || (HasGMPermissions() && sMailSystem.MailOption(MAIL_FLAG_CAN_SEND_TO_OPPOSITE_FACTION_GM)))
    {
        interfaction = true;
    }

    // Check we're sending to the same faction (disable this for testing)
    if (player_info->team != _player->GetTeam() && !interfaction)
    {
        SendMailError(MAIL_ERR_NOT_YOUR_ALLIANCE);
        return;
    }

    // Check if we're sending mail to ourselves
    if (strcmp(player_info->name, _player->GetName()) == 0 && !GetPermissionCount())
    {
        SendMailError(MAIL_ERR_CANNOT_SEND_TO_SELF);
        return;
    }

    if (msg.stationery == MAIL_STATIONERY_GM && !HasGMPermissions())
    {
        SendMailError(MAIL_ERR_INTERNAL_ERROR);
        return;
    }

    // Instant delivery time by default.
    msg.delivery_time = (uint32_t)UNIXTIME;

    // Set up the cost
    uint32_t cost = items_count ? 30 * items_count : 30;  // price hardcoded in client

    if (!sMailSystem.MailOption(MAIL_FLAG_DISABLE_POSTAGE_COSTS) && !(GetPermissionCount() && sMailSystem.MailOption(MAIL_FLAG_NO_COST_FOR_GM)))
    {
        cost += 30;
    }

    // check that we have enough in our backpack
    if (!_player->HasGold(cost))
    {
        SendMailError(MAIL_ERR_NOT_ENOUGH_MONEY);
        return;
    }

    // Check for the item, and required item.
    if (!items.empty())
    {
        for (std::vector< Item* >::iterator itr = items.begin(); itr != items.end(); ++itr)
        {
            pItem = *itr;
            if (_player->GetItemInterface()->SafeRemoveAndRetreiveItemByGuid(pItem->getGuid(), false) != pItem)
                continue;        // should never be hit.

            pItem->RemoveFromWorld();
            pItem->setOwner(NULL);
            pItem->SaveToDB(INVENTORY_SLOT_NOT_SET, 0, true, NULL);
            msg.items.push_back(pItem->getGuidLow());

            if (GetPermissionCount() > 0)
            {
                /* log the message */
                sGMLog.writefromsession(this, "sent mail with item entry %u to %s, with gold %u.", pItem->getEntry(), player_info->name, money);
            }

            pItem->DeleteMe();
        }
    }

    if (money != 0 || COD != 0 || (!items.size() && player_info->acct != _player->GetSession()->GetAccountId()))
    {
        if (!sMailSystem.MailOption(MAIL_FLAG_DISABLE_HOUR_DELAY_FOR_ITEMS))
            msg.delivery_time += 3600;  // 1hr
    }

    // take the money
    _player->ModGold(-static_cast<int32_t>(cost));

    // Fill in the rest of the info
    msg.player_guid = player_info->guid;
    msg.sender_guid = _player->getGuid();
    msg.money = static_cast<uint32_t>(money);
    msg.cod = static_cast<uint32_t>(COD);
    msg.subject = subject;
    msg.body = body;

    // 30 day expiry time for unread mail
    if (!sMailSystem.MailOption(MAIL_FLAG_NO_EXPIRY))
        msg.expire_time = (uint32_t)UNIXTIME + (TIME_DAY * MAIL_DEFAULT_EXPIRATION_TIME);
    else
        msg.expire_time = 0;

    msg.deleted_flag = false;
    msg.message_type = 0;
    msg.checked_flag = msg.body.empty() ? MAIL_CHECK_MASK_COPIED : MAIL_CHECK_MASK_HAS_BODY;

    // Great, all our info is filled in. Now we can add it to the other players mailbox.
    sMailSystem.DeliverMessage(player_info->guid, &msg);
    // Save/Update character's gold if they've received gold that is. This prevents a rollback.
    CharacterDatabase.Execute("UPDATE characters SET gold = %u WHERE guid = %u", _player->GetGold(), _player->m_playerInfo->guid);
    // Success packet :)
    SendMailError(MAIL_OK);
}
コード例 #3
0
ファイル: ChatHandler.cpp プロジェクト: Tulba/AscEmu_CATA
void WorldSession::HandleMessagechatOpcode(WorldPacket& recv_data)
{
    CHECK_INWORLD_RETURN

    //CHECK_PACKET_SIZE(recv_data, 9);
    WorldPacket* data = NULL;

    uint32 type;
    int32 lang;

    const char* pMisc = NULL;
    const char* pMsg = NULL;

    switch (recv_data.GetOpcode())
    {
        case CMSG_MESSAGECHAT_SAY:
            type = CHAT_MSG_SAY;
            break;
        case CMSG_MESSAGECHAT_YELL:
            type = CHAT_MSG_YELL;
            break;
        case CMSG_MESSAGECHAT_CHANNEL:
            type = CHAT_MSG_CHANNEL;
            break;
        case CMSG_MESSAGECHAT_WHISPER:
            type = CHAT_MSG_WHISPER;
            break;
        case CMSG_MESSAGECHAT_GUILD:
            type = CHAT_MSG_GUILD;
            break;
        case CMSG_MESSAGECHAT_OFFICER:
            type = CHAT_MSG_OFFICER;
            break;
        case CMSG_MESSAGECHAT_AFK:
            type = CHAT_MSG_AFK;
            break;
        case CMSG_MESSAGECHAT_DND:
            type = CHAT_MSG_DND;
            break;
        case CMSG_MESSAGECHAT_EMOTE:
            type = CHAT_MSG_EMOTE;
            break;
        case CMSG_MESSAGECHAT_PARTY:
            type = CHAT_MSG_PARTY;
            break;
        case CMSG_MESSAGECHAT_RAID:
            type = CHAT_MSG_RAID;
            break;
        case CMSG_MESSAGECHAT_BATTLEGROUND:
            type = CHAT_MSG_BATTLEGROUND;
            break;
        case CMSG_MESSAGECHAT_RAID_WARNING:
            type = CHAT_MSG_RAID_WARNING;
            break;
        default:
            sLog.outError("HandleMessagechatOpcode : Unknown chat opcode (0x%X)", recv_data.GetOpcode());
            recv_data.clear();
            return;
    }

    recv_data >> lang;

    if (lang >= NUM_LANGUAGES)
        return;

    if (GetPlayer()->IsBanned())
    {
        GetPlayer()->BroadcastMessage("You cannot do that when banned.");
        return;
    }

    // Flood protection
    if (lang != -1 && !GetPermissionCount() && sWorld.flood_lines != 0)
    {
        /* flood detection, wheeee! */
        if (UNIXTIME >= floodTime)
        {
            floodLines = 0;
            floodTime = UNIXTIME + sWorld.flood_seconds;
        }

        if ((++floodLines) > sWorld.flood_lines)
        {
            if (sWorld.flood_message)
                _player->BroadcastMessage("Your message has triggered serverside flood protection. You can speak again in %u seconds.", floodTime - UNIXTIME);

            return;
        }
    }

    switch (type)
    {
        case CHAT_MSG_EMOTE:
        case CHAT_MSG_SAY:
        case CHAT_MSG_YELL:
        case CHAT_MSG_WHISPER:
        case CHAT_MSG_CHANNEL:
        case CHAT_MSG_PARTY:
        case CHAT_MSG_PARTY_LEADER:
        case CHAT_MSG_BATTLEGROUND:
        case CHAT_MSG_BATTLEGROUND_LEADER:
        case CHAT_MSG_RAID:
        case CHAT_MSG_RAID_WARNING:
        case CHAT_MSG_RAID_LEADER:
        case CHAT_MSG_GUILD:
        case CHAT_MSG_OFFICER:
        {
            if (m_muted && m_muted >= (uint32)UNIXTIME)
            {
                SystemMessage("Your voice is currently muted by a moderator.");
                return;
            }
        }
        break;
    }

    std::string msg, to = "", channel = "", tmp;
    msg.reserve(256);

    // Process packet
    switch (type)
    {
        case CHAT_MSG_SAY:
            msg = recv_data.ReadString(recv_data.readBits(9));
            break;
        default:
            LOG_ERROR("CHAT: unknown msg type %u, lang: %u", type, lang);
    }


    if (int(msg.find("|T")) > -1)
    {
        GetPlayer()->BroadcastMessage("Don't even THINK about doing that again");
        return;
    }

    // HookInterface OnChat event
    if (pMsg && !sHookInterface.OnChat(_player, type, lang, pMsg, pMisc))
        return;

    Channel* chn = NULL;
    // Main chat message processing
    switch (type)
    {
        case CHAT_MSG_EMOTE:
        {
            if (sWorld.interfaction_chat && lang > 0)
                lang = 0;

            if (g_chatFilter->Parse(msg))
            {
                SystemMessage("Your chat message was blocked by a server-side filter.");
                return;
            }

            if (GetPlayer()->m_modlanguage >= 0)
                data = sChatHandler.FillMessageData(CHAT_MSG_EMOTE, GetPlayer()->m_modlanguage, msg.c_str(), _player->GetGUID(), _player->HasFlag(PLAYER_FLAGS, PLAYER_FLAG_GM) ? 4 : 0);
            else if (lang == 0 && sWorld.interfaction_chat)
                data = sChatHandler.FillMessageData(CHAT_MSG_EMOTE, CanUseCommand('0') ? LANG_UNIVERSAL : lang, msg.c_str(), _player->GetGUID(), _player->HasFlag(PLAYER_FLAGS, PLAYER_FLAG_GM) ? 4 : 0);
            else
                data = sChatHandler.FillMessageData(CHAT_MSG_EMOTE, CanUseCommand('c') ? LANG_UNIVERSAL : lang, msg.c_str(), _player->GetGUID(), _player->HasFlag(PLAYER_FLAGS, PLAYER_FLAG_GM) ? 4 : 0);

            GetPlayer()->SendMessageToSet(data, true, !sWorld.interfaction_chat);

            //sLog.outString("[emote] %s: %s", _player->GetName(), msg.c_str());
            delete data;

        }
        break;
        case CHAT_MSG_SAY:
        {
            if (sWorld.interfaction_chat && lang > 0)
                lang = 0;

            if (sChatHandler.ParseCommands(msg.c_str(), this) > 0)
                break;

            if (g_chatFilter->Parse(msg))
            {
                SystemMessage("Your chat message was blocked by a server-side filter.");
                return;
            }

            if (GetPlayer()->m_modlanguage >= 0)
            {
                data = sChatHandler.FillMessageData(CHAT_MSG_SAY, GetPlayer()->m_modlanguage, msg.c_str(), _player->GetGUID(), _player->HasFlag(PLAYER_FLAGS, PLAYER_FLAG_GM) ? 4 : 0);
                GetPlayer()->SendMessageToSet(data, true);
            }
            else
            {
                if (lang > 0 && LanguageSkills[lang] && !_player->_HasSkillLine(LanguageSkills[lang]))
                    return;

                if (lang == 0 && !CanUseCommand('c') && !sWorld.interfaction_chat)
                    return;

                data = sChatHandler.FillMessageData(CHAT_MSG_SAY, lang, msg.c_str(), _player->GetGUID(), _player->HasFlag(PLAYER_FLAGS, PLAYER_FLAG_GM) ? 4 : 0);

                GetPlayer()->SendMessageToSet(data, true);
            }
            delete data;

        }
        break;
        case CHAT_MSG_PARTY:
        case CHAT_MSG_PARTY_LEADER:
        case CHAT_MSG_RAID:
        case CHAT_MSG_RAID_LEADER:
        case CHAT_MSG_RAID_WARNING:
        {
            if (sChatHandler.ParseCommands(msg.c_str(), this) > 0)
                break;

            if (sWorld.interfaction_chat && lang > 0)
                lang = 0;

            if (g_chatFilter->Parse(msg) == true)
            {
                SystemMessage("Your chat message was blocked by a server-side filter.");
                return;
            }

            Group* pGroup = _player->GetGroup();
            if (pGroup == NULL) break;

            if (GetPlayer()->m_modlanguage >= 0)
                data = sChatHandler.FillMessageData(type, GetPlayer()->m_modlanguage, msg.c_str(), _player->GetGUID(), _player->HasFlag(PLAYER_FLAGS, PLAYER_FLAG_GM) ? 4 : 0);
            else if (lang == 0 && sWorld.interfaction_chat)
                data = sChatHandler.FillMessageData(type, (CanUseCommand('0') && lang != -1) ? LANG_UNIVERSAL : lang, msg.c_str(), _player->GetGUID(), _player->HasFlag(PLAYER_FLAGS, PLAYER_FLAG_GM) ? 4 : 0);
            else
                data = sChatHandler.FillMessageData(type, (CanUseCommand('c') && lang != -1) ? LANG_UNIVERSAL : lang, msg.c_str(), _player->GetGUID(), _player->HasFlag(PLAYER_FLAGS, PLAYER_FLAG_GM) ? 4 : 0);
            if (type == CHAT_MSG_PARTY && pGroup->GetGroupType() == GROUP_TYPE_RAID)
            {
                // only send to that subgroup
                SubGroup* sgr = _player->GetGroup() ?
                    _player->GetGroup()->GetSubGroup(_player->GetSubGroup()) : 0;

                if (sgr)
                {
                    _player->GetGroup()->Lock();
                    for (GroupMembersSet::iterator itr = sgr->GetGroupMembersBegin(); itr != sgr->GetGroupMembersEnd(); ++itr)
                    {
                        if ((*itr)->m_loggedInPlayer)
                            (*itr)->m_loggedInPlayer->GetSession()->SendChatPacket(data, 1, lang, this);
                    }
                    _player->GetGroup()->Unlock();
                }
            }
            else
            {
                SubGroup* sgr;
                for (uint32 i = 0; i < _player->GetGroup()->GetSubGroupCount(); ++i)
                {
                    sgr = _player->GetGroup()->GetSubGroup(i);
                    _player->GetGroup()->Lock();
                    for (GroupMembersSet::iterator itr = sgr->GetGroupMembersBegin(); itr != sgr->GetGroupMembersEnd(); ++itr)
                    {
                        if ((*itr)->m_loggedInPlayer)
                            (*itr)->m_loggedInPlayer->GetSession()->SendChatPacket(data, 1, lang, this);
                    }
                    _player->GetGroup()->Unlock();

                }
            }
            //sLog.outString("[party] %s: %s", _player->GetName(), msg.c_str());
            delete data;
        }
        break;
        case CHAT_MSG_GUILD:
        {
            if (sChatHandler.ParseCommands(msg.c_str(), this) > 0)
            {
                break;
            }

            if (g_chatFilter->Parse(msg) == true)
            {
                SystemMessage("Your chat message was blocked by a server-side filter.");
                return;
            }

            if (_player->m_playerInfo->guild)
                _player->m_playerInfo->guild->GuildChat(msg.c_str(), this, lang);

        }
        break;
        case CHAT_MSG_OFFICER:
        {
            if (sChatHandler.ParseCommands(msg.c_str(), this) > 0)
                break;

            if (g_chatFilter->Parse(msg) == true)
            {
                SystemMessage("Your chat message was blocked by a server-side filter.");
                return;
            }

            if (_player->m_playerInfo->guild)
                _player->m_playerInfo->guild->OfficerChat(msg.c_str(), this, lang);

        }
        break;
        case CHAT_MSG_YELL:
        {
            if (sWorld.interfaction_chat && lang > 0)
                lang = 0;

            if (sChatHandler.ParseCommands(msg.c_str(), this) > 0)
                break;

            if (g_chatFilter->Parse(msg) == true)
            {
                SystemMessage("Your chat message was blocked by a server-side filter.");
                return;
            }
            if (lang > 0 && LanguageSkills[lang] && _player->_HasSkillLine(LanguageSkills[lang]) == false)
                return;

            if (lang == 0 && sWorld.interfaction_chat)
                data = sChatHandler.FillMessageData(CHAT_MSG_YELL, (CanUseCommand('0') && lang != -1) ? LANG_UNIVERSAL : lang, msg.c_str(), _player->GetGUID(), _player->HasFlag(PLAYER_FLAGS, PLAYER_FLAG_GM) ? 4 : 0);

            else if (GetPlayer()->m_modlanguage >= 0)
                data = sChatHandler.FillMessageData(CHAT_MSG_YELL, GetPlayer()->m_modlanguage, msg.c_str(), _player->GetGUID(), _player->HasFlag(PLAYER_FLAGS, PLAYER_FLAG_GM) ? 4 : 0);
            else
                data = sChatHandler.FillMessageData(CHAT_MSG_YELL, (CanUseCommand('c') && lang != -1) ? LANG_UNIVERSAL : lang, msg.c_str(), _player->GetGUID(), _player->HasFlag(PLAYER_FLAGS, PLAYER_FLAG_GM) ? 4 : 0);

            _player->GetMapMgr()->SendChatMessageToCellPlayers(_player, data, 2, 1, lang, this);
            delete data;
        }
        break;
        case CHAT_MSG_WHISPER:
        {
            if (lang != -1)
                lang = LANG_UNIVERSAL; //All whispers are universal
            if (g_chatFilter->Parse(msg) == true)
            {
                SystemMessage("Your chat message was blocked by a server-side filter.");
                return;
            }

            PlayerCache* playercache = objmgr.GetPlayerCache(to.c_str(), false);
            if (playercache == NULL)
            {
                data = new WorldPacket(SMSG_CHAT_PLAYER_NOT_FOUND, to.length() + 1);
                *data << to;
                SendPacket(data);
                delete data;
                break;
            }

            if (_player->GetTeamInitial() != playercache->GetUInt32Value(CACHE_PLAYER_INITIALTEAM) && !sWorld.interfaction_chat && !playercache->HasFlag(CACHE_PLAYER_FLAGS, PLAYER_FLAG_GM) && !_player->HasFlag(PLAYER_FLAGS, PLAYER_FLAG_GM))
            {
                WorldPacket response(SMSG_CHAT_PLAYER_NOT_FOUND, to.length() + 1);
                response << to;
                SendPacket(&response);
                playercache->DecRef();
                break;
            }

            // Check that the player isn't a gm with his status on
            ///\todo Game Master's on retail are able to have block whispers after they close the ticket with the current packet.
            // When a Game Master is visible to your player it says "This player is unavailable for whisper" I need to figure out how this done.
            if (!HasPermissions() && playercache->HasFlag(CACHE_PLAYER_FLAGS, PLAYER_FLAG_GM) && playercache->CountValue64(CACHE_GM_TARGETS, _player->GetGUID()) == 0)
            {
                // Build automated reply
                std::string Reply = "SYSTEM: This Game Master does not currently have an open ticket from you and did not receive your whisper. Please submit a new GM Ticket request if you need to speak to a GM. This is an automatic message.";
                data = sChatHandler.FillMessageData(CHAT_MSG_WHISPER_INFORM, LANG_UNIVERSAL, Reply.c_str(), playercache->GetGUID(), 4);
                SendPacket(data);
                delete data;
                playercache->DecRef();
                break;
            }

            if (playercache->CountValue64(CACHE_SOCIAL_IGNORELIST, _player->GetLowGUID()) > 0)
            {
                data = sChatHandler.FillMessageData(CHAT_MSG_IGNORED, LANG_UNIVERSAL, msg.c_str(), playercache->GetGUID(), _player->HasFlag(PLAYER_FLAGS, PLAYER_FLAG_GM) ? 4 : 0);
                SendPacket(data);
                delete data;
                playercache->DecRef();
                break;
            }
            else
            {
                data = sChatHandler.FillMessageData(CHAT_MSG_WHISPER, lang, msg.c_str(), _player->GetGUID(), _player->HasFlag(PLAYER_FLAGS, PLAYER_FLAG_GM) ? 4 : 0);
                playercache->SendPacket(data);
            }


            //Sent the to Users id as the channel, this should be fine as it's not used for whisper
            if (lang != -1) //DO NOT SEND if its an addon message!
            {
                data = sChatHandler.FillMessageData(CHAT_MSG_WHISPER_INFORM, LANG_UNIVERSAL, msg.c_str(), playercache->GetGUID(), playercache->HasFlag(CACHE_PLAYER_FLAGS, PLAYER_FLAG_GM) ? 4 : 0);
                SendPacket(data);
                delete data;
            }

            if (playercache->HasFlag(CACHE_PLAYER_FLAGS, PLAYER_FLAG_AFK))
            {
                // Has AFK flag, autorespond.
                std::string reason;
                playercache->GetStringValue(CACHE_AFK_DND_REASON, reason);

                data = sChatHandler.FillMessageData(CHAT_MSG_AFK, LANG_UNIVERSAL, reason.c_str(), playercache->GetGUID(), _player->HasFlag(PLAYER_FLAGS, PLAYER_FLAG_GM) ? 4 : 0);
                SendPacket(data);
                delete data;
            }
            else if (playercache->HasFlag(CACHE_PLAYER_FLAGS, PLAYER_FLAG_DND))
            {
                // Has DND flag, autorespond.
                std::string reason;
                playercache->GetStringValue(CACHE_AFK_DND_REASON, reason);
                data = sChatHandler.FillMessageData(CHAT_MSG_DND, LANG_UNIVERSAL, reason.c_str(), playercache->GetGUID(), playercache->HasFlag(CACHE_PLAYER_FLAGS, PLAYER_FLAG_GM) ? 4 : 0);
                SendPacket(data);
                delete data;
            }

            playercache->DecRef();

        }
        break;
        case CHAT_MSG_CHANNEL:
        {
            if (g_chatFilter->Parse(msg) == true)
            {
                SystemMessage("Your chat message was blocked by a server-side filter.");
                return;
            }

            if (sChatHandler.ParseCommands(msg.c_str(), this) > 0)
                break;

            chn = channelmgr.GetChannel(channel.c_str(), GetPlayer());
            if (chn)
            {
                //g_chatFilter->ParseEscapeCodes((char*)pMsg, (chn->m_flags & CHANNEL_PACKET_ALLOWLINKS)>0);
                chn->Say(GetPlayer(), msg.c_str(), NULL, false);
            }
        }
        break;
        case CHAT_MSG_AFK:
        {
            std::string reason = "";
            recv_data >> reason;

            GetPlayer()->SetAFKReason(reason);

            if (g_chatFilter->Parse(msg) == true)
            {
                SystemMessage("Your chat message was blocked by a server-side filter.");
                return;
            }

            /* WorldPacket *data, WorldSession* session, uint32 type, uint32 language, const char *channelName, const char *message*/
            if (GetPlayer()->HasFlag(PLAYER_FLAGS, PLAYER_FLAG_AFK))
            {
                GetPlayer()->RemoveFlag(PLAYER_FLAGS, PLAYER_FLAG_AFK);
                if (sWorld.GetKickAFKPlayerTime())
                    sEventMgr.RemoveEvents(GetPlayer(), EVENT_PLAYER_SOFT_DISCONNECT);
            }
            else
            {
                GetPlayer()->SetFlag(PLAYER_FLAGS, PLAYER_FLAG_AFK);

                if (GetPlayer()->m_bg)
                    GetPlayer()->m_bg->RemovePlayer(GetPlayer(), false);

                if (sWorld.GetKickAFKPlayerTime())
                    sEventMgr.AddEvent(GetPlayer(), &Player::SoftDisconnect, EVENT_PLAYER_SOFT_DISCONNECT, sWorld.GetKickAFKPlayerTime(), 1, 0);
            }
        }
        break;
        case CHAT_MSG_DND:
        {
            std::string reason;
            recv_data >> reason;
            GetPlayer()->SetAFKReason(reason);

            if (g_chatFilter->Parse(msg) == true)
            {
                SystemMessage("Your chat message was blocked by a server-side filter.");
                return;
            }

            if (GetPlayer()->HasFlag(PLAYER_FLAGS, PLAYER_FLAG_DND))
                GetPlayer()->RemoveFlag(PLAYER_FLAGS, PLAYER_FLAG_DND);
            else
            {
                GetPlayer()->SetFlag(PLAYER_FLAGS, PLAYER_FLAG_DND);
            }
        }
        break;

        case CHAT_MSG_BATTLEGROUND:
        case CHAT_MSG_BATTLEGROUND_LEADER:
        {
            if (sChatHandler.ParseCommands(msg.c_str(), this) > 0)
                break;

            if (g_chatFilter->Parse(msg) == true)
            {
                SystemMessage("Your chat message was blocked by a server-side filter.");
                return;
            }
            if (_player->m_bg != NULL)
            {
                data = sChatHandler.FillMessageData(type, lang, msg.c_str(), _player->GetGUID());
                _player->m_bg->DistributePacketToTeam(data, _player->GetTeam());
                delete data;
            }
        }
        break;
    }
}