Merge branch 'master' into 4.3.4

Conflicts:
	src/server/game/Chat/ChatLink.cpp
	src/server/game/Entities/Player/Player.cpp
	src/server/game/Handlers/ChannelHandler.cpp
	src/server/scripts/EasternKingdoms/hinterlands.cpp

4 files changed, 484 insertions, 564 deletions

diff --git a/src/server/game/Chat/Channels/Channel.cpp b/src/server/game/Chat/Channels/Channel.cpp
index 3ccab6e5c6c..7bada252da6 100755
--- a/src/server/game/Chat/Channels/Channel.cpp
+++ b/src/server/game/Chat/Channels/Channel.cpp
@@ -25,48 +25,54 @@
 #include "AccountMgr.h"
 #include "Player.h"
 
-Channel::Channel(const std::string& name, uint32 channel_id, uint32 Team) : m_announce(true),
-    m_ownership(true), m_name(name), m_password(""), m_flags(0), m_channelId(channel_id),
-    m_ownerGUID(0), m_Team(Team)
+Channel::Channel(std::string const& name, uint32 channelId, uint32 team):
+    _announce(true),
+    _ownership(true),
+    _IsSaved(false),
+    _flags(0),
+    _channelId(channelId),
+    _Team(team),
+    _ownerGUID(0),
+    _name(name),
+    _password("")
 {
-    m_IsSaved = false;
     // set special flags if built-in channel
-    if (ChatChannelsEntry const* ch = sChatChannelsStore.LookupEntry(channel_id)) // check whether it's a built-in channel
+    if (ChatChannelsEntry const* ch = sChatChannelsStore.LookupEntry(channelId)) // check whether it's a built-in channel
     {
-        m_announce = false;                                 // no join/leave announces
-        m_ownership = false;                                // no ownership handout
+        _announce = false;                                 // no join/leave announces
+        _ownership = false;                                // no ownership handout
 
-        m_flags |= CHANNEL_FLAG_GENERAL;                    // for all built-in channels
+        _flags |= CHANNEL_FLAG_GENERAL;                    // for all built-in channels
 
         if (ch->flags & CHANNEL_DBC_FLAG_TRADE)             // for trade channel
-            m_flags |= CHANNEL_FLAG_TRADE;
+            _flags |= CHANNEL_FLAG_TRADE;
 
         if (ch->flags & CHANNEL_DBC_FLAG_CITY_ONLY2)        // for city only channels
-            m_flags |= CHANNEL_FLAG_CITY;
+            _flags |= CHANNEL_FLAG_CITY;
 
         if (ch->flags & CHANNEL_DBC_FLAG_LFG)               // for LFG channel
-            m_flags |= CHANNEL_FLAG_LFG;
+            _flags |= CHANNEL_FLAG_LFG;
         else                                                // for all other channels
-            m_flags |= CHANNEL_FLAG_NOT_LFG;
+            _flags |= CHANNEL_FLAG_NOT_LFG;
     }
     else                                                    // it's custom channel
     {
-        m_flags |= CHANNEL_FLAG_CUSTOM;
+        _flags |= CHANNEL_FLAG_CUSTOM;
 
         // If storing custom channels in the db is enabled either load or save the channel
         if (sWorld->getBoolConfig(CONFIG_PRESERVE_CUSTOM_CHANNELS))
         {
             PreparedStatement *stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHANNEL);
             stmt->setString(0, name);
-            stmt->setUInt32(1, m_Team);
+            stmt->setUInt32(1, _Team);
             PreparedQueryResult result = CharacterDatabase.Query(stmt);
 
             if (result) //load
             {
                 Field* fields = result->Fetch();
-                m_announce = fields[0].GetBool();
-                m_ownership = fields[1].GetBool();
-                m_password  = fields[2].GetString();
+                _announce = fields[0].GetBool();
+                _ownership = fields[1].GetBool();
+                _password  = fields[2].GetString();
                 const char* db_BannedList = fields[3].GetCString();
 
                 if (db_BannedList)
@@ -77,8 +83,8 @@ Channel::Channel(const std::string& name, uint32 channel_id, uint32 Team) : m_an
                         uint64 banned_guid = atol(*i);
                         if (banned_guid)
                         {
-                            sLog->outDebug(LOG_FILTER_CHATSYS, "Channel(%s) loaded banned guid:" UI64FMTD "", name.c_str(), banned_guid);
-                            banned.insert(banned_guid);
+                            sLog->outDebug(LOG_FILTER_CHATSYS, "Channel(%s) loaded bannedStore guid:" UI64FMTD "", name.c_str(), banned_guid);
+                            bannedStore.insert(banned_guid);
                         }
                     }
                 }
@@ -87,45 +93,45 @@ Channel::Channel(const std::string& name, uint32 channel_id, uint32 Team) : m_an
             {
                 stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_CHANNEL);
                 stmt->setString(0, name);
-                stmt->setUInt32(1, m_Team);
+                stmt->setUInt32(1, _Team);
                 CharacterDatabase.Execute(stmt);
                 sLog->outDebug(LOG_FILTER_CHATSYS, "Channel(%s) saved in database", name.c_str());
             }
 
-            m_IsSaved = true;
+            _IsSaved = true;
         }
     }
 }
 
 void Channel::UpdateChannelInDB() const
 {
-    if (m_IsSaved)
+    if (_IsSaved)
     {
         std::ostringstream banlist;
-        BannedList::const_iterator iter;
-        for (iter = banned.begin(); iter != banned.end(); ++iter)
+        BannedContainer::const_iterator iter;
+        for (iter = bannedStore.begin(); iter != bannedStore.end(); ++iter)
             banlist << (*iter) << ' ';
 
         std::string banListStr = banlist.str();
 
         PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_CHANNEL);
-        stmt->setBool(0, m_announce);
-        stmt->setBool(1, m_ownership);
-        stmt->setString(2, m_password);
+        stmt->setBool(0, _announce);
+        stmt->setBool(1, _ownership);
+        stmt->setString(2, _password);
         stmt->setString(3, banListStr);
-        stmt->setString(4, m_name);
-        stmt->setUInt32(5, m_Team);
+        stmt->setString(4, _name);
+        stmt->setUInt32(5, _Team);
         CharacterDatabase.Execute(stmt);
 
-        sLog->outDebug(LOG_FILTER_CHATSYS, "Channel(%s) updated in database", m_name.c_str());
+        sLog->outDebug(LOG_FILTER_CHATSYS, "Channel(%s) updated in database", _name.c_str());
     }
 }
 
 void Channel::UpdateChannelUseageInDB() const
 {
     PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_CHANNEL_USAGE);
-    stmt->setString(0, m_name);
-    stmt->setUInt32(1, m_Team);
+    stmt->setString(0, _name);
+    stmt->setUInt32(1, _Team);
     CharacterDatabase.Execute(stmt);
 }
 
@@ -141,531 +147,500 @@ void Channel::CleanOldChannelsInDB()
     }
 }
 
-void Channel::Join(uint64 p, const char *pass)
+void Channel::JoinChannel(Player* player, std::string const& pass)
 {
-    WorldPacket data;
-    if (IsOn(p))
+    uint64 guid = player->GetGUID();
+    if (IsOn(guid))
     {
-        if (!IsConstant())                                   // non send error message for built-in channels
+        // Do not send error message for built-in channels
+        if (!IsConstant())
         {
-            MakePlayerAlreadyMember(&data, p);
-            SendToOne(&data, p);
+            WorldPacket data;
+            MakePlayerAlreadyMember(&data, guid);
+            SendToOne(&data, guid);
         }
         return;
     }
 
-    if (IsBanned(p))
+    if (IsBanned(guid))
     {
+        WorldPacket data;
         MakeBanned(&data);
-        SendToOne(&data, p);
+        SendToOne(&data, guid);
         return;
     }
 
-    if (m_password.length() > 0 && strcmp(pass, m_password.c_str()))
+    if (!_password.empty() && pass != _password)
     {
+        WorldPacket data;
         MakeWrongPassword(&data);
-        SendToOne(&data, p);
+        SendToOne(&data, guid);
         return;
     }
 
-    Player* player = ObjectAccessor::FindPlayer(p);
-
-    if (player)
+    if (HasFlag(CHANNEL_FLAG_LFG) &&
+        sWorld->getBoolConfig(CONFIG_RESTRICTED_LFG_CHANNEL) &&
+        AccountMgr::IsPlayerAccount(player->GetSession()->GetSecurity()) &&
+        player->GetGroup())
     {
-        if (HasFlag(CHANNEL_FLAG_LFG) &&
-            sWorld->getBoolConfig(CONFIG_RESTRICTED_LFG_CHANNEL) && AccountMgr::IsPlayerAccount(player->GetSession()->GetSecurity()) && player->GetGroup())
-        {
-            MakeNotInLfg(&data);
-            SendToOne(&data, p);
-            return;
-        }
-
-        player->JoinedChannel(this);
+        WorldPacket data;
+        MakeNotInLfg(&data);
+        SendToOne(&data, guid);
+        return;
     }
 
-    if (m_announce && (!player || !AccountMgr::IsGMAccount(player->GetSession()->GetSecurity()) || !sWorld->getBoolConfig(CONFIG_SILENTLY_GM_JOIN_TO_CHANNEL)))
+    player->JoinedChannel(this);
+
+    if (_announce && (!AccountMgr::IsGMAccount(player->GetSession()->GetSecurity()) ||
+                       !sWorld->getBoolConfig(CONFIG_SILENTLY_GM_JOIN_TO_CHANNEL)))
     {
-        MakeJoined(&data, p);
+        WorldPacket data;
+        MakeJoined(&data, guid);
         SendToAll(&data);
     }
 
-    data.clear();
-
     PlayerInfo pinfo;
-    pinfo.player = p;
+    pinfo.player = guid;
     pinfo.flags = MEMBER_FLAG_NONE;
-    players[p] = pinfo;
+    playersStore[guid] = pinfo;
 
+    WorldPacket data;
     MakeYouJoined(&data);
-    SendToOne(&data, p);
+    SendToOne(&data, guid);
 
-    JoinNotify(p);
+    JoinNotify(guid);
 
     // Custom channel handling
     if (!IsConstant())
     {
         // Update last_used timestamp in db
-        if (!players.empty())
+        if (!playersStore.empty())
             UpdateChannelUseageInDB();
 
         // If the channel has no owner yet and ownership is allowed, set the new owner.
-        if (!m_ownerGUID && m_ownership)
+        if (!_ownerGUID && _ownership)
         {
-            SetOwner(p, (players.size() > 1 ? true : false));
-            players[p].SetModerator(true);
+            SetOwner(guid, playersStore.size() > 1);
+            playersStore[guid].SetModerator(true);
         }
     }
 }
 
