Channel Class Reference

#include <Channel.h>

Classes
struct	PlayerInfo

Public Member Functions
	Channel (std::string const &name, uint32 channel_id, uint32 Team=0)
std::string const &	GetName () const
uint32	GetChannelId () const
bool	IsConstant () const
bool	IsAnnounce () const
bool	IsLFG () const
std::string const &	GetPassword () const
void	SetPassword (std::string const &npassword)
void	SetAnnounce (bool nannounce)
uint32	GetNumPlayers () const
uint8	GetFlags () const
bool	HasFlag (uint8 flag) const
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)
void	Ban (Player const *player, std::string const &badname)
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 (ObjectGuid const &guid, bool exclaim=true)
void	SetOwner (Player const *player, std::string const &name)
void	SendWhoOwner (Player const *player)
void	SetModerator (Player const *player, std::string const &newname)
void	UnsetModerator (Player const *player, std::string const &newname)
void	SetMute (Player const *player, std::string const &newname)
void	UnsetMute (Player const *player, std::string const &newname)
void	SilenceAll (Player const *player, std::string const &name)
void	SilenceVoice (Player const *player, std::string const &name)
void	UnsilenceAll (Player const *player, std::string const &name)
void	UnsilenceVoice (Player const *player, std::string const &name)
void	List (Player const *player)
void	Announce (Player const *player)
void	Say (ObjectGuid const &guid, std::string const &what, uint32 lang)
void	DeclineInvite (Player const *player)
void	Invite (Player const *player, std::string const &newp)
void	Voice (Player const *player)
void	DeVoice (Player const *player)
void	JoinNotify (Player const *player)
void	LeaveNotify (Player const *player)
void	SetOwnership (bool ownership)

Static Public Member Functions
static void	CleanOldChannelsInDB ()

Private Types
typedef std::map< ObjectGuid, PlayerInfo >	PlayerContainer
typedef GuidSet	BannedContainer

Private Member Functions
void	MakeNotifyPacket (WorldPackets::Channel::ChannelNotify &data, uint8 notifyType)
void	MakeJoined (WorldPackets::Channel::ChannelNotify &data, ObjectGuid const &guid)
void	MakeLeft (WorldPackets::Channel::ChannelNotify &data, ObjectGuid const &guid)
void	MakeYouJoined (WorldPackets::Channel::ChannelNotify &data)
void	MakeYouLeft (WorldPackets::Channel::ChannelNotify &data)
void	MakeWrongPassword (WorldPackets::Channel::ChannelNotify &data)
void	MakeNotMember (WorldPackets::Channel::ChannelNotify &data)
void	MakeNotModerator (WorldPackets::Channel::ChannelNotify &data)
void	MakePasswordChanged (WorldPackets::Channel::ChannelNotify &data, ObjectGuid const &guid)
void	MakeOwnerChanged (WorldPackets::Channel::ChannelNotify &data, ObjectGuid const &guid)
void	MakePlayerNotFound (WorldPackets::Channel::ChannelNotify &data, std::string const &name)
void	MakeNotOwner (WorldPackets::Channel::ChannelNotify &data)
void	MakeChannelOwner (WorldPackets::Channel::ChannelNotify &data)
void	MakeModeChange (WorldPackets::Channel::ChannelNotify &data, ObjectGuid const &guid, uint8 oldFlags, uint8 newFlags)
void	MakeAnnouncementsOn (WorldPackets::Channel::ChannelNotify &data, ObjectGuid const &guid)
void	MakeAnnouncementsOff (WorldPackets::Channel::ChannelNotify &data, ObjectGuid const &guid)
void	MakeMuted (WorldPackets::Channel::ChannelNotify &data)
void	MakePlayerKicked (WorldPackets::Channel::ChannelNotify &data, ObjectGuid const &bad, ObjectGuid const &good)
void	MakeBanned (WorldPackets::Channel::ChannelNotify &data)
void	MakePlayerBanned (WorldPackets::Channel::ChannelNotify &data, ObjectGuid const &bad, ObjectGuid const &good)
void	MakePlayerUnbanned (WorldPackets::Channel::ChannelNotify &data, ObjectGuid const &bad, ObjectGuid const &good)
void	MakePlayerNotBanned (WorldPackets::Channel::ChannelNotify &data, std::string const &name)
void	MakePlayerAlreadyMember (WorldPackets::Channel::ChannelNotify &data, ObjectGuid const &guid)
void	MakeInvite (WorldPackets::Channel::ChannelNotify &data, ObjectGuid const &guid)
void	MakeInviteWrongFaction (WorldPackets::Channel::ChannelNotify &data)
void	MakeWrongFaction (WorldPackets::Channel::ChannelNotify &data)
void	MakeInvalidName (WorldPackets::Channel::ChannelNotify &data)
void	MakeNotModerated (WorldPackets::Channel::ChannelNotify &data)
void	MakePlayerInvited (WorldPackets::Channel::ChannelNotify &data, std::string const &name)
void	MakePlayerInviteBanned (WorldPackets::Channel::ChannelNotify &data, std::string const &name)
void	MakeThrottled (WorldPackets::Channel::ChannelNotify &data)
void	MakeNotInArea (WorldPackets::Channel::ChannelNotify &data)
void	MakeNotInLfg (WorldPackets::Channel::ChannelNotify &data)
void	MakeVoiceOn (WorldPackets::Channel::ChannelNotify &data, ObjectGuid const &guid)
void	MakeVoiceOff (WorldPackets::Channel::ChannelNotify &data, ObjectGuid const &guid)
void	SendToAll (WorldPacket const *data, ObjectGuid const &guid=ObjectGuid::Empty)
void	SendToAllButOne (WorldPacket const *data, ObjectGuid const &who)
void	SendToOne (WorldPacket const *data, ObjectGuid const &who)
bool	IsOn (ObjectGuid const &who) const
bool	IsBanned (ObjectGuid const &guid) const
void	UpdateChannelInDB () const
void	UpdateChannelUseageInDB () const
uint8	GetPlayerFlags (ObjectGuid const &guid) const
void	SetModerator (ObjectGuid const &guid, bool set)
void	SetMute (ObjectGuid const &guid, bool set)