-void Channel::Leave(uint64 p, bool send)
+void Channel::LeaveChannel(Player* player, bool send)
 {
-    if (!IsOn(p))
+    uint64 guid = player->GetGUID();
+    if (!IsOn(guid))
     {
         if (send)
         {
             WorldPacket data;
             MakeNotMember(&data);
-            SendToOne(&data, p);
+            SendToOne(&data, guid);
         }
+        return;
     }
-    else
+
+    if (send)
     {
-        Player* player = ObjectAccessor::FindPlayer(p);
+        WorldPacket data;
+        MakeYouLeft(&data);
+        SendToOne(&data, guid);
+        player->LeftChannel(this);
+        data.clear();
+    }
 
-        if (send)
-        {
-            WorldPacket data;
-            MakeYouLeft(&data);
-            SendToOne(&data, p);
-            if (player)
-                player->LeftChannel(this);
-            data.clear();
-        }
+    bool changeowner = playersStore[guid].IsOwner();
 
-        bool changeowner = players[p].IsOwner();
+    playersStore.erase(guid);
+    if (_announce && (!AccountMgr::IsGMAccount(player->GetSession()->GetSecurity()) ||
+                       !sWorld->getBoolConfig(CONFIG_SILENTLY_GM_JOIN_TO_CHANNEL)))
+    {
+        WorldPacket data;
+        MakeLeft(&data, guid);
+        SendToAll(&data);
+    }
 
-        players.erase(p);
-        if (m_announce && (!player || !AccountMgr::IsGMAccount(player->GetSession()->GetSecurity()) || !sWorld->getBoolConfig(CONFIG_SILENTLY_GM_JOIN_TO_CHANNEL)))
-        {
-            WorldPacket data;
-            MakeLeft(&data, p);
-            SendToAll(&data);
-        }
+    LeaveNotify(guid);
 
-        LeaveNotify(p);
+    if (!IsConstant())
+    {
+        // Update last_used timestamp in db
+        UpdateChannelUseageInDB();
 
-        if (!IsConstant())
+        // If the channel owner left and there are still playersStore inside, pick a new owner
+        if (changeowner && _ownership && !playersStore.empty())
         {
-            // Update last_used timestamp in db
-            UpdateChannelUseageInDB();
-
-            // If the channel owner left and there are still players inside, pick a new owner
-            if (changeowner && m_ownership && !players.empty())
-            {
-                uint64 newowner = players.begin()->second.player;
-                players[newowner].SetModerator(true);
-                SetOwner(newowner);
-            }
+            uint64 newowner = playersStore.begin()->second.player;
+            playersStore[newowner].SetModerator(true);
+            SetOwner(newowner);
         }
     }
 }
 
-void Channel::KickOrBan(uint64 good, const char *badname, bool ban)
+void Channel::KickOrBan(Player const* player, std::string const& badname, bool ban)
 {
-    AccountTypes sec = SEC_PLAYER;
-    Player* gplr = ObjectAccessor::FindPlayer(good);
-    if (gplr)
-        sec = gplr->GetSession()->GetSecurity();
+    AccountTypes sec = player->GetSession()->GetSecurity();
+    uint64 good = player->GetGUID();
 
     if (!IsOn(good))
     {
         WorldPacket data;
         MakeNotMember(&data);
         SendToOne(&data, good);
+        return;
     }
-    else if (!players[good].IsModerator() && !AccountMgr::IsGMAccount(sec))
+
+    if (!playersStore[good].IsModerator() && !AccountMgr::IsGMAccount(sec))
     {
         WorldPacket data;
         MakeNotModerator(&data);
         SendToOne(&data, good);
+        return;
     }
-    else
+    
+    Player* bad = sObjectAccessor->FindPlayerByName(badname);
+    uint64 victim = bad ? bad->GetGUID() : 0;
+    if (!victim || !IsOn(victim))
     {
-        Player* bad = sObjectAccessor->FindPlayerByName(badname);
-        if (bad == NULL || !IsOn(bad->GetGUID()))
-        {
-            WorldPacket data;
-            MakePlayerNotFound(&data, badname);
-            SendToOne(&data, good);
-        }
-        else if (!AccountMgr::IsGMAccount(sec) && bad->GetGUID() == m_ownerGUID && good != m_ownerGUID)
-        {
-            WorldPacket data;
-            MakeNotOwner(&data);
-            SendToOne(&data, good);
-        }
-        else
-        {
-            bool changeowner = (m_ownerGUID == bad->GetGUID());
-
-            WorldPacket data;
-            bool notify = !(AccountMgr::IsGMAccount(sec) && sWorld->getBoolConfig(CONFIG_SILENTLY_GM_JOIN_TO_CHANNEL));
+        WorldPacket data;
+        MakePlayerNotFound(&data, badname);
+        SendToOne(&data, good);
+        return;
+    }
 
-            if (ban && !IsBanned(bad->GetGUID()))
-            {
-                banned.insert(bad->GetGUID());
-                UpdateChannelInDB();
+    bool changeowner = _ownerGUID == victim;
 
-                if (notify)
-                    MakePlayerBanned(&data, bad->GetGUID(), good);
-            }
-            else if (notify)
-                MakePlayerKicked(&data, bad->GetGUID(), good);
+    if (!AccountMgr::IsGMAccount(sec) && changeowner && good != _ownerGUID)
+    {
+        WorldPacket data;
+        MakeNotOwner(&data);
+        SendToOne(&data, good);
+        return;
+    }
 
-            if (notify)
-                SendToAll(&data);
+    bool notify = !(AccountMgr::IsGMAccount(sec) && sWorld->getBoolConfig(CONFIG_SILENTLY_GM_JOIN_TO_CHANNEL));
 
-            players.erase(bad->GetGUID());
-            bad->LeftChannel(this);
+    if (ban && !IsBanned(victim))
+    {
+        bannedStore.insert(victim);
+        UpdateChannelInDB();
 
-            if (changeowner && m_ownership && !players.empty())
-            {
-                uint64 newowner = good;
-                players[newowner].SetModerator(true);
-                SetOwner(newowner);
-            }
+        if (notify)
+        {
+            WorldPacket data;
+            MakePlayerBanned(&data, victim, good);
+            SendToAll(&data);
         }
     }
+    else if (notify)
+    {
+        WorldPacket data;
+        MakePlayerKicked(&data, victim, good);
+        SendToAll(&data);
+    }
+
+    playersStore.erase(victim);
+    bad->LeftChannel(this);
+
+    if (changeowner && _ownership && !playersStore.empty())
+    {
+        uint64 newowner = good;
+        playersStore[newowner].SetModerator(true);
+        SetOwner(newowner);
+    }
 }
 
-void Channel::UnBan(uint64 good, const char *badname)
+void Channel::UnBan(Player const* player, std::string const& badname)
 {
-    uint32 sec = 0;
-    Player* gplr = ObjectAccessor::FindPlayer(good);
-    if (gplr)
-        sec = gplr->GetSession()->GetSecurity();
+    uint32 sec = player->GetSession()->GetSecurity();
+    uint64 good = player->GetGUID();
 
     if (!IsOn(good))
     {
         WorldPacket data;
         MakeNotMember(&data);
         SendToOne(&data, good);
+        return;
     }
-    else if (!players[good].IsModerator() && !AccountMgr::IsGMAccount(sec))
+
+    if (!playersStore[good].IsModerator() && !AccountMgr::IsGMAccount(sec))
     {
         WorldPacket data;
         MakeNotModerator(&data);
         SendToOne(&data, good);
+        return;
     }
-    else
-    {
-        Player* bad = sObjectAccessor->FindPlayerByName(badname);
-        if (bad == NULL || !IsBanned(bad->GetGUID()))
-        {
-            WorldPacket data;
-            MakePlayerNotFound(&data, badname);
-            SendToOne(&data, good);
-        }
-        else
-        {
-            banned.erase(bad->GetGUID());
 
-            WorldPacket data;
-            MakePlayerUnbanned(&data, bad->GetGUID(), good);
-            SendToAll(&data);
+    Player* bad = sObjectAccessor->FindPlayerByName(badname);
+    uint64 victim = bad ? bad->GetGUID(): 0;
 
-            UpdateChannelInDB();
-        }
+    if (!victim || !IsBanned(victim))
+    {
+        WorldPacket data;
+        MakePlayerNotFound(&data, badname);
+        SendToOne(&data, good);
+        return;
     }
+
+    bannedStore.erase(victim);
+
+    WorldPacket data;
+    MakePlayerUnbanned(&data, victim, good);
+    SendToAll(&data);
+
+    UpdateChannelInDB();
 }
 
-void Channel::Password(uint64 p, const char *pass)
+void Channel::Password(Player const* player, std::string const& pass)
 {
-    uint32 sec = 0;
-    Player* player = ObjectAccessor::FindPlayer(p);
-    if (player)
-        sec = player->GetSession()->GetSecurity();
+    uint64 guid = player->GetGUID();
 
     ChatHandler chat(player->GetSession());
-
-    if (!IsOn(p))
+    if (!IsOn(guid))
     {
         WorldPacket data;
         MakeNotMember(&data);
-        SendToOne(&data, p);
+        SendToOne(&data, guid);
+        return;
     }
-    else if (!players[p].IsModerator() && !AccountMgr::IsGMAccount(sec))
+    
+    if (!playersStore[guid].IsModerator() && !AccountMgr::IsGMAccount(player->GetSession()->GetSecurity()))
     {
         WorldPacket data;
         MakeNotModerator(&data);
-        SendToOne(&data, p);
+        SendToOne(&data, guid);
+        return;
     }
-    else
-    {
-        m_password = pass;
 
-        WorldPacket data;
-        MakePasswordChanged(&data, p);
-        SendToAll(&data);
+    _password = pass;
 
-        UpdateChannelInDB();
-    }
+    WorldPacket data;
+    MakePasswordChanged(&data, guid);
+    SendToAll(&data);
+
+    UpdateChannelInDB();
 }
 
-void Channel::SetMode(uint64 p, const char *p2n, bool mod, bool set)
+void Channel::SetMode(Player const* player, std::string const& p2n, bool mod, bool set)
 {
-    Player* player = ObjectAccessor::FindPlayer(p);
-    if (!player)
-        return;
-
+    uint64 guid = player->GetGUID();
     uint32 sec = player->GetSession()->GetSecurity();
 
-    if (!IsOn(p))
+    if (!IsOn(guid))
     {
         WorldPacket data;
         MakeNotMember(&data);
-        SendToOne(&data, p);
+        SendToOne(&data, guid);
+        return;
     }
-    else if (!players[p].IsModerator() && !AccountMgr::IsGMAccount(sec))
+
+    if (!playersStore[guid].IsModerator() && !AccountMgr::IsGMAccount(sec))
     {
         WorldPacket data;
         MakeNotModerator(&data);
-        SendToOne(&data, p);
+        SendToOne(&data, guid);
+        return;
     }
-    else
-    {
-        Player* newp = sObjectAccessor->FindPlayerByName(p2n);
-        if (!newp)
-        {
-            WorldPacket data;
-            MakePlayerNotFound(&data, p2n);
-            SendToOne(&data, p);
-            return;
-        }
 
-        if (p == m_ownerGUID && newp->GetGUID() == m_ownerGUID && mod)
-            return;
+    if (guid == _ownerGUID && std::string(p2n) == player->GetName() && mod)
+        return;
 
-        if (!IsOn(newp->GetGUID()))
-        {
-            WorldPacket data;
-            MakePlayerNotFound(&data, p2n);
-            SendToOne(&data, p);
-            return;
-        }
+    Player* newp = sObjectAccessor->FindPlayerByName(p2n);
+    uint64 victim = newp ? newp->GetGUID() : 0;
 
+    if (!victim || !IsOn(victim) ||
         // allow make moderator from another team only if both is GMs
         // at this moment this only way to show channel post for GM from another team
-        if ((!AccountMgr::IsGMAccount(player->GetSession()->GetSecurity()) || !AccountMgr::IsGMAccount(newp->GetSession()->GetSecurity())) &&
-            player->GetTeam() != newp->GetTeam() && !sWorld->getBoolConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_CHANNEL))
-        {
-            WorldPacket data;
-            MakePlayerNotFound(&data, p2n);
-            SendToOne(&data, p);
-            return;
-        }
-
-        if (m_ownerGUID == newp->GetGUID() && m_ownerGUID != p)
-        {
-            WorldPacket data;
-            MakeNotOwner(&data);
-            SendToOne(&data, p);
-            return;
-        }
-
-        if (mod)
-            SetModerator(newp->GetGUID(), set);
-        else
-            SetMute(newp->GetGUID(), set);
-    }
-}
-
-void Channel::SetOwner(uint64 p, const char *newname)
-{
-    Player* player = ObjectAccessor::FindPlayer(p);
-    if (!player)
-        return;
-
-    uint32 sec = player->GetSession()->GetSecurity();
-
-    if (!IsOn(p))
+        ((!AccountMgr::IsGMAccount(sec) || !AccountMgr::IsGMAccount(newp->GetSession()->GetSecurity())) &&
+         player->GetTeam() != newp->GetTeam() && !sWorld->getBoolConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_CHANNEL)))
     {
         WorldPacket data;
-        MakeNotMember(&data);
-        SendToOne(&data, p);
+        MakePlayerNotFound(&data, p2n);
+        SendToOne(&data, guid);
         return;
     }
 
-    if (!AccountMgr::IsGMAccount(sec) && p != m_ownerGUID)
+    if (_ownerGUID == victim && _ownerGUID != guid)
     {
         WorldPacket data;
         MakeNotOwner(&data);
-        SendToOne(&data, p);
+        SendToOne(&data, guid);
         return;
     }
 
-    Player* newp = sObjectAccessor->FindPlayerByName(newname);
-    if (newp == NULL || !IsOn(newp->GetGUID()))
+    if (mod)
+        SetModerator(newp->GetGUID(), set);
+    else
+        SetMute(newp->GetGUID(), set);
+}
+
+void Channel::SetOwner(Player const* player, std::string const& newname)
+{
+    uint64 guid = player->GetGUID();
+    uint32 sec = player->GetSession()->GetSecurity();
+
+    if (!IsOn(guid) || (!AccountMgr::IsGMAccount(sec) && guid != _ownerGUID))
     {
         WorldPacket data;
-        MakePlayerNotFound(&data, newname);
-        SendToOne(&data, p);
+        MakeNotMember(&data);
+        SendToOne(&data, guid);
         return;
     }
 
-    if (newp->GetTeam() != player->GetTeam() && !sWorld->getBoolConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_CHANNEL))
+    Player* newp = sObjectAccessor->FindPlayerByName(newname);
+    uint64 victim = newp ? newp->GetGUID() : 0;
+    
+    if (!victim || !IsOn(victim) ||
+        (newp->GetTeam() != player->GetTeam() && !sWorld->getBoolConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_CHANNEL)))
     {
         WorldPacket data;
         MakePlayerNotFound(&data, newname);
-        SendToOne(&data, p);
+        SendToOne(&data, guid);
         return;
     }
 
-    players[newp->GetGUID()].SetModerator(true);
-    SetOwner(newp->GetGUID());
+    playersStore[victim].SetModerator(true);
+    SetOwner(victim);
 }
 
-void Channel::SendWhoOwner(uint64 p)
+void Channel::SendWhoOwner(uint64 guid)
 {
-    if (!IsOn(p))
-    {
-        WorldPacket data;
-        MakeNotMember(&data);
-        SendToOne(&data, p);
-    }
-    else
-    {
-        WorldPacket data;
+    WorldPacket data;
+    if (IsOn(guid))
         MakeChannelOwner(&data);
-        SendToOne(&data, p);
-    }
+    else
+        MakeNotMember(&data);
+    SendToOne(&data, guid);
 }
 
-void Channel::List(Player* player)
+void Channel::List(Player const* player)
 {
-    uint64 p = player->GetGUID();
+    uint64 guid = player->GetGUID();
 
-    if (!IsOn(p))
+    if (!IsOn(guid))
     {
         WorldPacket data;
         MakeNotMember(&data);
-        SendToOne(&data, p);
+        SendToOne(&data, guid);
+        return;
     }
-    else
-    {
-        WorldPacket data(SMSG_CHANNEL_LIST, 1+(GetName().size()+1)+1+4+players.size()*(8+1));
-        data << uint8(1);                                   // channel type?
-        data << GetName();                                  // channel name
-        data << uint8(GetFlags());                          // channel flags?
 
-        size_t pos = data.wpos();
-        data << uint32(0);                                  // size of list, placeholder
+    sLog->outDebug(LOG_FILTER_CHATSYS, "SMSG_CHANNEL_LIST %s Channel: %s",
+        player->GetSession()->GetPlayerInfo().c_str(), GetName().c_str());
 
-        uint32 gmLevelInWhoList = sWorld->getIntConfig(CONFIG_GM_LEVEL_IN_WHO_LIST);
+    WorldPacket data(SMSG_CHANNEL_LIST, 1+(GetName().size()+1)+1+4+playersStore.size()*(8+1));
+    data << uint8(1);                                   // channel type?
+    data << GetName();                                  // channel name
+    data << uint8(GetFlags());                          // channel flags?
 
-        uint32 count  = 0;
-        for (PlayerList::const_iterator i = players.begin(); i != players.end(); ++i)
-        {
-            Player* member = ObjectAccessor::FindPlayer(i->first);
+    size_t pos = data.wpos();
+    data << uint32(0);                                  // size of list, placeholder
 
-            // PLAYER can't see MODERATOR, GAME MASTER, ADMINISTRATOR characters
-            // MODERATOR, GAME MASTER, ADMINISTRATOR can see all
-            if (member && (!AccountMgr::IsPlayerAccount(player->GetSession()->GetSecurity()) || member->GetSession()->GetSecurity() <= AccountTypes(gmLevelInWhoList)) &&
-                member->IsVisibleGloballyFor(player))
-            {
-                data << uint64(i->first);
-                data << uint8(i->second.flags);             // flags seems to be changed...
-                ++count;
-            }
-        }
+    uint32 gmLevelInWhoList = sWorld->getIntConfig(CONFIG_GM_LEVEL_IN_WHO_LIST);
 
-        data.put<uint32>(pos, count);
+    uint32 count  = 0;
+    for (PlayerContainer::const_iterator i = playersStore.begin(); i != playersStore.end(); ++i)
+    {
+        Player* member = ObjectAccessor::FindPlayer(i->first);
 
-        SendToOne(&data, p);
+        // PLAYER can't see MODERATOR, GAME MASTER, ADMINISTRATOR characters
+        // MODERATOR, GAME MASTER, ADMINISTRATOR can see all
+        if (member && (!AccountMgr::IsPlayerAccount(player->GetSession()->GetSecurity()) || member->GetSession()->GetSecurity() <= AccountTypes(gmLevelInWhoList)) &&
+            member->IsVisibleGloballyFor(player))
+        {
+            data << uint64(i->first);
+            data << uint8(i->second.flags);             // flags seems to be changed...
+            ++count;
+        }
     }
+
+    data.put<uint32>(pos, count);
+
+    SendToOne(&data, guid);
 }
 
-void Channel::Announce(uint64 p)
+void Channel::Announce(Player const* player)
 {
-    uint32 sec = 0;
-    Player* player = ObjectAccessor::FindPlayer(p);
-    if (player)
-        sec = player->GetSession()->GetSecurity();
+    uint64 guid = player->GetGUID();
+    uint32 sec = player->GetSession()->GetSecurity();
 
-    if (!IsOn(p))
+    if (!IsOn(guid))
     {
         WorldPacket data;
         MakeNotMember(&data);
-        SendToOne(&data, p);
+        SendToOne(&data, guid);
+        return;
     }
-    else if (!players[p].IsModerator() && !AccountMgr::IsGMAccount(sec))
+
+    if (!playersStore[guid].IsModerator() && !AccountMgr::IsGMAccount(sec))
     {
         WorldPacket data;
         MakeNotModerator(&data);
-        SendToOne(&data, p);
+        SendToOne(&data, guid);
+        return;
     }
-    else
-    {
-        m_announce = !m_announce;
 
-        WorldPacket data;
-        if (m_announce)
-            MakeAnnouncementsOn(&data, p);
-        else
-            MakeAnnouncementsOff(&data, p);
-        SendToAll(&data);
+    _announce = !_announce;
 
-        UpdateChannelInDB();
-    }
+    WorldPacket data;
+    if (_announce)
+        MakeAnnouncementsOn(&data, guid);
+    else
+        MakeAnnouncementsOff(&data, guid);
+    SendToAll(&data);
+
+    UpdateChannelInDB();
 }
 
-void Channel::Say(uint64 p, const char *what, uint32 lang)
+void Channel::Say(uint64 guid, std::string const& what, uint32 lang)
 {
-    if (!what)
+    if (what.empty())
         return;
+
     if (sWorld->getBoolConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_CHANNEL))
         lang = LANG_UNIVERSAL;
 
-    Player* player = ObjectAccessor::FindPlayer(p);
+    Player* player = ObjectAccessor::FindPlayer(guid);
 
-    if (!IsOn(p))
+    if (!IsOn(guid))
     {
         WorldPacket data;
         MakeNotMember(&data);
-        SendToOne(&data, p);
+        SendToOne(&data, guid);
+        return;
     }
-    else if (players[p].IsMuted())
+    
+    if (playersStore[guid].IsMuted())
     {
         WorldPacket data;
         MakeMuted(&data);
-        SendToOne(&data, p);
-    }
-    else
-    {
-        uint32 messageLength = strlen(what) + 1;
-
-        WorldPacket data(SMSG_MESSAGECHAT, 1+4+8+4+m_name.size()+1+8+4+messageLength+1);
-        data << (uint8)CHAT_MSG_CHANNEL;
-        data << (uint32)lang;
-        data << p;                                          // 2.1.0
-        data << uint32(0);                                  // 2.1.0
-        data << m_name;
-        data << p;
-        data << messageLength;
-        data << what;
-        data << uint8(player ? player->GetChatTag() : 0);
-
-        SendToAll(&data, !players[p].IsModerator() ? p : false);
+        SendToOne(&data, guid);
+        return;
     }
+
+    WorldPacket data(SMSG_MESSAGECHAT, 1 + 4 + 8 + 4 + _name.size() + 8 + 4 + what.size() + 1);
+    data << uint8(CHAT_MSG_CHANNEL);
+    data << uint32(lang);
+    data << guid;
+    data << uint32(0);
+    data << _name;
+    data << guid;
+    data << what.size() + 1;
+    data << what;
+    data << uint8(player ? player->GetChatTag() : 0);
+
+    SendToAll(&data, !playersStore[guid].IsModerator() ? guid : false);
 }
 