Private Attributes
bool	_announce
bool	_ownership
bool	_IsSaved
uint8	_flags
uint32	_channelId
uint32	_team
ObjectGuid	_ownerGUID
std::string	_name
std::string	_password
PlayerContainer	_playersStore
BannedContainer	_bannedStore

Member Typedef Documentation

typedef GuidSet Channel::BannedContainer

private

typedef std::map<ObjectGuid, PlayerInfo> Channel::PlayerContainer

private

Constructor & Destructor Documentation

Channel::Channel	(	std::string const &	name,
		uint32	channel_id,
		uint32	Team = 0
	)

 :
 _announce(true),
 _ownership(true),
 _IsSaved(false),
 _flags(0),
 _channelId(channelId),
 _team(team),
 _name(name)
{
 // set special flags if built-in channel
 if (ChatChannelsEntry const* ch = sChatChannelsStore.LookupEntry(channelId)) // check whether it's a built-in channel
 {
 _announce = false; // no join/leave announces
 _ownership = false; // no ownership handout

 _flags |= CHANNEL_FLAG_GENERAL; // for all built-in channels

 if (ch->Flags & CHANNEL_DBC_FLAG_TRADE) // for trade channel
 _flags |= CHANNEL_FLAG_TRADE;

 if (ch->Flags & CHANNEL_DBC_FLAG_CITY_ONLY2) // for city only channels
 _flags |= CHANNEL_FLAG_CITY;

 if (ch->Flags & CHANNEL_DBC_FLAG_LFG) // for LFG channel
 _flags |= CHANNEL_FLAG_LFG;
 else // for all other channels
 _flags |= CHANNEL_FLAG_NOT_LFG;
 }
 else // it's custom channel
 {
 _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, _team);
 PreparedQueryResult result = CharacterDatabase.Query(stmt);

 if (result) // load
 {
 Field* fields = result->Fetch();
 _announce = fields[0].GetBool();
 _ownership = fields[1].GetBool();
 _password = fields[2].GetString();
 std::string bannedList = fields[3].GetString();

 if (!bannedList.empty())
 {
 Tokenizer tokens(bannedList, ' ');
 for (Tokenizer::const_iterator i = tokens.begin(); i != tokens.end(); ++i)
 {
 std::string bannedGuidStr(*i);
 ObjectGuid bannedGuid;
 bannedGuid.SetRawValue(uint64(strtoull(bannedGuidStr.substr(0, 16).c_str(), nullptr, 16)), uint64(strtoull(bannedGuidStr.substr(16).c_str(), nullptr, 16)));
 if (!bannedGuid.IsEmpty())
 {
 TC_LOG_DEBUG("chat.system", "Channel (%s) loaded bannedStore %s", _name.c_str(), bannedGuid.ToString().c_str());
 _bannedStore.insert(bannedGuid);
 }
 }
 }
 }
 else // save
 {
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_CHANNEL);
 stmt->setString(0, _name);
 stmt->setUInt32(1, _team);
 CharacterDatabase.Execute(stmt);
 TC_LOG_DEBUG("chat.system", "Channel (%s) saved in database", _name.c_str());
 }

 _IsSaved = true;
 }
 }
}

Here is the call graph for this function:

Member Function Documentation

void Channel::Announce

(

Player const *

player

)

{
 ObjectGuid const& guid = player->GetGUID();

 if (!IsOn(guid))
 {
 WorldPackets::Channel::ChannelNotify notify;
 MakeNotMember(notify);
 player->SendDirectMessage(notify.Write());
 return;
 }

 if (!_playersStore[guid].IsModerator() && !player->GetSession()->HasPermission(rbac::RBAC_PERM_CHANGE_CHANNEL_NOT_MODERATOR))
 {
 WorldPackets::Channel::ChannelNotify notify;
 MakeNotModerator(notify);
 player->SendDirectMessage(notify.Write());
 return;
 }

 _announce = !_announce;

 WorldPackets::Channel::ChannelNotify notify;
 if (_announce)
 MakeAnnouncementsOn(notify, guid);
 else
 MakeAnnouncementsOff(notify, guid);
 SendToAll(notify.Write());

 UpdateChannelInDB();
}

Here is the call graph for this function:

void Channel::Ban ( Player const *  player, std::string const &  badname  )

inline

{ KickOrBan(player, badname, true); }

void Channel::CleanOldChannelsInDB ( )

static