-void Channel::Invite(uint64 p, const char *newname)
+void Channel::Invite(Player const* player, std::string const& newname)
 {
-    if (!IsOn(p))
+    uint64 guid = player->GetGUID();
+
+    if (!IsOn(guid))
     {
         WorldPacket data;
         MakeNotMember(&data);
-        SendToOne(&data, p);
+        SendToOne(&data, guid);
         return;
     }
 
@@ -674,7 +649,7 @@ void Channel::Invite(uint64 p, const char *newname)
     {
         WorldPacket data;
         MakePlayerNotFound(&data, newname);
-        SendToOne(&data, p);
+        SendToOne(&data, guid);
         return;
     }
 
@@ -682,19 +657,15 @@ void Channel::Invite(uint64 p, const char *newname)
     {
         WorldPacket data;
         MakePlayerInviteBanned(&data, newname);
-        SendToOne(&data, p);
+        SendToOne(&data, guid);
         return;
     }
 
-    Player* player = ObjectAccessor::FindPlayer(p);
-    if (!player)
-        return;
-
     if (newp->GetTeam() != player->GetTeam() && !sWorld->getBoolConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_CHANNEL))
     {
         WorldPacket data;
         MakeInviteWrongFaction(&data);
-        SendToOne(&data, p);
+        SendToOne(&data, guid);
         return;
     }
 
@@ -702,45 +673,47 @@ void Channel::Invite(uint64 p, const char *newname)
     {
         WorldPacket data;
         MakePlayerAlreadyMember(&data, newp->GetGUID());
-        SendToOne(&data, p);
+        SendToOne(&data, guid);
         return;
     }
 
-    WorldPacket data;
-    if (!newp->GetSocial()->HasIgnore(GUID_LOPART(p)))
+    if (!newp->GetSocial()->HasIgnore(GUID_LOPART(guid)))
     {
-        MakeInvite(&data, p);
+        WorldPacket data;
+        MakeInvite(&data, guid);
         SendToOne(&data, newp->GetGUID());
         data.clear();
     }
+
+    WorldPacket data;
     MakePlayerInvited(&data, newp->GetName());
-    SendToOne(&data, p);
+    SendToOne(&data, guid);
 }
 
 void Channel::SetOwner(uint64 guid, bool exclaim)
 {
-    if (m_ownerGUID)
+    if (_ownerGUID)
     {
         // [] will re-add player after it possible removed
-        PlayerList::iterator p_itr = players.find(m_ownerGUID);
-        if (p_itr != players.end())
+        PlayerContainer::iterator p_itr = playersStore.find(_ownerGUID);
+        if (p_itr != playersStore.end())
             p_itr->second.SetOwner(false);
     }
 
-    m_ownerGUID = guid;
-    if (m_ownerGUID)
+    _ownerGUID = guid;
+    if (_ownerGUID)
     {
-        uint8 oldFlag = GetPlayerFlags(m_ownerGUID);
-        players[m_ownerGUID].SetModerator(true);
-        players[m_ownerGUID].SetOwner(true);
+        uint8 oldFlag = GetPlayerFlags(_ownerGUID);
+        playersStore[_ownerGUID].SetModerator(true);
+        playersStore[_ownerGUID].SetOwner(true);
 
         WorldPacket data;
-        MakeModeChange(&data, m_ownerGUID, oldFlag);
+        MakeModeChange(&data, _ownerGUID, oldFlag);
         SendToAll(&data);
 
         if (exclaim)
         {
-            MakeOwnerChanged(&data, m_ownerGUID);
+            MakeOwnerChanged(&data, _ownerGUID);
             SendToAll(&data);
         }
 
@@ -748,36 +721,25 @@ void Channel::SetOwner(uint64 guid, bool exclaim)
     }
 }
 
-void Channel::SendToAll(WorldPacket* data, uint64 p)
+void Channel::SendToAll(WorldPacket* data, uint64 guid)
 {
-    for (PlayerList::const_iterator i = players.begin(); i != players.end(); ++i)
-    {
-        Player* player = ObjectAccessor::FindPlayer(i->first);
-        if (player)
-        {
-            if (!p || !player->GetSocial()->HasIgnore(GUID_LOPART(p)))
+    for (PlayerContainer::const_iterator i = playersStore.begin(); i != playersStore.end(); ++i)
+        if (Player* player = ObjectAccessor::FindPlayer(i->first))
+            if (!guid || !player->GetSocial()->HasIgnore(GUID_LOPART(guid)))
                 player->GetSession()->SendPacket(data);
-        }
-    }
 }
 
 void Channel::SendToAllButOne(WorldPacket* data, uint64 who)
 {
-    for (PlayerList::const_iterator i = players.begin(); i != players.end(); ++i)
-    {
+    for (PlayerContainer::const_iterator i = playersStore.begin(); i != playersStore.end(); ++i)
         if (i->first != who)
-        {
-            Player* player = ObjectAccessor::FindPlayer(i->first);
-            if (player)
+            if (Player* player = ObjectAccessor::FindPlayer(i->first))
                 player->GetSession()->SendPacket(data);
-        }
-    }
 }
 
 void Channel::SendToOne(WorldPacket* data, uint64 who)
 {
-    Player* player = ObjectAccessor::FindPlayer(who);
-    if (player)
+    if (Player* player = ObjectAccessor::FindPlayer(who))
         player->GetSession()->SendPacket(data);
 }
 
@@ -791,29 +753,25 @@ void Channel::DeVoice(uint64 /*guid1*/, uint64 /*guid2*/)
 
 }
 
-// done
 void Channel::MakeNotifyPacket(WorldPacket* data, uint8 notify_type)
 {
-    data->Initialize(SMSG_CHANNEL_NOTIFY, 1+m_name.size()+1);
+    data->Initialize(SMSG_CHANNEL_NOTIFY, 1 + _name.size());
     *data << uint8(notify_type);
-    *data << m_name;
+    *data << _name;
 }
 
-// done 0x00
 void Channel::MakeJoined(WorldPacket* data, uint64 guid)
 {
     MakeNotifyPacket(data, CHAT_JOINED_NOTICE);
     *data << uint64(guid);
 }
 
-// done 0x01
 void Channel::MakeLeft(WorldPacket* data, uint64 guid)
 {
     MakeNotifyPacket(data, CHAT_LEFT_NOTICE);
     *data << uint64(guid);
 }
 
-// done 0x02
 void Channel::MakeYouJoined(WorldPacket* data)
 {
     MakeNotifyPacket(data, CHAT_YOU_JOINED_NOTICE);
@@ -822,7 +780,6 @@ void Channel::MakeYouJoined(WorldPacket* data)
     *data << uint32(0);
 }
 
-// done 0x03
 void Channel::MakeYouLeft(WorldPacket* data)
 {
     MakeNotifyPacket(data, CHAT_YOU_LEFT_NOTICE);
@@ -830,64 +787,55 @@ void Channel::MakeYouLeft(WorldPacket* data)
     *data << uint8(IsConstant());
 }
 
-// done 0x04
 void Channel::MakeWrongPassword(WorldPacket* data)
 {
     MakeNotifyPacket(data, CHAT_WRONG_PASSWORD_NOTICE);
 }
 
-// done 0x05
 void Channel::MakeNotMember(WorldPacket* data)
 {
     MakeNotifyPacket(data, CHAT_NOT_MEMBER_NOTICE);
 }
 
-// done 0x06
 void Channel::MakeNotModerator(WorldPacket* data)
 {
     MakeNotifyPacket(data, CHAT_NOT_MODERATOR_NOTICE);
 }
 
-// done 0x07
 void Channel::MakePasswordChanged(WorldPacket* data, uint64 guid)
 {
     MakeNotifyPacket(data, CHAT_PASSWORD_CHANGED_NOTICE);
     *data << uint64(guid);
 }
 
-// done 0x08
 void Channel::MakeOwnerChanged(WorldPacket* data, uint64 guid)
 {
     MakeNotifyPacket(data, CHAT_OWNER_CHANGED_NOTICE);
     *data << uint64(guid);
 }
 
-// done 0x09
-void Channel::MakePlayerNotFound(WorldPacket* data, const std::string& name)
+void Channel::MakePlayerNotFound(WorldPacket* data, std::string const& name)
 {
     MakeNotifyPacket(data, CHAT_PLAYER_NOT_FOUND_NOTICE);
     *data << name;
 }
 
-// done 0x0A
 void Channel::MakeNotOwner(WorldPacket* data)
 {
     MakeNotifyPacket(data, CHAT_NOT_OWNER_NOTICE);
 }
 
-// done 0x0B
 void Channel::MakeChannelOwner(WorldPacket* data)
 {
     std::string name = "";
 
-    if (!sObjectMgr->GetPlayerNameByGUID(m_ownerGUID, name) || name.empty())
+    if (!sObjectMgr->GetPlayerNameByGUID(_ownerGUID, name) || name.empty())
         name = "PLAYER_NOT_FOUND";
 
     MakeNotifyPacket(data, CHAT_CHANNEL_OWNER_NOTICE);
-    *data << ((IsConstant() || !m_ownerGUID) ? "Nobody" : name);
+    *data << ((IsConstant() || !_ownerGUID) ? "Nobody" : name);
 }
 
-// done 0x0C
 void Channel::MakeModeChange(WorldPacket* data, uint64 guid, uint8 oldflags)
 {
     MakeNotifyPacket(data, CHAT_MODE_CHANGE_NOTICE);
@@ -896,27 +844,23 @@ void Channel::MakeModeChange(WorldPacket* data, uint64 guid, uint8 oldflags)
     *data << uint8(GetPlayerFlags(guid));
 }
 
-// done 0x0D
 void Channel::MakeAnnouncementsOn(WorldPacket* data, uint64 guid)
 {
     MakeNotifyPacket(data, CHAT_ANNOUNCEMENTS_ON_NOTICE);
     *data << uint64(guid);
 }
 
-// done 0x0E
 void Channel::MakeAnnouncementsOff(WorldPacket* data, uint64 guid)
 {
     MakeNotifyPacket(data, CHAT_ANNOUNCEMENTS_OFF_NOTICE);
     *data << uint64(guid);
 }
 
-// done 0x11
 void Channel::MakeMuted(WorldPacket* data)
 {
     MakeNotifyPacket(data, CHAT_MUTED_NOTICE);
 }
 
-// done 0x12
 void Channel::MakePlayerKicked(WorldPacket* data, uint64 bad, uint64 good)
 {
     MakeNotifyPacket(data, CHAT_PLAYER_KICKED_NOTICE);
@@ -924,13 +868,11 @@ void Channel::MakePlayerKicked(WorldPacket* data, uint64 bad, uint64 good)
     *data << uint64(good);
 }
 
-// done 0x13
 void Channel::MakeBanned(WorldPacket* data)
 {
     MakeNotifyPacket(data, CHAT_BANNED_NOTICE);
 }
 
-// done 0x14
 void Channel::MakePlayerBanned(WorldPacket* data, uint64 bad, uint64 good)
 {
     MakeNotifyPacket(data, CHAT_PLAYER_BANNED_NOTICE);
@@ -938,7 +880,6 @@ void Channel::MakePlayerBanned(WorldPacket* data, uint64 bad, uint64 good)
     *data << uint64(good);
 }
 
-// done 0x15
 void Channel::MakePlayerUnbanned(WorldPacket* data, uint64 bad, uint64 good)
 {
     MakeNotifyPacket(data, CHAT_PLAYER_UNBANNED_NOTICE);
@@ -946,91 +887,77 @@ void Channel::MakePlayerUnbanned(WorldPacket* data, uint64 bad, uint64 good)
     *data << uint64(good);
 }
 
-// done 0x16
 void Channel::MakePlayerNotBanned(WorldPacket* data, const std::string &name)
 {
     MakeNotifyPacket(data, CHAT_PLAYER_NOT_BANNED_NOTICE);
     *data << name;
 }
 
-// done 0x17
 void Channel::MakePlayerAlreadyMember(WorldPacket* data, uint64 guid)
 {
     MakeNotifyPacket(data, CHAT_PLAYER_ALREADY_MEMBER_NOTICE);
     *data << uint64(guid);
 }
 
-// done 0x18
 void Channel::MakeInvite(WorldPacket* data, uint64 guid)
 {
     MakeNotifyPacket(data, CHAT_INVITE_NOTICE);
     *data << uint64(guid);
 }
 
-// done 0x19
 void Channel::MakeInviteWrongFaction(WorldPacket* data)
 {
     MakeNotifyPacket(data, CHAT_INVITE_WRONG_FACTION_NOTICE);
 }
 
-// done 0x1A
 void Channel::MakeWrongFaction(WorldPacket* data)
 {
     MakeNotifyPacket(data, CHAT_WRONG_FACTION_NOTICE);
 }
 
-// done 0x1B
 void Channel::MakeInvalidName(WorldPacket* data)
 {
     MakeNotifyPacket(data, CHAT_INVALID_NAME_NOTICE);
 }
 
-// done 0x1C
 void Channel::MakeNotModerated(WorldPacket* data)
 {
     MakeNotifyPacket(data, CHAT_NOT_MODERATED_NOTICE);
 }
 
-// done 0x1D
 void Channel::MakePlayerInvited(WorldPacket* data, const std::string& name)
 {
     MakeNotifyPacket(data, CHAT_PLAYER_INVITED_NOTICE);
     *data << name;
 }
 
-// done 0x1E
 void Channel::MakePlayerInviteBanned(WorldPacket* data, const std::string& name)
 {
     MakeNotifyPacket(data, CHAT_PLAYER_INVITE_BANNED_NOTICE);
     *data << name;
 }
 
-// done 0x1F
 void Channel::MakeThrottled(WorldPacket* data)
 {
     MakeNotifyPacket(data, CHAT_THROTTLED_NOTICE);
 }
 
-// done 0x20
 void Channel::MakeNotInArea(WorldPacket* data)
 {
     MakeNotifyPacket(data, CHAT_NOT_IN_AREA_NOTICE);
 }
 
-// done 0x21
 void Channel::MakeNotInLfg(WorldPacket* data)
 {
     MakeNotifyPacket(data, CHAT_NOT_IN_LFG_NOTICE);
 }
 
-// done 0x22
 void Channel::MakeVoiceOn(WorldPacket* data, uint64 guid)
 {
     MakeNotifyPacket(data, CHAT_VOICE_ON_NOTICE);
     *data << uint64(guid);
 }
 