{
 if (sWorld->getIntConfig(CONFIG_PRESERVE_CUSTOM_CHANNEL_DURATION) > 0)
 {
 PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_OLD_CHANNELS);
 stmt->setUInt32(0, sWorld->getIntConfig(CONFIG_PRESERVE_CUSTOM_CHANNEL_DURATION) * DAY);
 CharacterDatabase.Execute(stmt);

 TC_LOG_DEBUG("chat.system", "Cleaned out unused custom chat channels.");
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Channel::DeclineInvite

(

Player const *

player

)

{
}

void Channel::DeVoice

(

Player const *

player

)

{
}

uint32 Channel::GetChannelId ( ) const

inline

{ return _channelId; }

Here is the caller graph for this function:

uint8 Channel::GetFlags ( ) const

inline

{ return _flags; }

Here is the caller graph for this function:

std::string const& Channel::GetName ( ) const

inline

{ return _name; }

Here is the caller graph for this function:

uint32 Channel::GetNumPlayers ( ) const

inline

{ return uint32(_playersStore.size()); }

Here is the caller graph for this function:

std::string const& Channel::GetPassword ( ) const

inline

{ return _password; }

uint8 Channel::GetPlayerFlags ( ObjectGuid const &  guid ) const

inlineprivate

 {
 PlayerContainer::const_iterator itr = _playersStore.find(guid);
 return itr != _playersStore.end() ? itr->second.GetFlags() : 0;
 }

Here is the caller graph for this function:

bool Channel::HasFlag ( uint8  flag ) const

inline

{ return (_flags & flag) != 0; }

Here is the caller graph for this function:

void Channel::Invite	(	Player const *	player,
		std::string const &	newp
	)

{
 ObjectGuid const& guid = player->GetGUID();

 if (!IsOn(guid))
 {
 WorldPackets::Channel::ChannelNotify notify;
 MakeNotMember(notify);
 player->SendDirectMessage(notify.Write());
 return;
 }

 Player* newp = ObjectAccessor::FindConnectedPlayerByName(newname);
 if (!newp || !newp->isGMVisible())
 {
 WorldPackets::Channel::ChannelNotify notify;
 MakePlayerNotFound(notify, newname);
 player->SendDirectMessage(notify.Write());
 return;
 }

 if (IsBanned(newp->GetGUID()))
 {
 WorldPackets::Channel::ChannelNotify notify;
 MakePlayerInviteBanned(notify, newname);
 player->SendDirectMessage(notify.Write());
 return;
 }

 if (newp->GetTeam() != player->GetTeam() &&
 (!player->GetSession()->HasPermission(rbac::RBAC_PERM_TWO_SIDE_INTERACTION_CHANNEL) ||
 !newp->GetSession()->HasPermission(rbac::RBAC_PERM_TWO_SIDE_INTERACTION_CHANNEL)))
 {
 WorldPackets::Channel::ChannelNotify notify;
 MakeInviteWrongFaction(notify);
 player->SendDirectMessage(notify.Write());
 return;
 }

 if (IsOn(newp->GetGUID()))
 {
 WorldPackets::Channel::ChannelNotify notify;
 MakePlayerAlreadyMember(notify, newp->GetGUID());
 player->SendDirectMessage(notify.Write());
 return;
 }

 if (!newp->GetSocial()->HasIgnore(guid))
 {
 WorldPackets::Channel::ChannelNotify notify;
 MakeInvite(notify, guid);
 newp->SendDirectMessage(notify.Write());
 }

 WorldPackets::Channel::ChannelNotify notify;
 MakePlayerInvited(notify, newp->GetName());
 player->SendDirectMessage(notify.Write());
}

Here is the call graph for this function:

bool Channel::IsAnnounce ( ) const

inline

{ return _announce; }

bool Channel::IsBanned ( ObjectGuid const &  guid ) const

inlineprivate

{ return _bannedStore.find(guid) != _bannedStore.end(); }

Here is the caller graph for this function:

bool Channel::IsConstant ( ) const

inline

{ return _channelId != 0; }

Here is the caller graph for this function:

bool Channel::IsLFG ( ) const

inline

{ return (GetFlags() & CHANNEL_FLAG_LFG) != 0; }

bool Channel::IsOn ( ObjectGuid const &  who ) const

inlineprivate

{ return _playersStore.find(who) != _playersStore.end(); }

Here is the caller graph for this function:

void Channel::JoinChannel	(	Player *	player,
		std::string const &	pass
	)

{
 ObjectGuid const& guid = player->GetGUID();
 if (IsOn(guid))
 {
 // Do not send error message for built-in channels
 if (!IsConstant())
 {
 WorldPackets::Channel::ChannelNotify notify;
 MakePlayerAlreadyMember(notify, guid);
 player->SendDirectMessage(notify.Write());
 }
 return;
 }

 if (IsBanned(guid))
 {
 WorldPackets::Channel::ChannelNotify notify;
 MakeBanned(notify);
 player->SendDirectMessage(notify.Write());
 return;
 }

 if (!_password.empty() && pass != _password)
 {
 WorldPackets::Channel::ChannelNotify notify;
 MakeWrongPassword(notify);
 player->SendDirectMessage(notify.Write());
 return;
 }

 if (HasFlag(CHANNEL_FLAG_LFG) &&
 sWorld->getBoolConfig(CONFIG_RESTRICTED_LFG_CHANNEL) &&
 AccountMgr::IsPlayerAccount(player->GetSession()->GetSecurity()) && //FIXME: Move to RBAC
 player->GetGroup())
 {
 WorldPackets::Channel::ChannelNotify notify;
 MakeNotInLfg(notify);
 player->SendDirectMessage(notify.Write());
 return;
 }

 player->JoinedChannel(this);

 if (_announce && !player->GetSession()->HasPermission(rbac::RBAC_PERM_SILENTLY_JOIN_CHANNEL))
 {
 WorldPackets::Channel::ChannelNotify notify;
 MakeJoined(notify, guid);
 SendToAll(notify.Write());
 }

 PlayerInfo playerInfo;
 playerInfo.PlayerGuid = guid;
 _playersStore[guid] = playerInfo;

 /*
 WorldPackets::Channel::ChannelNotify notify;
 MakeYouJoined(notify);
 player->SendDirectMessage(notify.Write());
 */

 WorldPackets::Channel::ChannelNotifyJoined notify;
 //notify.ChannelWelcomeMsg = "";
 notify.ChatChannelID = _channelId;
 //notify.InstanceID = 0;
 notify._ChannelFlags = _flags;
 notify._Channel = _name;
 player->SendDirectMessage(notify.Write());

 JoinNotify(player);

 // Custom channel handling
 if (!IsConstant())
 {
 // Update last_used timestamp in db
 if (!_playersStore.empty())
 UpdateChannelUseageInDB();

 // If the channel has no owner yet and ownership is allowed, set the new owner.
 if (_ownerGUID.IsEmpty() && _ownership)
 {
 SetOwner(guid, _playersStore.size() > 1);
 _playersStore[guid].SetModerator(true);
 }
 }
}

Here is the call graph for this function:

void Channel::JoinNotify

(

Player const *

player

)

{
 ObjectGuid const& guid = player->GetGUID();

 if (IsConstant())
 {
 WorldPackets::Channel::UserlistAdd userlistAdd;
 userlistAdd.AddedUserGUID = guid;
 userlistAdd._ChannelFlags = GetFlags();
 userlistAdd.UserFlags = GetPlayerFlags(guid);
 userlistAdd.ChannelID = GetChannelId();
 userlistAdd.ChannelName = GetName();
 SendToAllButOne(userlistAdd.Write(), guid);
 }
 else
 {
 WorldPackets::Channel::UserlistUpdate userlistUpdate;
 userlistUpdate.UpdatedUserGUID = guid;
 userlistUpdate._ChannelFlags = GetFlags();
 userlistUpdate.UserFlags = GetPlayerFlags(guid);
 userlistUpdate.ChannelID = GetChannelId();
 userlistUpdate.ChannelName = GetName();
 SendToAll(userlistUpdate.Write());
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Channel::Kick ( Player const *  player, std::string const &  badname  )

inline

{ KickOrBan(player, badname, false); }

void Channel::KickOrBan	(	Player const *	player,
		std::string const &	badname,
		bool	ban
	)

{
 ObjectGuid const& good = player->GetGUID();

 if (!IsOn(good))
 {
 WorldPackets::Channel::ChannelNotify notify;
 MakeNotMember(notify);
 player->SendDirectMessage(notify.Write());
 return;
 }

 if (!_playersStore[good].IsModerator() && !player->GetSession()->HasPermission(rbac::RBAC_PERM_CHANGE_CHANNEL_NOT_MODERATOR))
 {
 WorldPackets::Channel::ChannelNotify notify;
 MakeNotModerator(notify);
 player->SendDirectMessage(notify.Write());
 return;
 }

 Player* bad = ObjectAccessor::FindConnectedPlayerByName(badname);
 ObjectGuid victim = bad ? bad->GetGUID() : ObjectGuid::Empty;
 if (!victim || !IsOn(victim))
 {
 WorldPackets::Channel::ChannelNotify notify;
 MakePlayerNotFound(notify, badname);
 player->SendDirectMessage(notify.Write());
 return;
 }

 bool changeowner = _ownerGUID == victim;

 if (!player->GetSession()->HasPermission(rbac::RBAC_PERM_CHANGE_CHANNEL_NOT_MODERATOR) && changeowner && good != _ownerGUID)
 {
 WorldPackets::Channel::ChannelNotify notify;
 MakeNotOwner(notify);
 player->SendDirectMessage(notify.Write());
 return;
 }

 if (ban && !IsBanned(victim))
 {
 _bannedStore.insert(victim);
 UpdateChannelInDB();

 if (!player->GetSession()->HasPermission(rbac::RBAC_PERM_SILENTLY_JOIN_CHANNEL))
 {
 WorldPackets::Channel::ChannelNotify notify;
 MakePlayerBanned(notify, victim, good);
 SendToAll(notify.Write());
 }
 }
 else if (!player->GetSession()->HasPermission(rbac::RBAC_PERM_SILENTLY_JOIN_CHANNEL))
 {
 WorldPackets::Channel::ChannelNotify notify;
 MakePlayerKicked(notify, victim, good);
 SendToAll(notify.Write());
 }

 _playersStore.erase(victim);
 bad->LeftChannel(this);

 if (changeowner && _ownership && !_playersStore.empty())
 {
 _playersStore[good].SetModerator(true);
 SetOwner(good);
 }
}

Here is the call graph for this function:

void Channel::LeaveChannel	(	Player *	player,
		bool	send = true
	)

{
 ObjectGuid const& guid = player->GetGUID();
 if (!IsOn(guid))
 {
 if (send)
 {
 WorldPackets::Channel::ChannelNotify notify;
 MakeNotMember(notify);
 player->SendDirectMessage(notify.Write());
 }
 return;
 }

 player->LeftChannel(this);

 if (send)
 {
 /*
 WorldPackets::Channel::ChannelNotify notify;
 MakeYouLeft(notify);
 player->SendDirectMessage(notify.Write());
 */

 WorldPackets::Channel::ChannelNotifyLeft notify;
 notify.Channel = _name;
 notify.ChatChannelID = 0;
 //notify.Suspended = false;
 player->SendDirectMessage(notify.Write());
 }

 bool changeowner = _playersStore[guid].IsOwner();

 _playersStore.erase(guid);

 if (_announce && !player->GetSession()->HasPermission(rbac::RBAC_PERM_SILENTLY_JOIN_CHANNEL))
 {
 WorldPackets::Channel::ChannelNotify notify;
 MakeLeft(notify, guid);
 SendToAll(notify.Write());
 }

 LeaveNotify(player);

 if (!IsConstant())
 {
 // Update last_used timestamp in db
 UpdateChannelUseageInDB();

 // If the channel owner left and there are still playersStore inside, pick a new owner
 if (changeowner && _ownership && !_playersStore.empty())
 {
 ObjectGuid const& newowner = _playersStore.begin()->second.PlayerGuid;
 _playersStore[newowner].SetModerator(true);
 SetOwner(newowner);
 }
 }
}

Here is the call graph for this function:

void Channel::LeaveNotify

(

Player const *

player

)

{
 ObjectGuid const& guid = player->GetGUID();
 WorldPackets::Channel::UserlistRemove userlistRemove;
 userlistRemove.RemovedUserGUID = guid;
 userlistRemove._ChannelFlags = GetFlags();
 userlistRemove.ChannelID = GetChannelId();
 userlistRemove.ChannelName = GetName();

 if (IsConstant())
 SendToAllButOne(userlistRemove.Write(), guid);
 else
 SendToAll(userlistRemove.Write());
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Channel::List

(

Player const *

player

)

always true?

{
 if (!IsOn(player->GetGUID()))
 {
 WorldPackets::Channel::ChannelNotify notify;
 MakeNotMember(notify);
 player->SendDirectMessage(notify.Write());
 return;
 }

 TC_LOG_DEBUG("chat.system", "SMSG_CHANNEL_LIST %s Channel: %s",
 player->GetSession()->GetPlayerInfo().c_str(), GetName().c_str());

 WorldPackets::Channel::ChannelListResponse list;
 list._Display = true; 
 list._Channel = GetName();
 list._ChannelFlags = GetFlags();

 uint32 gmLevelInWhoList = sWorld->getIntConfig(CONFIG_GM_LEVEL_IN_WHO_LIST);

 list._Members.reserve(_playersStore.size());
 for (PlayerContainer::value_type const& i : _playersStore)
 {
 Player* member = ObjectAccessor::FindConnectedPlayer(i.first);

 // PLAYER can't see MODERATOR, GAME MASTER, ADMINISTRATOR characters
 // MODERATOR, GAME MASTER, ADMINISTRATOR can see all
 if (member &&
 (player->GetSession()->HasPermission(rbac::RBAC_PERM_WHO_SEE_ALL_SEC_LEVELS) ||
 member->GetSession()->GetSecurity() <= AccountTypes(gmLevelInWhoList)) &&
 member->IsVisibleGloballyFor(player))
 {
 list._Members.emplace_back(i.second.PlayerGuid, GetVirtualRealmAddress(), i.second.GetFlags());
 }
 }

 player->SendDirectMessage(list.Write());
}

Here is the call graph for this function:

void Channel::MakeAnnouncementsOff ( WorldPackets::Channel::ChannelNotify &  data, ObjectGuid const &  guid  )

private

{
 MakeNotifyPacket(data, CHAT_ANNOUNCEMENTS_OFF_NOTICE);
 data.SenderGuid = guid;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Channel::MakeAnnouncementsOn ( WorldPackets::Channel::ChannelNotify &  data, ObjectGuid const &  guid  )

private

{
 MakeNotifyPacket(data, CHAT_ANNOUNCEMENTS_ON_NOTICE);
 data.SenderGuid = guid;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Channel::MakeBanned ( WorldPackets::Channel::ChannelNotify &  data )

private

{
 MakeNotifyPacket(data, CHAT_BANNED_NOTICE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Channel::MakeChannelOwner ( WorldPackets::Channel::ChannelNotify &  data )

private

{
 std::string name;

 if (!ObjectMgr::GetPlayerNameByGUID(_ownerGUID, name) || name.empty())
 name = "PLAYER_NOT_FOUND";

 MakeNotifyPacket(data, CHAT_CHANNEL_OWNER_NOTICE);
 data.Sender = ((IsConstant() || !_ownerGUID) ? "Nobody" : name);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Channel::MakeInvalidName ( WorldPackets::Channel::ChannelNotify &  data )

private

{
 MakeNotifyPacket(data, CHAT_INVALID_NAME_NOTICE);
}

Here is the call graph for this function:

void Channel::MakeInvite ( WorldPackets::Channel::ChannelNotify &  data, ObjectGuid const &  guid  )

private

{
 MakeNotifyPacket(data, CHAT_INVITE_NOTICE);
 data.SenderGuid = guid;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Channel::MakeInviteWrongFaction ( WorldPackets::Channel::ChannelNotify &  data )

private

{
 MakeNotifyPacket(data, CHAT_INVITE_WRONG_FACTION_NOTICE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Channel::MakeJoined ( WorldPackets::Channel::ChannelNotify &  data, ObjectGuid const &  guid  )

private

{
 MakeNotifyPacket(data, CHAT_JOINED_NOTICE);
 data.SenderGuid = guid;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Channel::MakeLeft ( WorldPackets::Channel::ChannelNotify &  data, ObjectGuid const &  guid  )

private

{
    MakeNotifyPacket(data, CHAT_LEFT_NOTICE);
    data.SenderGuid = guid;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Channel::MakeModeChange ( WorldPackets::Channel::ChannelNotify &  data, ObjectGuid const &  guid, uint8  oldFlags, uint8  newFlags  )

private

{
    MakeNotifyPacket(data, CHAT_MODE_CHANGE_NOTICE);
    data.SenderGuid = guid;
    data.OldFlags = oldFlags;
    data.NewFlags = newFlags;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Channel::MakeMuted ( WorldPackets::Channel::ChannelNotify &  data )

private

{
    MakeNotifyPacket(data, CHAT_MUTED_NOTICE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Channel::MakeNotifyPacket ( WorldPackets::Channel::ChannelNotify &  data, uint8  notifyType  )

private

{
    data.Type = notifyType;
    data._Channel = _name;
}

Here is the caller graph for this function:

void Channel::MakeNotInArea ( WorldPackets::Channel::ChannelNotify &  data )

private

{
    MakeNotifyPacket(data, CHAT_NOT_IN_AREA_NOTICE);
}

Here is the call graph for this function:

void Channel::MakeNotInLfg ( WorldPackets::Channel::ChannelNotify &  data )

private

{
    MakeNotifyPacket(data, CHAT_NOT_IN_LFG_NOTICE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Channel::MakeNotMember ( WorldPackets::Channel::ChannelNotify &  data )

private

{
    MakeNotifyPacket(data, CHAT_NOT_MEMBER_NOTICE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Channel::MakeNotModerated ( WorldPackets::Channel::ChannelNotify &  data )

private

{
    MakeNotifyPacket(data, CHAT_NOT_MODERATED_NOTICE);
}

Here is the call graph for this function:

void Channel::MakeNotModerator ( WorldPackets::Channel::ChannelNotify &  data )

private

{
    MakeNotifyPacket(data, CHAT_NOT_MODERATOR_NOTICE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Channel::MakeNotOwner ( WorldPackets::Channel::ChannelNotify &  data )

private

{
    MakeNotifyPacket(data, CHAT_NOT_OWNER_NOTICE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Channel::MakeOwnerChanged ( WorldPackets::Channel::ChannelNotify &  data, ObjectGuid const &  guid  )

private

{
    MakeNotifyPacket(data, CHAT_OWNER_CHANGED_NOTICE);
    data.SenderGuid = guid;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Channel::MakePasswordChanged ( WorldPackets::Channel::ChannelNotify &  data, ObjectGuid const &  guid  )

private

{
    MakeNotifyPacket(data, CHAT_PASSWORD_CHANGED_NOTICE);
    data.SenderGuid = guid;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Channel::MakePlayerAlreadyMember ( WorldPackets::Channel::ChannelNotify &  data, ObjectGuid const &  guid  )

private

{
    MakeNotifyPacket(data, CHAT_PLAYER_ALREADY_MEMBER_NOTICE);
    data.SenderGuid = guid;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Channel::MakePlayerBanned ( WorldPackets::Channel::ChannelNotify &  data, ObjectGuid const &  bad, ObjectGuid const &  good  )

private

{
    MakeNotifyPacket(data, CHAT_PLAYER_BANNED_NOTICE);
    data.SenderGuid = good;
    data.TargetGuid = bad;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Channel::MakePlayerInviteBanned ( WorldPackets::Channel::ChannelNotify &  data, std::string const &  name  )

private

{
    MakeNotifyPacket(data, CHAT_PLAYER_INVITE_BANNED_NOTICE);
    data.Sender = name;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Channel::MakePlayerInvited ( WorldPackets::Channel::ChannelNotify &  data, std::string const &  name  )

private

{
    MakeNotifyPacket(data, CHAT_PLAYER_INVITED_NOTICE);
    data.Sender = name;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Channel::MakePlayerKicked ( WorldPackets::Channel::ChannelNotify &  data, ObjectGuid const &  bad, ObjectGuid const &  good  )

private

{
    MakeNotifyPacket(data, CHAT_PLAYER_KICKED_NOTICE);
    data.SenderGuid = good;
    data.TargetGuid = bad;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Channel::MakePlayerNotBanned ( WorldPackets::Channel::ChannelNotify &  data, std::string const &  name  )

private

{
    MakeNotifyPacket(data, CHAT_PLAYER_NOT_BANNED_NOTICE);
    data.Sender = name;
}

Here is the call graph for this function:

void Channel::MakePlayerNotFound ( WorldPackets::Channel::ChannelNotify &  data, std::string const &  name  )

private

{
    MakeNotifyPacket(data, CHAT_PLAYER_NOT_FOUND_NOTICE);
    data.Sender = name;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Channel::MakePlayerUnbanned ( WorldPackets::Channel::ChannelNotify &  data, ObjectGuid const &  bad, ObjectGuid const &  good  )

private

{
    MakeNotifyPacket(data, CHAT_PLAYER_UNBANNED_NOTICE);
    data.SenderGuid = good;
    data.TargetGuid = bad;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Channel::MakeThrottled ( WorldPackets::Channel::ChannelNotify &  data )

private

{
    MakeNotifyPacket(data, CHAT_THROTTLED_NOTICE);
}

Here is the call graph for this function:

void Channel::MakeVoiceOff ( WorldPackets::Channel::ChannelNotify &  data, ObjectGuid const &  guid  )

private

{
    MakeNotifyPacket(data, CHAT_VOICE_OFF_NOTICE);
    data.SenderGuid = guid;
}

Here is the call graph for this function:

void Channel::MakeVoiceOn ( WorldPackets::Channel::ChannelNotify &  data, ObjectGuid const &  guid  )

private

{
    MakeNotifyPacket(data, CHAT_VOICE_ON_NOTICE);
    data.SenderGuid = guid;
}

Here is the call graph for this function:

void Channel::MakeWrongFaction ( WorldPackets::Channel::ChannelNotify &  data )

private

{
    MakeNotifyPacket(data, CHAT_WRONG_FACTION_NOTICE);
}

Here is the call graph for this function:

void Channel::MakeWrongPassword ( WorldPackets::Channel::ChannelNotify &  data )

private

{
    MakeNotifyPacket(data, CHAT_WRONG_PASSWORD_NOTICE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Channel::MakeYouJoined ( WorldPackets::Channel::ChannelNotify &  data )

private

{
    MakeNotifyPacket(data, CHAT_YOU_JOINED_NOTICE);
    //*data << uint8(GetFlags());
    data.ChatChannelID = GetChannelId();
    //*data << uint32(0);
}

Here is the call graph for this function:

void Channel::MakeYouLeft ( WorldPackets::Channel::ChannelNotify &  data )

private

{
    MakeNotifyPacket(data, CHAT_YOU_LEFT_NOTICE);
    data.ChatChannelID = GetChannelId();
    //*data << uint8(IsConstant());
}

Here is the call graph for this function:

void Channel::Password	(	Player const *	player,
		std::string const &	pass
	)

{
    ObjectGuid const& guid = player->GetGUID();

    if (!IsOn(guid))
    {
        WorldPackets::Channel::ChannelNotify notify;
        MakeNotMember(notify);
        player->SendDirectMessage(notify.Write());
        return;
    }

    if (!_playersStore[guid].IsModerator() && !player->GetSession()->HasPermission(rbac::RBAC_PERM_CHANGE_CHANNEL_NOT_MODERATOR))
    {
        WorldPackets::Channel::ChannelNotify notify;
        MakeNotModerator(notify);
        player->SendDirectMessage(notify.Write());
        return;
    }

    _password = pass;

    WorldPackets::Channel::ChannelNotify notify;
    MakePasswordChanged(notify, guid);
    SendToAll(notify.Write());

    UpdateChannelInDB();
}

Here is the call graph for this function:

void Channel::Say	(	ObjectGuid const &	guid,
		std::string const &	what,
		uint32	lang
	)

{
    if (what.empty())
        return;

    // TODO: Add proper RBAC check
    if (sWorld->getBoolConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_CHANNEL))
        lang = LANG_UNIVERSAL;

    if (!IsOn(guid))
    {
        WorldPackets::Channel::ChannelNotify notify;
        MakeNotMember(notify);
        SendToOne(notify.Write(), guid);
        return;
    }

    if (_playersStore[guid].IsMuted())
    {
        WorldPackets::Channel::ChannelNotify notify;
        MakeMuted(notify);
        SendToOne(notify.Write(), guid);
        return;
    }

    WorldPackets::Chat::Chat packet;
    if (Player* player = ObjectAccessor::FindConnectedPlayer(guid))
        packet.Initialize(CHAT_MSG_CHANNEL, Language(lang), player, player, what, 0, _name);
    else
    {
        packet.Initialize(CHAT_MSG_CHANNEL, Language(lang), nullptr, nullptr, what, 0, _name);
        packet.SenderGUID = guid;
        packet.TargetGUID = guid;
    }

    SendToAll(packet.Write(), !_playersStore[guid].IsModerator() ? guid : ObjectGuid::Empty);
}

Here is the call graph for this function:

void Channel::SendToAll ( WorldPacket const *  data, ObjectGuid const &  guid = ObjectGuid::Empty  )

private

{
    for (PlayerContainer::value_type const& i : _playersStore)
        if (Player* player = ObjectAccessor::FindConnectedPlayer(i.first))
            if (guid.IsEmpty() || !player->GetSocial()->HasIgnore(guid))
                player->SendDirectMessage(data);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Channel::SendToAllButOne ( WorldPacket const *  data, ObjectGuid const &  who  )

private

{
    for (PlayerContainer::value_type const& i : _playersStore)
        if (i.first != who)
            if (Player* player = ObjectAccessor::FindConnectedPlayer(i.first))
                player->SendDirectMessage(data);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Channel::SendToOne ( WorldPacket const *  data, ObjectGuid const &  who  )

private

{
    if (Player* player = ObjectAccessor::FindConnectedPlayer(who))
        player->SendDirectMessage(data);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Channel::SendWhoOwner

(

Player const *

player

)

{
    WorldPackets::Channel::ChannelNotify notify;
    if (IsOn(player->GetGUID()))
        MakeChannelOwner(notify);
    else
        MakeNotMember(notify);
    player->SendDirectMessage(notify.Write());
}

Here is the call graph for this function:

void Channel::SetAnnounce ( bool  nannounce )

inline

{ _announce = nannounce; }

void Channel::SetMode	(	Player const *	player,
		std::string const &	p2n,
		bool	mod,
		bool	set
	)

{
    ObjectGuid const& guid = player->GetGUID();

    if (!IsOn(guid))
    {
        WorldPackets::Channel::ChannelNotify notify;
        MakeNotMember(notify);
        player->SendDirectMessage(notify.Write());
        return;
    }

    if (!_playersStore[guid].IsModerator() && !player->GetSession()->HasPermission(rbac::RBAC_PERM_CHANGE_CHANNEL_NOT_MODERATOR))
    {
        WorldPackets::Channel::ChannelNotify notify;
        MakeNotModerator(notify);
        player->SendDirectMessage(notify.Write());
        return;
    }

    if (guid == _ownerGUID && p2n == player->GetName() && mod)
        return;

    Player* newp = ObjectAccessor::FindConnectedPlayerByName(p2n);
    ObjectGuid victim = newp ? newp->GetGUID() : ObjectGuid::Empty;

    if (victim.IsEmpty() || !IsOn(victim) ||
        (player->GetTeam() != newp->GetTeam() &&
        (!player->GetSession()->HasPermission(rbac::RBAC_PERM_TWO_SIDE_INTERACTION_CHANNEL) ||
        !newp->GetSession()->HasPermission(rbac::RBAC_PERM_TWO_SIDE_INTERACTION_CHANNEL))))
    {
        WorldPackets::Channel::ChannelNotify notify;
        MakePlayerNotFound(notify, p2n);
        player->SendDirectMessage(notify.Write());
        return;
    }

    if (_ownerGUID == victim && _ownerGUID != guid)
    {
        WorldPackets::Channel::ChannelNotify notify;
        MakeNotOwner(notify);
        player->SendDirectMessage(notify.Write());
        return;
    }

    if (mod)
        SetModerator(newp->GetGUID(), set);
    else
        SetMute(newp->GetGUID(), set);
}

Here is the call graph for this function:

void Channel::SetModerator ( Player const *  player, std::string const &  newname  )

inline

{ SetMode(player, newname, true, true); }

Here is the caller graph for this function:

void Channel::SetModerator ( ObjectGuid const &  guid, bool  set  )

private

{
    if (_playersStore[guid].IsModerator() != set)
    {
        uint8 oldFlag = _playersStore[guid].GetFlags();
        _playersStore[guid].SetModerator(set);

        WorldPackets::Channel::ChannelNotify data;
        MakeModeChange(data, guid, oldFlag, _playersStore[guid].GetFlags());
        SendToAll(data.Write());
    }
}

Here is the call graph for this function:

void Channel::SetMute ( Player const *  player, std::string const &  newname  )

inline

{ SetMode(player, newname, false, true); }

Here is the caller graph for this function:

void Channel::SetMute ( ObjectGuid const &  guid, bool  set  )

private

{
    if (_playersStore[guid].IsMuted() != set)
    {
        uint8 oldFlag = _playersStore[guid].GetFlags();
        _playersStore[guid].SetMuted(set);

        WorldPackets::Channel::ChannelNotify data;
        MakeModeChange(data, guid, oldFlag, _playersStore[guid].GetFlags());
        SendToAll(data.Write());
    }
}

Here is the call graph for this function:

void Channel::SetOwner	(	ObjectGuid const &	guid,
		bool	exclaim = true
	)

{
    if (!_ownerGUID.IsEmpty())
    {
        // [] will re-add player after it possible removed
        PlayerContainer::iterator itr = _playersStore.find(_ownerGUID);
        if (itr != _playersStore.end())
            itr->second.SetOwner(false);
    }

    _ownerGUID = guid;
    if (!_ownerGUID.IsEmpty())
    {
        uint8 oldFlag = _playersStore[_ownerGUID].GetFlags();
        _playersStore[_ownerGUID].SetModerator(true);
        _playersStore[_ownerGUID].SetOwner(true);

        WorldPackets::Channel::ChannelNotify notify;
        MakeModeChange(notify, _ownerGUID, oldFlag, _playersStore[_ownerGUID].GetFlags());
        SendToAll(notify.Write());

        if (exclaim)
        {
            MakeOwnerChanged(notify, _ownerGUID);
            SendToAll(notify.Write());
        }

        UpdateChannelInDB();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Channel::SetOwner	(	Player const *	player,
		std::string const &	name
	)

{
    ObjectGuid const& guid = player->GetGUID();

    if (!IsOn(guid))
    {
        WorldPackets::Channel::ChannelNotify notify;
        MakeNotMember(notify);
        player->SendDirectMessage(notify.Write());
        return;
    }

    if (!player->GetSession()->HasPermission(rbac::RBAC_PERM_CHANGE_CHANNEL_NOT_MODERATOR) && guid != _ownerGUID)
    {
        WorldPackets::Channel::ChannelNotify notify;
        MakeNotOwner(notify);
        player->SendDirectMessage(notify.Write());
        return;
    }

    Player* newp = ObjectAccessor::FindConnectedPlayerByName(newname);
    ObjectGuid victim = newp ? newp->GetGUID() : ObjectGuid::Empty;

    if (!victim || !IsOn(victim) ||
        (player->GetTeam() != newp->GetTeam() &&
        (!player->GetSession()->HasPermission(rbac::RBAC_PERM_TWO_SIDE_INTERACTION_CHANNEL) ||
        !newp->GetSession()->HasPermission(rbac::RBAC_PERM_TWO_SIDE_INTERACTION_CHANNEL))))
    {
        WorldPackets::Channel::ChannelNotify notify;
        MakePlayerNotFound(notify, newname);
        player->SendDirectMessage(notify.Write());
        return;
    }

    _playersStore[victim].SetModerator(true);
    SetOwner(victim);
}

Here is the call graph for this function:

void Channel::SetOwnership ( bool  ownership )

inline

{ _ownership = ownership; }

Here is the caller graph for this function:

void Channel::SetPassword ( std::string const &  npassword )

inline

{ _password = npassword; }

void Channel::SilenceAll	(	Player const *	player,
		std::string const &	name
	)

{
}

void Channel::SilenceVoice	(	Player const *	player,
		std::string const &	name
	)

{
}

void Channel::UnBan	(	Player const *	player,
		std::string const &	badname
	)

{
    ObjectGuid const& good = player->GetGUID();

    if (!IsOn(good))
    {
        WorldPackets::Channel::ChannelNotify notify;
        MakeNotMember(notify);
        player->SendDirectMessage(notify.Write());
        return;
    }

    if (!_playersStore[good].IsModerator() && !player->GetSession()->HasPermission(rbac::RBAC_PERM_CHANGE_CHANNEL_NOT_MODERATOR))
    {
        WorldPackets::Channel::ChannelNotify notify;
        MakeNotModerator(notify);
        player->SendDirectMessage(notify.Write());
        return;
    }

    Player* bad = ObjectAccessor::FindConnectedPlayerByName(badname);
    ObjectGuid victim = bad ? bad->GetGUID() : ObjectGuid::Empty;

    if (victim.IsEmpty() || !IsBanned(victim))
    {
        WorldPackets::Channel::ChannelNotify notify;
        MakePlayerNotFound(notify, badname);
        player->SendDirectMessage(notify.Write());
        return;
    }

    _bannedStore.erase(victim);

    WorldPackets::Channel::ChannelNotify notify;
    MakePlayerUnbanned(notify, victim, good);
    SendToAll(notify.Write());

    UpdateChannelInDB();
}

Here is the call graph for this function:

void Channel::UnsetModerator ( Player const *  player, std::string const &  newname  )

inline

{ SetMode(player, newname, true, false); }

void Channel::UnsetMute ( Player const *  player, std::string const &  newname  )

inline

{ SetMode(player, newname, false, false); }

void Channel::UnsilenceAll	(	Player const *	player,
		std::string const &	name
	)

{
}

void Channel::UnsilenceVoice	(	Player const *	player,
		std::string const &	name
	)

{
}

void Channel::UpdateChannelInDB ( ) const

private

{
    if (_IsSaved)
    {
        std::ostringstream banlist;
        for (ObjectGuid const& guid : _bannedStore)
            banlist << guid << ' ';

        PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_CHANNEL);
        stmt->setBool(0, _announce);
        stmt->setBool(1, _ownership);
        stmt->setString(2, _password);
        stmt->setString(3, banlist.str());
        stmt->setString(4, _name);
        stmt->setUInt32(5, _team);
        CharacterDatabase.Execute(stmt);

        TC_LOG_DEBUG("chat.system", "Channel (%s) updated in database", _name.c_str());
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Channel::UpdateChannelUseageInDB ( ) const

private

{
    PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_CHANNEL_USAGE);
    stmt->setString(0, _name);
    stmt->setUInt32(1, _team);
    CharacterDatabase.Execute(stmt);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Channel::Voice

(

Player const *

player

)

{
}

Member Data Documentation

bool Channel::_announce

private

BannedContainer Channel::_bannedStore

private

uint32 Channel::_channelId

private

uint8 Channel::_flags

private

bool Channel::_IsSaved

private

std::string Channel::_name

private

ObjectGuid Channel::_ownerGUID

private

bool Channel::_ownership

private

std::string Channel::_password

private

PlayerContainer Channel::_playersStore

private

uint32 Channel::_team

private

---

The documentation for this class was generated from the following files:

• src/server/game/Chat/Channels/Channel.h
• src/server/game/Chat/Channels/Channel.cpp