-// done 0x23
 void Channel::MakeVoiceOff(WorldPacket* data, uint64 guid)
 {
     MakeNotifyPacket(data, CHAT_VOICE_OFF_NOTICE);
@@ -1039,13 +966,7 @@ void Channel::MakeVoiceOff(WorldPacket* data, uint64 guid)
 
 void Channel::JoinNotify(uint64 guid)
 {
-    WorldPacket data;
-
-    if (IsConstant())
-        data.Initialize(SMSG_USERLIST_ADD, 8+1+1+4+GetName().size()+1);
-    else
-        data.Initialize(SMSG_USERLIST_UPDATE, 8+1+1+4+GetName().size()+1);
-
+    WorldPacket data(IsConstant() ? SMSG_USERLIST_ADD : SMSG_USERLIST_UPDATE, 8 + 1 + 1 + 4 + GetName().size());
     data << uint64(guid);
     data << uint8(GetPlayerFlags(guid));
     data << uint8(GetFlags());
@@ -1060,7 +981,7 @@ void Channel::JoinNotify(uint64 guid)
 
 void Channel::LeaveNotify(uint64 guid)
 {
-    WorldPacket data(SMSG_USERLIST_REMOVE, 8+1+4+GetName().size()+1);
+    WorldPacket data(SMSG_USERLIST_REMOVE, 8 + 1 + 4 + GetName().size());
     data << uint64(guid);
     data << uint8(GetFlags());
     data << uint32(GetNumPlayers());
diff --git a/src/server/game/Chat/Channels/Channel.h b/src/server/game/Chat/Channels/Channel.h
index 5f6be0e36de..5ac4cf14280 100755
--- a/src/server/game/Chat/Channels/Channel.h
+++ b/src/server/game/Chat/Channels/Channel.h
@@ -53,10 +53,10 @@ enum ChatNotify
     CHAT_MODERATION_OFF_NOTICE        = 0x10,           //+ "[%s] Channel moderation disabled by %s.";
     CHAT_MUTED_NOTICE                 = 0x11,           //+ "[%s] You do not have permission to speak.";
     CHAT_PLAYER_KICKED_NOTICE         = 0x12,           //? "[%s] Player %s kicked by %s.";
-    CHAT_BANNED_NOTICE                = 0x13,           //+ "[%s] You are banned from that channel.";
-    CHAT_PLAYER_BANNED_NOTICE         = 0x14,           //? "[%s] Player %s banned by %s.";
+    CHAT_BANNED_NOTICE                = 0x13,           //+ "[%s] You are bannedStore from that channel.";
+    CHAT_PLAYER_BANNED_NOTICE         = 0x14,           //? "[%s] Player %s bannedStore by %s.";
     CHAT_PLAYER_UNBANNED_NOTICE       = 0x15,           //? "[%s] Player %s unbanned by %s.";
-    CHAT_PLAYER_NOT_BANNED_NOTICE     = 0x16,           //+ "[%s] Player %s is not banned.";
+    CHAT_PLAYER_NOT_BANNED_NOTICE     = 0x16,           //+ "[%s] Player %s is not bannedStore.";
     CHAT_PLAYER_ALREADY_MEMBER_NOTICE = 0x17,           //+ "[%s] Player %s is already on the channel.";
     CHAT_INVITE_NOTICE                = 0x18,           //+ "%2$s has invited you to join the channel '%1$s'.";
     CHAT_INVITE_WRONG_FACTION_NOTICE  = 0x19,           //+ "Target is in the wrong alliance for %s.";
@@ -64,7 +64,7 @@ enum ChatNotify
     CHAT_INVALID_NAME_NOTICE          = 0x1B,           //+ "Invalid channel name";
     CHAT_NOT_MODERATED_NOTICE         = 0x1C,           //+ "%s is not moderated";
     CHAT_PLAYER_INVITED_NOTICE        = 0x1D,           //+ "[%s] You invited %s to join the channel";
-    CHAT_PLAYER_INVITE_BANNED_NOTICE  = 0x1E,           //+ "[%s] %s has been banned.";
+    CHAT_PLAYER_INVITE_BANNED_NOTICE  = 0x1E,           //+ "[%s] %s has been bannedStore.";
     CHAT_THROTTLED_NOTICE             = 0x1F,           //+ "[%s] The number of messages that can be sent to this channel is limited, please wait to send another message.";
     CHAT_NOT_IN_AREA_NOTICE           = 0x20,           //+ "[%s] You are not in the correct area for this channel."; -- The user is trying to send a chat to a zone specific channel, and they're not physically in that zone.
     CHAT_NOT_IN_LFG_NOTICE            = 0x21,           //+ "[%s] You must be queued in looking for group before joining this channel."; -- The user must be in the looking for group system to join LFG chat channels.
@@ -147,18 +147,45 @@ class Channel
         }
     };
 
-    typedef     std::map<uint64, PlayerInfo> PlayerList;
-    PlayerList  players;
-    typedef     std::set<uint64> BannedList;
-    BannedList  banned;
-    bool        m_announce;
-    bool        m_ownership;
-    std::string m_name;
-    std::string m_password;
-    uint8       m_flags;
-    uint32      m_channelId;
-    uint64      m_ownerGUID;
-    bool        m_IsSaved;
+    public:
+        Channel(std::string const& name, uint32 channel_id, uint32 Team = 0);
+        std::string const& GetName() const { return _name; }
+        uint32 GetChannelId() const { return _channelId; }
+        bool IsConstant() const { return _channelId != 0; }
+        bool IsAnnounce() const { return _announce; }
+        bool IsLFG() const { return GetFlags() & CHANNEL_FLAG_LFG; }
+        std::string const& GetPassword() const { return _password; }
+        void SetPassword(std::string const& npassword) { _password = npassword; }
+        void SetAnnounce(bool nannounce) { _announce = nannounce; }
+        uint32 GetNumPlayers() const { return playersStore.size(); }
+        uint8 GetFlags() const { return _flags; }
+        bool HasFlag(uint8 flag) const { return _flags & flag; }
+
+        void JoinChannel(Player* player, std::string const& pass);
+        void LeaveChannel(Player* player, bool send = true);
+        void KickOrBan(Player const* player, std::string const& badname, bool ban);
+        void Kick(Player const* player, std::string const& badname) { KickOrBan(player, badname, false); }
+        void Ban(Player const* player, std::string const& badname) { KickOrBan(player, badname, true); }
+        void UnBan(Player const* player, std::string const& badname);
+        void Password(Player const* player, std::string const& pass);
+        void SetMode(Player const* player, std::string const& p2n, bool mod, bool set);
+        void SetOwner(uint64 guid, bool exclaim = true);
+        void SetOwner(Player const* player, std::string const& name);
+        void SendWhoOwner(uint64 guid);
+        void SetModerator(Player const* player, std::string const& newname) { SetMode(player, newname, true, true); }
+        void UnsetModerator(Player const* player, std::string const& newname) { SetMode(player, newname, true, false); }
+        void SetMute(Player const* player, std::string const& newname) { SetMode(player, newname, false, true); }
+        void UnsetMute(Player const* player, std::string const& newname) { SetMode(player, newname, false, false); }
+        void List(Player const* player);
+        void Announce(Player const* player);
+        void Say(uint64 guid, std::string const& what, uint32 lang);
+        void Invite(Player const* player, std::string const& newp);
+        void Voice(uint64 guid1, uint64 guid2);
+        void DeVoice(uint64 guid1, uint64 guid2);
+        void JoinNotify(uint64 guid);                                           // invisible notify
+        void LeaveNotify(uint64 guid);                                          // invisible notify
+        void SetOwnership(bool ownership) { _ownership = ownership; };
+        static void CleanOldChannelsInDB();
 
     private:
         // initial packet data (notify type and channel name)
@@ -199,91 +226,62 @@ class Channel
         void MakeVoiceOn(WorldPacket* data, uint64 guid);                       //+ 0x22
         void MakeVoiceOff(WorldPacket* data, uint64 guid);                      //+ 0x23
 
-        void SendToAll(WorldPacket* data, uint64 p = 0);
+        void SendToAll(WorldPacket* data, uint64 guid = 0);
         void SendToAllButOne(WorldPacket* data, uint64 who);
         void SendToOne(WorldPacket* data, uint64 who);
 
-        bool IsOn(uint64 who) const { return players.find(who) != players.end(); }
-        bool IsBanned(uint64 guid) const { return banned.find(guid) != banned.end(); }
+        bool IsOn(uint64 who) const { return playersStore.find(who) != playersStore.end(); }
+        bool IsBanned(uint64 guid) const { return bannedStore.find(guid) != bannedStore.end(); }
 
         void UpdateChannelInDB() const;
         void UpdateChannelUseageInDB() const;
 
-        uint8 GetPlayerFlags(uint64 p) const
+        uint8 GetPlayerFlags(uint64 guid) const
         {
-            PlayerList::const_iterator p_itr = players.find(p);
-            if (p_itr == players.end())
-                return 0;
-
-            return p_itr->second.flags;
+            PlayerContainer::const_iterator itr = playersStore.find(guid);
+            return itr != playersStore.end() ? itr->second.flags : 0;
         }
 
-        void SetModerator(uint64 p, bool set)
+        void SetModerator(uint64 guid, bool set)
         {
-            if (players[p].IsModerator() != set)
+            if (playersStore[guid].IsModerator() != set)
             {
-                uint8 oldFlag = GetPlayerFlags(p);
-                players[p].SetModerator(set);
+                uint8 oldFlag = GetPlayerFlags(guid);
+                playersStore[guid].SetModerator(set);
 
                 WorldPacket data;
-                MakeModeChange(&data, p, oldFlag);
+                MakeModeChange(&data, guid, oldFlag);
                 SendToAll(&data);
             }
         }
 
-        void SetMute(uint64 p, bool set)
+        void SetMute(uint64 guid, bool set)
         {
-            if (players[p].IsMuted() != set)
+            if (playersStore[guid].IsMuted() != set)
             {
-                uint8 oldFlag = GetPlayerFlags(p);
-                players[p].SetMuted(set);
+                uint8 oldFlag = GetPlayerFlags(guid);
+                playersStore[guid].SetMuted(set);
 
                 WorldPacket data;
-                MakeModeChange(&data, p, oldFlag);
+                MakeModeChange(&data, guid, oldFlag);
                 SendToAll(&data);
             }
         }
 
-    public:
-        uint32 m_Team;
-        Channel(std::string const& name, uint32 channel_id, uint32 Team = 0);
-        std::string const& GetName() const { return m_name; }
-        uint32 GetChannelId() const { return m_channelId; }
-        bool IsConstant() const { return m_channelId != 0; }
-        bool IsAnnounce() const { return m_announce; }
-        bool IsLFG() const { return GetFlags() & CHANNEL_FLAG_LFG; }
-        std::string const& GetPassword() const { return m_password; }
-        void SetPassword(std::string const& npassword) { m_password = npassword; }
-        void SetAnnounce(bool nannounce) { m_announce = nannounce; }
-        uint32 GetNumPlayers() const { return players.size(); }
-        uint8 GetFlags() const { return m_flags; }
-        bool HasFlag(uint8 flag) const { return m_flags & flag; }
+        typedef std::map<uint64, PlayerInfo> PlayerContainer;
+        typedef std::set<uint64> BannedContainer;
 
-        void Join(uint64 p, const char *pass);
-        void Leave(uint64 p, bool send = true);
-        void KickOrBan(uint64 good, const char *badname, bool ban);
-        void Kick(uint64 good, const char *badname) { KickOrBan(good, badname, false); }
-        void Ban(uint64 good, const char *badname) { KickOrBan(good, badname, true); }
-        void UnBan(uint64 good, const char *badname);
-        void Password(uint64 p, const char *pass);
-        void SetMode(uint64 p, const char *p2n, bool mod, bool set);
-        void SetOwner(uint64 p, bool exclaim = true);
-        void SetOwner(uint64 p, const char *newname);
-        void SendWhoOwner(uint64 p);
-        void SetModerator(uint64 p, const char *newname) { SetMode(p, newname, true, true); }
-        void UnsetModerator(uint64 p, const char *newname) { SetMode(p, newname, true, false); }
-        void SetMute(uint64 p, const char *newname) { SetMode(p, newname, false, true); }
-        void UnsetMute(uint64 p, const char *newname) { SetMode(p, newname, false, false); }
-        void List(Player* p);
-        void Announce(uint64 p);
-        void Say(uint64 p, const char *what, uint32 lang);
-        void Invite(uint64 p, const char *newp);
-        void Voice(uint64 guid1, uint64 guid2);
-        void DeVoice(uint64 guid1, uint64 guid2);
-        void JoinNotify(uint64 guid);                                           // invisible notify
-        void LeaveNotify(uint64 guid);                                          // invisible notify
-        void SetOwnership(bool ownership) { m_ownership = ownership; };
-        static void CleanOldChannelsInDB();
+        bool _announce;
+        bool _ownership;
+        bool _IsSaved;
+        uint8 _flags;
+        uint32 _channelId;
+        uint32 _Team;
+        uint64 _ownerGUID;
+        std::string _name;
+        std::string _password;
+        PlayerContainer playersStore;
+        BannedContainer bannedStore;
 };
 #endif
 
diff --git a/src/server/game/Chat/Channels/ChannelMgr.cpp b/src/server/game/Chat/Channels/ChannelMgr.cpp
index 4c1db28c18b..b903f15c9a8 100755
--- a/src/server/game/Chat/Channels/ChannelMgr.cpp
+++ b/src/server/game/Chat/Channels/ChannelMgr.cpp
@@ -36,6 +36,7 @@ ChannelMgr* ChannelMgr::forTeam(uint32 team)
 
     if (team == ALLIANCE)
         return ACE_Singleton<AllianceChannelMgr, ACE_Null_Mutex>::instance();
+
     if (team == HORDE)
         return ACE_Singleton<HordeChannelMgr, ACE_Null_Mutex>::instance();
 
@@ -79,8 +80,8 @@ Channel* ChannelMgr::GetChannel(std::string const& name, Player* player, bool pk
 
         return NULL;
     }
-    else
-        return i->second;
+
+    return i->second;
 }
 
 void ChannelMgr::LeftChannel(std::string const& name)
@@ -96,7 +97,7 @@ void ChannelMgr::LeftChannel(std::string const& name)
 
     Channel* channel = i->second;
 
-    if (channel->GetNumPlayers() == 0 && !channel->IsConstant())
+    if (!channel->GetNumPlayers() && !channel->IsConstant())
     {
         channels.erase(wname);
         delete channel;
@@ -105,6 +106,6 @@ void ChannelMgr::LeftChannel(std::string const& name)
 
 void ChannelMgr::MakeNotOnPacket(WorldPacket* data, std::string const& name)
 {
-    data->Initialize(SMSG_CHANNEL_NOTIFY, (1+10));  // we guess size
-    (*data) << (uint8)0x05 << name;
+    data->Initialize(SMSG_CHANNEL_NOTIFY, 1 + name.size());
+    (*data) << uint8(5) << name;
 }
diff --git a/src/server/game/Chat/ChatLink.cpp b/src/server/game/Chat/ChatLink.cpp
index 8c2a3a22a70..218564c9f36 100644
--- a/src/server/game/Chat/ChatLink.cpp
+++ b/src/server/game/Chat/ChatLink.cpp
@@ -76,7 +76,7 @@ inline bool CheckDelimiter(std::istringstream& iss, char delimiter, const char*
     char c = iss.peek();
     if (c != delimiter)
     {
-        sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): invalid %s link structure ('%c' expected, '%c' found)", iss.str().c_str(), context, delimiter, c);
+        sLog->outTrace(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): invalid %s link structure ('%c' expected, '%c' found)", iss.str().c_str(), context, delimiter, c);
         return false;
     }
     iss.ignore(1);
@@ -110,20 +110,20 @@ bool ItemChatLink::Initialize(std::istringstream& iss)
     uint32 itemEntry = 0;
     if (!ReadUInt32(iss, itemEntry))
     {
-        sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): sequence finished unexpectedly while reading item entry", iss.str().c_str());
+        sLog->outTrace(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): sequence finished unexpectedly while reading item entry", iss.str().c_str());
         return false;
     }
     // Validate item
     _item = sObjectMgr->GetItemTemplate(itemEntry);
     if (!_item)
     {
-        sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): got invalid itemEntry %u in |item command", iss.str().c_str(), itemEntry);
+        sLog->outTrace(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): got invalid itemEntry %u in |item command", iss.str().c_str(), itemEntry);
         return false;
     }
     // Validate item's color
     if (_color != ItemQualityColors[_item->Quality])
     {
-        sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): linked item has color %u, but user claims %u", iss.str().c_str(), ItemQualityColors[_item->Quality], _color);
+        sLog->outTrace(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): linked item has color %u, but user claims %u", iss.str().c_str(), ItemQualityColors[_item->Quality], _color);
         return false;
     }
     // Number of various item properties after item entry
@@ -137,7 +137,7 @@ bool ItemChatLink::Initialize(std::istringstream& iss)
         int32 id = 0;
         if (!ReadInt32(iss, id))
         {
-            sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): sequence finished unexpectedly while reading item property (%u)", iss.str().c_str(), index);
+            sLog->outTrace(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): sequence finished unexpectedly while reading item property (%u)", iss.str().c_str(), index);
             return false;
         }
         if (id && (index == randomPropertyPosition))
@@ -148,7 +148,7 @@ bool ItemChatLink::Initialize(std::istringstream& iss)
                 _property = sItemRandomPropertiesStore.LookupEntry(id);
                 if (!_property)
                 {
-                    sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): got invalid item property id %u in |item command", iss.str().c_str(), id);
+                    sLog->outTrace(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): got invalid item property id %u in |item command", iss.str().c_str(), id);
                     return false;
                 }
             }
@@ -157,7 +157,7 @@ bool ItemChatLink::Initialize(std::istringstream& iss)
                 _suffix = sItemRandomSuffixStore.LookupEntry(-id);
                 if (!_suffix)
                 {
-                    sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): got invalid item suffix id %u in |item command", iss.str().c_str(), -id);
+                    sLog->outTrace(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): got invalid item suffix id %u in |item command", iss.str().c_str(), -id);
                     return false;
                 }
             }
@@ -199,7 +199,7 @@ bool ItemChatLink::ValidateName(char* buffer, const char* context)
         }
     }
     if (!res)
-        sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): linked item (id: %u) name wasn't found in any localization", context, _item->ItemId);
+        sLog->outTrace(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): linked item (id: %u) name wasn't found in any localization", context, _item->ItemId);
     return res;
 }
 
@@ -211,14 +211,14 @@ bool QuestChatLink::Initialize(std::istringstream& iss)
     uint32 questId = 0;
     if (!ReadUInt32(iss, questId))
     {
-        sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): sequence finished unexpectedly while reading quest entry", iss.str().c_str());
+        sLog->outTrace(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): sequence finished unexpectedly while reading quest entry", iss.str().c_str());
         return false;
     }
     // Validate quest
     _quest = sObjectMgr->GetQuestTemplate(questId);
     if (!_quest)
     {
-        sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): quest template %u not found", iss.str().c_str(), questId);
+        sLog->outTrace(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): quest template %u not found", iss.str().c_str(), questId);
         return false;
     }
     // Check delimiter
@@ -227,13 +227,13 @@ bool QuestChatLink::Initialize(std::istringstream& iss)
     // Read quest level
     if (!ReadInt32(iss, _questLevel))
     {
-        sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): sequence finished unexpectedly while reading quest level", iss.str().c_str());
+        sLog->outTrace(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): sequence finished unexpectedly while reading quest level", iss.str().c_str());
         return false;
     }
     // Validate quest level
     if (_questLevel >= STRONG_MAX_LEVEL)
     {
-        sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): quest level %d is too big", iss.str().c_str(), _questLevel);
+        sLog->outTrace(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): quest level %d is too big", iss.str().c_str(), _questLevel);
         return false;
     }
     return true;
@@ -253,7 +253,7 @@ bool QuestChatLink::ValidateName(char* buffer, const char* context)
                     break;
                 }
     if (!res)
-        sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): linked quest (id: %u) title wasn't found in any localization", context, _quest->GetQuestId());
+        sLog->outTrace(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): linked quest (id: %u) title wasn't found in any localization", context, _quest->GetQuestId());
     return res;
 }
 
@@ -267,14 +267,14 @@ bool SpellChatLink::Initialize(std::istringstream& iss)
     uint32 spellId = 0;
     if (!ReadUInt32(iss, spellId))
     {
-        sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): sequence finished unexpectedly while reading spell entry", iss.str().c_str());
+        sLog->outTrace(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): sequence finished unexpectedly while reading spell entry", iss.str().c_str());
         return false;
     }
     // Validate spell
     _spell = sSpellMgr->GetSpellInfo(spellId);
     if (!_spell)
     {
-        sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): got invalid spell id %u in |spell command", iss.str().c_str(), spellId);
+        sLog->outTrace(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): got invalid spell id %u in |spell command", iss.str().c_str(), spellId);
         return false;
     }
     return true;
@@ -290,19 +290,19 @@ bool SpellChatLink::ValidateName(char* buffer, const char* context)
         SkillLineAbilityMapBounds bounds = sSpellMgr->GetSkillLineAbilityMapBounds(_spell->Id);
         if (bounds.first == bounds.second)
         {
-            sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): skill line not found for spell %u", context, _spell->Id);
+            sLog->outTrace(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): skill line not found for spell %u", context, _spell->Id);
             return false;
         }
         SkillLineAbilityEntry const* skillInfo = bounds.first->second;
         if (!skillInfo)
         {
-            sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): skill line ability not found for spell %u", context, _spell->Id);
+            sLog->outTrace(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): skill line ability not found for spell %u", context, _spell->Id);
             return false;
         }
         SkillLineEntry const* skillLine = sSkillLineStore.LookupEntry(skillInfo->skillId);
         if (!skillLine)
         {
-            sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): skill line not found for skill %u", context, skillInfo->skillId);
+            sLog->outTrace(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): skill line not found for skill %u", context, skillInfo->skillId);
             return false;
         }
 
@@ -319,7 +319,7 @@ bool SpellChatLink::ValidateName(char* buffer, const char* context)
     if (*_spell->SpellName && strcmp(_spell->SpellName, buffer) == 0)
         return true;
 
-    sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): linked spell (id: %u) name wasn't found in any localization", context, _spell->Id);
+    sLog->outTrace(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): linked spell (id: %u) name wasn't found in any localization", context, _spell->Id);
     return false;
 }
 
@@ -333,14 +333,14 @@ bool AchievementChatLink::Initialize(std::istringstream& iss)
     uint32 achievementId = 0;
     if (!ReadUInt32(iss, achievementId))
     {
-        sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): sequence finished unexpectedly while reading achievement entry", iss.str().c_str());
+        sLog->outTrace(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): sequence finished unexpectedly while reading achievement entry", iss.str().c_str());
         return false;
     }
     // Validate achievement
     _achievement = sAchievementMgr->GetAchievement(achievementId);
     if (!_achievement)
     {
-        sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): got invalid achivement id %u in |achievement command", iss.str().c_str(), achievementId);
+        sLog->outTrace(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): got invalid achivement id %u in |achievement command", iss.str().c_str(), achievementId);
         return false;
     }
     // Check delimiter
@@ -349,7 +349,7 @@ bool AchievementChatLink::Initialize(std::istringstream& iss)
     // Read HEX
     if (!ReadHex(iss, _guid, 0))
     {
-        sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): invalid hexadecimal number while reading char's guid", iss.str().c_str());
+        sLog->outTrace(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): invalid hexadecimal number while reading char's guid", iss.str().c_str());
         return false;
     }
     // Skip progress
@@ -361,7 +361,7 @@ bool AchievementChatLink::Initialize(std::istringstream& iss)
 
         if (!ReadUInt32(iss, _data[index]))
         {
-            sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): sequence finished unexpectedly while reading achievement property (%u)", iss.str().c_str(), index);
+            sLog->outTrace(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): sequence finished unexpectedly while reading achievement property (%u)", iss.str().c_str(), index);
             return false;
         }
     }
@@ -375,7 +375,7 @@ bool AchievementChatLink::ValidateName(char* buffer, const char* context)
     if (*_achievement->name && strcmp(_achievement->name, buffer) == 0)
         return true;
 
-    sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): linked achievement (id: %u) name wasn't found in any localization", context, _achievement->ID);
+    sLog->outTrace(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): linked achievement (id: %u) name wasn't found in any localization", context, _achievement->ID);
     return false;
 }
 
@@ -389,14 +389,14 @@ bool TradeChatLink::Initialize(std::istringstream& iss)
     uint32 spellId = 0;
     if (!ReadUInt32(iss, spellId))
     {
-        sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): sequence finished unexpectedly while reading achievement entry", iss.str().c_str());
+        sLog->outTrace(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): sequence finished unexpectedly while reading achievement entry", iss.str().c_str());
         return false;
     }
     // Validate spell
     _spell = sSpellMgr->GetSpellInfo(spellId);
     if (!_spell)
     {
-        sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): got invalid spell id %u in |trade command", iss.str().c_str(), spellId);
+        sLog->outTrace(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): got invalid spell id %u in |trade command", iss.str().c_str(), spellId);
         return false;
     }
     // Check delimiter
@@ -405,7 +405,7 @@ bool TradeChatLink::Initialize(std::istringstream& iss)
     // Minimum talent level
     if (!ReadInt32(iss, _minSkillLevel))
     {
-        sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): sequence finished unexpectedly while reading minimum talent level", iss.str().c_str());
+        sLog->outTrace(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): sequence finished unexpectedly while reading minimum talent level", iss.str().c_str());
         return false;
     }
     // Check delimiter
@@ -414,7 +414,7 @@ bool TradeChatLink::Initialize(std::istringstream& iss)
     // Maximum talent level
     if (!ReadInt32(iss, _maxSkillLevel))
     {
-        sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): sequence finished unexpectedly while reading maximum talent level", iss.str().c_str());
+        sLog->outTrace(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): sequence finished unexpectedly while reading maximum talent level", iss.str().c_str());
         return false;
     }
     // Check delimiter
@@ -423,7 +423,7 @@ bool TradeChatLink::Initialize(std::istringstream& iss)
     // Something hexadecimal
     if (!ReadHex(iss, _guid, 0))
     {
-        sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): sequence finished unexpectedly while reading achievement's owner guid", iss.str().c_str());
+        sLog->outTrace(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): sequence finished unexpectedly while reading achievement's owner guid", iss.str().c_str());
         return false;
     }
     // Skip base64 encoded stuff
@@ -440,21 +440,21 @@ bool TalentChatLink::Initialize(std::istringstream& iss)
     // Read talent entry
     if (!ReadUInt32(iss, _talentId))
     {
-        sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): sequence finished unexpectedly while reading talent entry", iss.str().c_str());
+        sLog->outTrace(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): sequence finished unexpectedly while reading talent entry", iss.str().c_str());
         return false;
     }
     // Validate talent
     TalentEntry const* talentInfo = sTalentStore.LookupEntry(_talentId);
     if (!talentInfo)
     {
-        sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): got invalid talent id %u in |talent command", iss.str().c_str(), _talentId);
+        sLog->outTrace(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): got invalid talent id %u in |talent command", iss.str().c_str(), _talentId);
         return false;
     }
     // Validate talent's spell
     _spell = sSpellMgr->GetSpellInfo(talentInfo->RankID[0]);
     if (!_spell)
     {
-        sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): got invalid spell id %u in |trade command", iss.str().c_str(), talentInfo->RankID[0]);
+        sLog->outTrace(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): got invalid spell id %u in |trade command", iss.str().c_str(), talentInfo->RankID[0]);
         return false;
     }
     // Delimiter
@@ -463,7 +463,7 @@ bool TalentChatLink::Initialize(std::istringstream& iss)
     // Rank
     if (!ReadInt32(iss, _rankId))
     {
-        sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): sequence finished unexpectedly while reading talent rank", iss.str().c_str());
+        sLog->outTrace(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): sequence finished unexpectedly while reading talent rank", iss.str().c_str());
         return false;
     }
     return true;
@@ -479,14 +479,14 @@ bool EnchantmentChatLink::Initialize(std::istringstream& iss)
     uint32 spellId = 0;
     if (!ReadUInt32(iss, spellId))
     {
-        sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): sequence finished unexpectedly while reading enchantment spell entry", iss.str().c_str());
+        sLog->outTrace(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): sequence finished unexpectedly while reading enchantment spell entry", iss.str().c_str());
         return false;
     }
     // Validate spell
     _spell = sSpellMgr->GetSpellInfo(spellId);
     if (!_spell)
     {
-        sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): got invalid spell id %u in |enchant command", iss.str().c_str(), spellId);
+        sLog->outTrace(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): got invalid spell id %u in |enchant command", iss.str().c_str(), spellId);
         return false;
     }
     return true;
@@ -501,7 +501,7 @@ bool GlyphChatLink::Initialize(std::istringstream& iss)
     // Slot
     if (!ReadUInt32(iss, _slotId))
     {
-        sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): sequence finished unexpectedly while reading slot id", iss.str().c_str());
+        sLog->outTrace(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): sequence finished unexpectedly while reading slot id", iss.str().c_str());
         return false;
     }
     // Check delimiter
@@ -511,21 +511,21 @@ bool GlyphChatLink::Initialize(std::istringstream& iss)
     uint32 glyphId = 0;
     if (!ReadUInt32(iss, glyphId))
     {
-        sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): sequence finished unexpectedly while reading glyph entry", iss.str().c_str());
+        sLog->outTrace(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): sequence finished unexpectedly while reading glyph entry", iss.str().c_str());
         return false;
     }
     // Validate glyph
     _glyph = sGlyphPropertiesStore.LookupEntry(glyphId);
     if (!_glyph)
     {
-        sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): got invalid glyph id %u in |glyph command", iss.str().c_str(), glyphId);
+        sLog->outTrace(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): got invalid glyph id %u in |glyph command", iss.str().c_str(), glyphId);
         return false;
     }
     // Validate glyph's spell
     _spell = sSpellMgr->GetSpellInfo(_glyph->SpellId);
     if (!_spell)
     {
-        sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): got invalid spell id %u in |glyph command", iss.str().c_str(), _glyph->SpellId);
+        sLog->outTrace(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): got invalid spell id %u in |glyph command", iss.str().c_str(), _glyph->SpellId);
         return false;
     }
     return true;
@@ -563,14 +563,14 @@ bool LinkExtractor::IsValidMessage()
         }
         else if (_iss.get() != PIPE_CHAR)
         {
-            sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): sequence aborted unexpectedly", _iss.str().c_str());
+            sLog->outTrace(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): sequence aborted unexpectedly", _iss.str().c_str());
             return false;
         }
 
         // pipe has always to be followed by at least one char
         if (_iss.peek() == '\0')
         {
-            sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): pipe followed by '\\0'", _iss.str().c_str());
+            sLog->outTrace(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): pipe followed by '\\0'", _iss.str().c_str());
             return false;
         }
 
@@ -593,14 +593,14 @@ bool LinkExtractor::IsValidMessage()
             }
             else
             {
-                sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): invalid sequence, expected '%c' but got '%c'", _iss.str().c_str(), *validSequenceIterator, commandChar);
+                sLog->outTrace(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): invalid sequence, expected '%c' but got '%c'", _iss.str().c_str(), *validSequenceIterator, commandChar);
                 return false;
             }
         }
         else if (validSequence != validSequenceIterator)
         {
             // no escaped pipes in sequences
-            sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): got escaped pipe in sequence", _iss.str().c_str());
+            sLog->outTrace(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): got escaped pipe in sequence", _iss.str().c_str());
             return false;
         }
 
@@ -609,7 +609,7 @@ bool LinkExtractor::IsValidMessage()
             case 'c':
                 if (!ReadHex(_iss, color, 8))
                 {
-                    sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): invalid hexadecimal number while reading color", _iss.str().c_str());
+                    sLog->outTrace(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): invalid hexadecimal number while reading color", _iss.str().c_str());
                     return false;
                 }
                 break;
@@ -618,7 +618,7 @@ bool LinkExtractor::IsValidMessage()
                 _iss.getline(buffer, 256, DELIMITER);
                 if (_iss.eof())
                 {
-                    sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): sequence finished unexpectedly", _iss.str().c_str());
+                    sLog->outTrace(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): sequence finished unexpectedly", _iss.str().c_str());
                     return false;
                 }
 
@@ -640,7 +640,7 @@ bool LinkExtractor::IsValidMessage()
                     link = new GlyphChatLink();
                 else
                 {
-                    sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): user sent unsupported link type '%s'", _iss.str().c_str(), buffer);
+                    sLog->outTrace(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): user sent unsupported link type '%s'", _iss.str().c_str(), buffer);
                     return false;
                 }
                 _links.push_back(link);
@@ -655,13 +655,13 @@ bool LinkExtractor::IsValidMessage()
                     // links start with '['
                     if (_iss.get() != '[')
                     {
-                        sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): link caption doesn't start with '['", _iss.str().c_str());
+                        sLog->outTrace(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): link caption doesn't start with '['", _iss.str().c_str());
                         return false;
                     }
                     _iss.getline(buffer, 256, ']');
                     if (_iss.eof())
                     {
-                        sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): sequence finished unexpectedly", _iss.str().c_str());
+                        sLog->outTrace(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): sequence finished unexpectedly", _iss.str().c_str());
                         return false;
                     }
 
@@ -679,7 +679,7 @@ bool LinkExtractor::IsValidMessage()
                 // no further payload
                 break;
             default:
-                sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): got invalid command |%c", _iss.str().c_str(), commandChar);
+                sLog->outTrace(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): got invalid command |%c", _iss.str().c_str(), commandChar);
                 return false;
         }
     }
@@ -687,7 +687,7 @@ bool LinkExtractor::IsValidMessage()
     // check if every opened sequence was also closed properly
     if (validSequence != validSequenceIterator)
     {
-        sLog->outDebug(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): EOF in active sequence", _iss.str().c_str());
+        sLog->outTrace(LOG_FILTER_CHATSYS, "ChatHandler::isValidChatMessage('%s'): EOF in active sequence", _iss.str().c_str());
         return false;
     }