#include "Channel.h"

Classes
struct	PlayerInfo

Public Member Functions
	Channel (std::string const &name, uint32 channel_id, uint32 channelDBId, TeamId teamId=TEAM_NEUTRAL, bool announce=true, bool ownership=true)

std::string const &	GetName () const

uint32	GetChannelId () const

uint32	GetChannelDBId () const

bool	IsConstant () const

bool	IsAnnounce () const

bool	IsLFG () const

std::string const &	GetPassword () const

void	SetPassword (std::string const &npassword)

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	AddBan (ObjectGuid guid, uint32 time)

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

void	UnBan (ObjectGuid guid)

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 guid, bool exclaim=true)

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

void	SendWhoOwner (ObjectGuid guid)

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	List (Player const *player)

void	Announce (Player const *player)

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

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

void	Voice (ObjectGuid guid1, ObjectGuid guid2)

void	DeVoice (ObjectGuid guid1, ObjectGuid guid2)

void	JoinNotify (Player *p)

void	LeaveNotify (Player *p)

void	FlagsNotify (Player *p)

void	ToggleModeration (Player *p)

void	AddWatching (Player *p)

void	RemoveWatching (Player *p)

Static Public Member Functions
static void	CleanOldChannelsInDB ()

Private Types
typedef std::unordered_map< ObjectGuid, PlayerInfo >	PlayerContainer

typedef std::unordered_map< ObjectGuid, uint32 >	BannedContainer

typedef std::unordered_set< Player * >	PlayersWatchingContainer

Private Member Functions
void	MakeNotifyPacket (WorldPacket *data, uint8 notify_type)

void	MakeJoined (WorldPacket *data, ObjectGuid guid)

void	MakeLeft (WorldPacket *data, ObjectGuid guid)

void	MakeYouJoined (WorldPacket *data)

void	MakeYouLeft (WorldPacket *data)

void	MakeWrongPassword (WorldPacket *data)

void	MakeNotMember (WorldPacket *data)

void	MakeNotModerator (WorldPacket *data)

void	MakePasswordChanged (WorldPacket *data, ObjectGuid guid)

void	MakeOwnerChanged (WorldPacket *data, ObjectGuid guid)

void	MakePlayerNotFound (WorldPacket *data, std::string const &name)

void	MakeNotOwner (WorldPacket *data)

void	MakeChannelOwner (WorldPacket *data)

void	MakeModeChange (WorldPacket *data, ObjectGuid guid, uint8 oldflags)

void	MakeAnnouncementsOn (WorldPacket *data, ObjectGuid guid)

void	MakeAnnouncementsOff (WorldPacket *data, ObjectGuid guid)

void	MakeMuted (WorldPacket *data)

void	MakePlayerKicked (WorldPacket *data, ObjectGuid bad, ObjectGuid good)

void	MakeBanned (WorldPacket *data)

void	MakePlayerBanned (WorldPacket *data, ObjectGuid bad, ObjectGuid good)

void	MakePlayerUnbanned (WorldPacket *data, ObjectGuid bad, ObjectGuid good)

void	MakePlayerNotBanned (WorldPacket *data, std::string const &name)

void	MakePlayerAlreadyMember (WorldPacket *data, ObjectGuid guid)

void	MakeInvite (WorldPacket *data, ObjectGuid guid)

void	MakeInviteWrongFaction (WorldPacket *data)

void	MakeWrongFaction (WorldPacket *data)

void	MakeInvalidName (WorldPacket *data)

void	MakeNotModerated (WorldPacket *data)

void	MakePlayerInvited (WorldPacket *data, std::string const &name)

void	MakePlayerInviteBanned (WorldPacket *data, std::string const &name)

void	MakeThrottled (WorldPacket *data)

void	MakeNotInArea (WorldPacket *data)

void	MakeNotInLfg (WorldPacket *data)

void	MakeVoiceOn (WorldPacket *data, ObjectGuid guid)

void	MakeVoiceOff (WorldPacket *data, ObjectGuid guid)

void	MakeModerationOn (WorldPacket *data, ObjectGuid guid)

void	MakeModerationOff (WorldPacket *data, ObjectGuid guid)

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

void	SendToAllButOne (WorldPacket *data, ObjectGuid who)

void	SendToOne (WorldPacket *data, ObjectGuid who)

void	SendToAllWatching (WorldPacket *data)

bool	ShouldAnnouncePlayer (Player const *player) const

bool	IsOn (ObjectGuid who) const

bool	IsBanned (ObjectGuid guid) const

void	UpdateChannelInDB () const

void	UpdateChannelUseageInDB () const

void	AddChannelBanToDB (ObjectGuid guid, uint32 time) const

void	RemoveChannelBanFromDB (ObjectGuid guid) const

uint8	GetPlayerFlags (ObjectGuid guid) const

void	SetModerator (ObjectGuid guid, bool set)

void	SetMute (ObjectGuid guid, bool set)

Private Attributes
bool	_announce

bool	_moderation

bool	_ownership

bool	_IsSaved

bool	_isOwnerGM

uint8	_flags

uint32	_channelId

uint32	_channelDBId

TeamId	_teamId

ObjectGuid	_ownerGUID

std::string	_name

std::string	_password

ChannelRights	_channelRights

PlayerContainer	playersStore

BannedContainer	bannedStore

PlayersWatchingContainer	playersWatchingStore

Detailed Description

Member Typedef Documentation

◆ BannedContainer

typedef std::unordered_map<ObjectGuid, uint32> Channel::BannedContainer

private

◆ PlayerContainer

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

private

◆ PlayersWatchingContainer

typedef std::unordered_set<Player*> Channel::PlayersWatchingContainer

private

Constructor & Destructor Documentation

◆ Channel()

Channel::Channel	(	std::string const &	name,
		uint32	channel_id,
		uint32	channelDBId,
		TeamId	teamId = `TEAM_NEUTRAL`,
		bool	announce = `true`,
		bool	ownership = `true`
	)

                                                                                                                         :
    _announce(announce),
    _ownership(ownership),
    _IsSaved(false),
    _isOwnerGM(false),
    _flags(0),
    _channelId(channelId),
    _channelDBId(channelDBId),
    _teamId(teamId),
    _name(name),
    _password("")
{
    // 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;
 
        // pussywizard:
        _channelRights = ChannelMgr::GetChannelRightsFor(_name);
        if (_channelRights.flags & CHANNEL_RIGHT_FORCE_NO_ANNOUNCEMENTS)
            _announce = false;
        if (_channelRights.flags & CHANNEL_RIGHT_FORCE_ANNOUNCEMENTS)
            _announce = true;
        if (_channelRights.flags & CHANNEL_RIGHT_NO_OWNERSHIP)
            _ownership = false;
        if (_channelRights.flags & CHANNEL_RIGHT_DONT_PRESERVE)
            return;
 
        _IsSaved = true;
 
        // Xinef: loading
        if (channelDBId > 0)
            return;
 
        // If storing custom channels in the db is enabled either load or save the channel
        if (sWorld->getBoolConfig(CONFIG_PRESERVE_CUSTOM_CHANNELS))
        {
            _channelDBId = ++ChannelMgr::_channelIdMax;
 
            CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_CHANNEL);
            stmt->SetData(0, _channelDBId);
            stmt->SetData(1, name);
            stmt->SetData(2, _teamId);
            stmt->SetData(3, _announce);
            CharacterDatabase.Execute(stmt);
        }
    }
}

References _announce, _channelDBId, ChannelMgr::_channelIdMax, _channelRights, _flags, _IsSaved, _name, _ownership, _teamId, CHANNEL_DBC_FLAG_CITY_ONLY2, CHANNEL_DBC_FLAG_LFG, CHANNEL_DBC_FLAG_TRADE, CHANNEL_FLAG_CITY, CHANNEL_FLAG_CUSTOM, CHANNEL_FLAG_GENERAL, CHANNEL_FLAG_LFG, CHANNEL_FLAG_NOT_LFG, CHANNEL_FLAG_TRADE, CHANNEL_RIGHT_DONT_PRESERVE, CHANNEL_RIGHT_FORCE_ANNOUNCEMENTS, CHANNEL_RIGHT_FORCE_NO_ANNOUNCEMENTS, CHANNEL_RIGHT_NO_OWNERSHIP, CHAR_INS_CHANNEL, CharacterDatabase, CONFIG_PRESERVE_CUSTOM_CHANNELS, ChannelRights::flags, ChannelMgr::GetChannelRightsFor(), sChatChannelsStore, PreparedStatementBase::SetData(), and sWorld.

Member Function Documentation

◆ AddBan()

void Channel::AddBan	(	ObjectGuid	guid,
		uint32	time
	)

inline

196{ bannedStore[guid] = time; }

Channel::bannedStore

BannedContainer bannedStore

Definition Channel.h:334

References bannedStore.

Referenced by ChannelMgr::LoadChannels().

◆ AddChannelBanToDB()

void Channel::AddChannelBanToDB	(	ObjectGuid	guid,
		uint32	time
	)		const

private

{
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_CHANNEL_BAN);
    stmt->SetData(0, _channelDBId);
    stmt->SetData(1, guid.GetCounter());
    stmt->SetData(2, time);
    CharacterDatabase.Execute(stmt);
}

References _channelDBId, CHAR_INS_CHANNEL_BAN, CharacterDatabase, ObjectGuid::GetCounter(), and PreparedStatementBase::SetData().

Referenced by KickOrBan().

◆ AddWatching()

void Channel::AddWatching ( Player * p )

{
    if (!IsOn(p->GetGUID()))
        return;
    playersWatchingStore.insert(p);
}

References Object::GetGUID(), IsOn(), and playersWatchingStore.

◆ Announce()

void Channel::Announce ( Player const * player )

{
    ObjectGuid guid = player->GetGUID();
 
    if (!IsOn(guid))
    {
        WorldPacket data;
        MakeNotMember(&data);
        SendToOne(&data, guid);
        return;
    }
 
    if (!playersStore[guid].IsModerator() && !player->GetSession()->HasPermission(rbac::RBAC_PERM_CHANGE_CHANNEL_NOT_MODERATOR))
    {
        WorldPacket data;
        MakeNotModerator(&data);
        SendToOne(&data, guid);
        return;
    }
 
    if (_channelRights.flags & (CHANNEL_RIGHT_FORCE_NO_ANNOUNCEMENTS | CHANNEL_RIGHT_FORCE_ANNOUNCEMENTS))
    {
        WorldPacket data;
        MakeNotModerator(&data);
        SendToOne(&data, guid);
        return;
    }
 
    _announce = !_announce;
 
    WorldPacket data;
    if (_announce)
        MakeAnnouncementsOn(&data, guid);
    else
        MakeAnnouncementsOff(&data, guid);
    SendToAll(&data);
 
    UpdateChannelInDB();
}

References _announce, _channelRights, CHANNEL_RIGHT_FORCE_ANNOUNCEMENTS, CHANNEL_RIGHT_FORCE_NO_ANNOUNCEMENTS, ChannelRights::flags, Object::GetGUID(), Player::GetSession(), WorldSession::HasPermission(), IsOn(), MakeAnnouncementsOff(), MakeAnnouncementsOn(), MakeNotMember(), MakeNotModerator(), playersStore, rbac::RBAC_PERM_CHANGE_CHANNEL_NOT_MODERATOR, SendToAll(), SendToOne(), and UpdateChannelInDB().

◆ Ban()

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

inline

195{ KickOrBan(player, badname, true); }

Channel::KickOrBan

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

Definition Channel.cpp:316

References KickOrBan().

◆ CleanOldChannelsInDB()

void Channel::CleanOldChannelsInDB ( )

static

{
    if (sWorld->getIntConfig(CONFIG_PRESERVE_CUSTOM_CHANNEL_DURATION) > 0)
    {
        CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
 
        CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_OLD_CHANNELS);
        stmt->SetData(0, sWorld->getIntConfig(CONFIG_PRESERVE_CUSTOM_CHANNEL_DURATION) * DAY);
        trans->Append(stmt);
 
        stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_OLD_CHANNELS_BANS);
        trans->Append(stmt);
 
        CharacterDatabase.CommitTransaction(trans);
    }
}

References CHAR_DEL_OLD_CHANNELS, CHAR_DEL_OLD_CHANNELS_BANS, CharacterDatabase, CONFIG_PRESERVE_CUSTOM_CHANNEL_DURATION, DAY, PreparedStatementBase::SetData(), and sWorld.

Referenced by World::SetInitialWorldSettings().

◆ DeVoice()

void Channel::DeVoice	(	ObjectGuid	guid1,
		ObjectGuid	guid2
	)

949{

950}

◆ FlagsNotify()

void Channel::FlagsNotify ( Player * p )

{
    if (_channelRights.flags & CHANNEL_RIGHT_CANT_SPEAK)
        return;
    if (p->GetSession()->HasPermission(rbac::RBAC_PERM_SILENTLY_JOIN_CHANNEL))
        return;
 
    WorldPacket data(SMSG_USERLIST_UPDATE, 8 + 1 + 1 + 4 + GetName().size());
    data << p->GetGUID();
    data << uint8(GetPlayerFlags(p->GetGUID()));
    data << uint8(GetFlags());
    data << uint32(GetNumPlayers());
    data << GetName();
 
    SendToAllWatching(&data);
}

References _channelRights, CHANNEL_RIGHT_CANT_SPEAK, ChannelRights::flags, GetFlags(), Object::GetGUID(), GetName(), GetNumPlayers(), GetPlayerFlags(), Player::GetSession(), WorldSession::HasPermission(), rbac::RBAC_PERM_SILENTLY_JOIN_CHANNEL, SendToAllWatching(), and SMSG_USERLIST_UPDATE.

Referenced by JoinChannel(), SetModerator(), and SetOwner().

◆ GetChannelDBId()

uint32 Channel::GetChannelDBId ( ) const

inline

181{ return _channelDBId; }

References _channelDBId.

◆ GetChannelId()

uint32 Channel::GetChannelId ( ) const

inline

180{ return _channelId; }

References _channelId.

Referenced by MakeYouJoined(), and MakeYouLeft().

◆ GetFlags()

uint8 Channel::GetFlags ( ) const

inline

188{ return _flags; }

References _flags.

Referenced by FlagsNotify(), JoinNotify(), LeaveNotify(), List(), and MakeYouJoined().

◆ GetName()

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

inline

179{ return _name; }

References _name.

Referenced by FlagsNotify(), JoinNotify(), LeaveNotify(), List(), ChatLogScript::OnPlayerCanUseChat(), UnBan(), and Player::UpdateLocalChannels().

◆ GetNumPlayers()

uint32 Channel::GetNumPlayers ( ) const

inline

187{ return playersStore.size(); }

References playersStore.

Referenced by FlagsNotify(), JoinNotify(), and LeaveNotify().

◆ GetPassword()

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

inline

185{ return _password; }

References _password.

◆ GetPlayerFlags()

uint8 Channel::GetPlayerFlags ( ObjectGuid guid ) const

inlineprivate

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

References playersStore.

Referenced by FlagsNotify(), JoinNotify(), and MakeModeChange().

◆ HasFlag()

bool Channel::HasFlag ( uint8 flag ) const

inline

189{ return _flags & flag; }

References _flags.

Referenced by IsLFG(), and ChatLogScript::OnPlayerCanUseChat().

◆ Invite()

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

{
    ObjectGuid guid = player->GetGUID();
 
    if (!IsOn(guid))
    {
        WorldPacket data;
        MakeNotMember(&data);
        SendToOne(&data, guid);
        return;
    }
 
    Player* newp = ObjectAccessor::FindPlayerByName(newname, false);
    if (!newp || !newp->isGMVisible())
    {
        WorldPacket data;
        MakePlayerNotFound(&data, newname);
        SendToOne(&data, guid);
        return;
    }
 
    if (IsBanned(newp->GetGUID()))
    {
        WorldPacket data;
        MakePlayerInviteBanned(&data, newname);
        SendToOne(&data, guid);
        return;
    }
 
    if (newp->GetTeamId() != player->GetTeamId())
    {
        WorldPacket data;
        MakeInviteWrongFaction(&data);
        SendToOne(&data, guid);
        return;
    }
 
    if (IsOn(newp->GetGUID()))
    {
        WorldPacket data;
        MakePlayerAlreadyMember(&data, newp->GetGUID());
        SendToOne(&data, guid);
        return;
    }
 
    if (!newp->GetSocial()->HasIgnore(guid))
    {
        WorldPacket data;
        MakeInvite(&data, guid);
        SendToOne(&data, newp->GetGUID());
        data.clear();
    }
 
    WorldPacket data;
    MakePlayerInvited(&data, newp->GetName());
    SendToOne(&data, guid);
}

References ByteBuffer::clear(), ObjectAccessor::FindPlayerByName(), Object::GetGUID(), WorldObject::GetName(), Player::GetSocial(), Player::GetTeamId(), PlayerSocial::HasIgnore(), IsBanned(), Player::isGMVisible(), IsOn(), MakeInvite(), MakeInviteWrongFaction(), MakeNotMember(), MakePlayerAlreadyMember(), MakePlayerInviteBanned(), MakePlayerInvited(), MakePlayerNotFound(), and SendToOne().

◆ IsAnnounce()

bool Channel::IsAnnounce ( ) const

inline

183{ return _announce; }

References _announce.

◆ IsBanned()

bool Channel::IsBanned ( ObjectGuid guid ) const

private

{
    BannedContainer::const_iterator itr = bannedStore.find(guid);
    return itr != bannedStore.end() && itr->second > GameTime::GetGameTime().count();
}

References bannedStore, and GameTime::GetGameTime().

Referenced by Invite(), JoinChannel(), KickOrBan(), UnBan(), and UnBan().

◆ IsConstant()

bool Channel::IsConstant ( ) const

inline

182{ return _channelId != 0; }

References _channelId.

Referenced by JoinChannel(), LeaveChannel(), MakeChannelOwner(), and MakeYouLeft().

◆ IsLFG()

bool Channel::IsLFG ( ) const

inline

184{ return HasFlag(CHANNEL_FLAG_LFG); }

Channel::HasFlag

bool HasFlag(uint8 flag) const

Definition Channel.h:189

References CHANNEL_FLAG_LFG, and HasFlag().

Referenced by JoinChannel().

◆ IsOn()

bool Channel::IsOn ( ObjectGuid who ) const

inlineprivate

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

References playersStore.

Referenced by AddWatching(), Announce(), Invite(), JoinChannel(), KickOrBan(), LeaveChannel(), List(), Password(), Say(), SendWhoOwner(), SetMode(), SetOwner(), ToggleModeration(), and UnBan().

◆ JoinChannel()

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

{
    ObjectGuid guid = player->GetGUID();
    if (IsOn(guid))
    {
        // Do not send error message for built-in channels
        if (!IsConstant())
        {
            WorldPacket data;
            MakePlayerAlreadyMember(&data, guid);
            SendToOne(&data, guid);
        }
        return;
    }
 
    if (IsBanned(guid))
    {
        WorldPacket data;
        MakeBanned(&data);
        SendToOne(&data, guid);
        return;
    }
 
    if (!_password.empty() && pass != _password)
    {
        WorldPacket data;
        MakeWrongPassword(&data);
        SendToOne(&data, guid);
        return;
    }
 
    if (IsLFG() && sWorld->getBoolConfig(CONFIG_RESTRICTED_LFG_CHANNEL) && !player->IsUsingLfg())
    {
        WorldPacket data;
        MakeNotInLfg(&data);
        SendToOne(&data, guid);
        return;
    }
 
    player->JoinedChannel(this);
 
    if (_announce && ShouldAnnouncePlayer(player))
    {
        WorldPacket data;
        MakeJoined(&data, guid);
        SendToAll(&data);
    }
 
    PlayerInfo pinfo;
    pinfo.player = guid;
    pinfo.flags = MEMBER_FLAG_NONE;
    pinfo.plrPtr = player;
 
    playersStore[guid] = pinfo;
 
    if (_channelRights.joinMessage.length())
        ChatHandler(player->GetSession()).PSendSysMessage("{}", _channelRights.joinMessage);
 
    WorldPacket data;
    MakeYouJoined(&data);
    SendToOne(&data, guid);
 
    JoinNotify(player);
 
    playersStore[guid].SetOwnerGM(player->GetSession()->HasPermission(rbac::RBAC_PERM_CHANGE_CHANNEL_NOT_MODERATOR));
 
    // Custom channel handling
    if (!IsConstant())
    {
        // Update last_used timestamp in db
        if (!playersStore.empty())
            UpdateChannelUseageInDB();
 
        if (_channelRights.moderators.find(player->GetSession()->GetAccountId()) != _channelRights.moderators.end())
        {
            playersStore[guid].SetModerator(true);
            FlagsNotify(player);
        }
 
        // If the channel has no owner yet and ownership is allowed, set the new owner.
        // If the channel owner is a GM and the config SilentGMJoinChannel is enabled, set the new owner
        if ((!_ownerGUID || (_isOwnerGM && sWorld->getBoolConfig(CONFIG_SILENTLY_GM_JOIN_TO_CHANNEL))) && _ownership)
        {
            _isOwnerGM = playersStore[guid].IsOwnerGM();
            SetOwner(guid, false);
        }
 
        if (_channelRights.flags & CHANNEL_RIGHT_CANT_SPEAK)
            playersStore[guid].SetMuted(true);
    }
}

References _announce, _channelRights, _isOwnerGM, _ownerGUID, _ownership, _password, CHANNEL_RIGHT_CANT_SPEAK, CONFIG_RESTRICTED_LFG_CHANNEL, CONFIG_SILENTLY_GM_JOIN_TO_CHANNEL, ChannelRights::flags, Channel::PlayerInfo::flags, FlagsNotify(), WorldSession::GetAccountId(), Object::GetGUID(), Player::GetSession(), WorldSession::HasPermission(), IsBanned(), IsConstant(), IsLFG(), IsOn(), Player::IsUsingLfg(), Player::JoinedChannel(), ChannelRights::joinMessage, JoinNotify(), MakeBanned(), MakeJoined(), MakeNotInLfg(), MakePlayerAlreadyMember(), MakeWrongPassword(), MakeYouJoined(), MEMBER_FLAG_NONE, ChannelRights::moderators, Channel::PlayerInfo::player, playersStore, Channel::PlayerInfo::plrPtr, ChatHandler::PSendSysMessage(), rbac::RBAC_PERM_CHANGE_CHANNEL_NOT_MODERATOR, SendToAll(), SendToOne(), SetOwner(), ShouldAnnouncePlayer(), sWorld, and UpdateChannelUseageInDB().

Referenced by Player::UpdateLFGChannel(), and Player::UpdateLocalChannels().

◆ JoinNotify()

void Channel::JoinNotify ( Player * p )

{
    if (_channelRights.flags & CHANNEL_RIGHT_CANT_SPEAK)
        return;
    if (p->GetSession()->HasPermission(rbac::RBAC_PERM_SILENTLY_JOIN_CHANNEL))
        return;
 
    WorldPacket data(SMSG_USERLIST_ADD, 8 + 1 + 1 + 4 + GetName().size());
    data << p->GetGUID();
    data << uint8(GetPlayerFlags(p->GetGUID()));
    data << uint8(GetFlags());
    data << uint32(GetNumPlayers());
    data << GetName();
 
    SendToAllWatching(&data);
}

References _channelRights, CHANNEL_RIGHT_CANT_SPEAK, ChannelRights::flags, GetFlags(), Object::GetGUID(), GetName(), GetNumPlayers(), GetPlayerFlags(), Player::GetSession(), WorldSession::HasPermission(), rbac::RBAC_PERM_SILENTLY_JOIN_CHANNEL, SendToAllWatching(), and SMSG_USERLIST_ADD.

Referenced by JoinChannel().

◆ Kick()

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

inline

194{ KickOrBan(player, badname, false); }

References KickOrBan().

◆ KickOrBan()

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

{
    ObjectGuid good = player->GetGUID();
 
    if (!IsOn(good))
    {
        WorldPacket data;
        MakeNotMember(&data);
        SendToOne(&data, good);
        return;
    }
 
    if (!playersStore[good].IsModerator() && !player->GetSession()->HasPermission(rbac::RBAC_PERM_CHANGE_CHANNEL_NOT_MODERATOR))
    {
        WorldPacket data;
        MakeNotModerator(&data);
        SendToOne(&data, good);
        return;
    }
 
    bool banOffline = false; // pussywizard
    bool isGoodConstantModerator = _channelRights.moderators.find(player->GetSession()->GetAccountId()) != _channelRights.moderators.end();
 
    ObjectGuid victim;
    uint32 badAccId = 0;
    Player* bad = ObjectAccessor::FindPlayerByName(badname, false);
    if (bad)
    {
        victim = bad->GetGUID();
        badAccId = bad->GetSession()->GetAccountId();
    }
 
    bool isOnChannel = victim && IsOn(victim);
    if (!isOnChannel)
    {
        if (ban && (player->GetSession()->HasPermission(rbac::RBAC_PERM_CHANGE_CHANNEL_NOT_MODERATOR) || isGoodConstantModerator))
        {
            if (ObjectGuid guid = sCharacterCache->GetCharacterGuidByName(badname))
            {
                if (CharacterCacheEntry const* gpd = sCharacterCache->GetCharacterCacheByGuid(guid))
                {
                    if (Player::TeamIdForRace(gpd->Race) == Player::TeamIdForRace(player->getRace()))
                    {
                        banOffline = true;
                        victim     = guid;
                        badAccId   = gpd->AccountId;
                    }
                    else
                    {
                        ChatHandler(player->GetSession()).PSendSysMessage("Character {} has other faction!", badname);
                        return;
                    }
                }
            }
 
            if (!banOffline)
            {
                WorldPacket data;
                MakePlayerNotFound(&data, badname);
                SendToOne(&data, good);
                return;
            }
        }
        else
        {
            WorldPacket data;
            MakePlayerNotFound(&data, badname);
            SendToOne(&data, good);
            return;
        }
    }
 
    bool changeowner = _ownerGUID == victim;
    bool isBadConstantModerator = _channelRights.moderators.find(badAccId) != _channelRights.moderators.end();
 
    if (!player->GetSession()->HasPermission(rbac::RBAC_PERM_CHANGE_CHANNEL_NOT_MODERATOR) && !isGoodConstantModerator)
    {
        if (changeowner && good != _ownerGUID)
        {
            WorldPacket data;
            MakeNotOwner(&data);
            SendToOne(&data, good);
            return;
        }
 
        if ((ban && (_channelRights.flags & CHANNEL_RIGHT_CANT_BAN)) || (!ban && (_channelRights.flags & CHANNEL_RIGHT_CANT_KICK)))
        {
            WorldPacket data;
            MakeNotModerator(&data);
            SendToOne(&data, good);
            return;
        }
 
        if (isBadConstantModerator || bad->GetSession()->HasPermission(rbac::RBAC_PERM_CHANGE_CHANNEL_NOT_MODERATOR))
        {
            WorldPacket data;
            MakeNotModerator(&data);
            SendToOne(&data, good);
            return;
        }
    }
 
    if (ban)
    {
        if (!IsBanned(victim))
        {
            bannedStore[victim] = GameTime::GetGameTime().count() + CHANNEL_BAN_DURATION;
            AddChannelBanToDB(victim, GameTime::GetGameTime().count() + CHANNEL_BAN_DURATION);
 
            if (ShouldAnnouncePlayer(player))
            {
                WorldPacket data;
                MakePlayerBanned(&data, victim, good);
                SendToAll(&data);
            }
        }
    }
    else if (ShouldAnnouncePlayer(player))
    {
        WorldPacket data;
        MakePlayerKicked(&data, victim, good);
        SendToAll(&data);
    }
 
    if (isOnChannel)
    {
        playersStore.erase(victim);
        bad->LeftChannel(this);
        RemoveWatching(bad);
        LeaveNotify(bad);
    }
 
    if (changeowner && _ownership)
    {
        if (good != victim)
            SetOwner(good);
        else if (!playersStore.empty())
        {
            ObjectGuid newowner;
            for (Channel::PlayerContainer::const_iterator itr = playersStore.begin(); itr != playersStore.end(); ++itr)
            {
                newowner = itr->second.player;
                if (!itr->second.plrPtr->GetSession()->HasPermission(rbac::RBAC_PERM_CHANGE_CHANNEL_NOT_MODERATOR))
                    break;
            }
            SetOwner(newowner);
        }
        else
            SetOwner(ObjectGuid::Empty);
    }
}

References _channelRights, _ownerGUID, _ownership, AddChannelBanToDB(), bannedStore, CHANNEL_BAN_DURATION, CHANNEL_RIGHT_CANT_BAN, CHANNEL_RIGHT_CANT_KICK, ObjectGuid::Empty, ObjectAccessor::FindPlayerByName(), ChannelRights::flags, WorldSession::GetAccountId(), GameTime::GetGameTime(), Object::GetGUID(), Unit::getRace(), Player::GetSession(), WorldSession::HasPermission(), IsBanned(), IsOn(), LeaveNotify(), Player::LeftChannel(), MakeNotMember(), MakeNotModerator(), MakeNotOwner(), MakePlayerBanned(), MakePlayerKicked(), MakePlayerNotFound(), ChannelRights::moderators, playersStore, ChatHandler::PSendSysMessage(), rbac::RBAC_PERM_CHANGE_CHANNEL_NOT_MODERATOR, RemoveWatching(), sCharacterCache, SendToAll(), SendToOne(), SetOwner(), ShouldAnnouncePlayer(), and Player::TeamIdForRace().

Referenced by Ban(), and Kick().

◆ LeaveChannel()

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

{
    ObjectGuid guid = player->GetGUID();
    if (!IsOn(guid))
    {
        if (send)
        {
            WorldPacket data;
            MakeNotMember(&data);
            SendToOne(&data, guid);
        }
        return;
    }
 
    if (send)
    {
        WorldPacket data;
        MakeYouLeft(&data);
        SendToOne(&data, guid);
        player->LeftChannel(this);
        data.clear();
    }
 
    bool changeowner = playersStore[guid].IsOwner();
 
    playersStore.erase(guid);
    if (_announce && ShouldAnnouncePlayer(player))
    {
        WorldPacket data;
        MakeLeft(&data, guid);
        SendToAll(&data);
    }
 
    RemoveWatching(player);
    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)
        {
            if (!playersStore.empty())
            {
                ObjectGuid newowner;
                for (Channel::PlayerContainer::const_iterator itr = playersStore.begin(); itr != playersStore.end(); ++itr)
                {
                    newowner = itr->second.player;
                    if (itr->second.plrPtr->GetSession()->HasPermission(rbac::RBAC_PERM_CHANGE_CHANNEL_NOT_MODERATOR))
                        _isOwnerGM = true;
                    else
                        _isOwnerGM = false;
                    if (!itr->second.plrPtr->GetSession()->HasPermission(rbac::RBAC_PERM_CHANGE_CHANNEL_NOT_MODERATOR))
                        break;
                }
                SetOwner(newowner);
                // if the new owner is invisible gm, set flag to automatically choose a new owner
            }
            else
                SetOwner(ObjectGuid::Empty);
        }
    }
}

References _announce, _isOwnerGM, _ownership, ByteBuffer::clear(), ObjectGuid::Empty, Object::GetGUID(), IsConstant(), IsOn(), LeaveNotify(), Player::LeftChannel(), MakeLeft(), MakeNotMember(), MakeYouLeft(), playersStore, rbac::RBAC_PERM_CHANGE_CHANNEL_NOT_MODERATOR, RemoveWatching(), SendToAll(), SendToOne(), SetOwner(), ShouldAnnouncePlayer(), and UpdateChannelUseageInDB().

Referenced by Player::CleanupChannels(), Player::UpdateLFGChannel(), and Player::UpdateLocalChannels().

◆ LeaveNotify()

void Channel::LeaveNotify ( Player * p )

{
    if (_channelRights.flags & CHANNEL_RIGHT_CANT_SPEAK)
        return;
    if (p->GetSession()->HasPermission(rbac::RBAC_PERM_SILENTLY_JOIN_CHANNEL))
        return;
 
    WorldPacket data(SMSG_USERLIST_REMOVE, 8 + 1 + 4 + GetName().size());
    data << p->GetGUID();
    data << uint8(GetFlags());
    data << uint32(GetNumPlayers());
    data << GetName();
 
    SendToAllWatching(&data);
}

References _channelRights, CHANNEL_RIGHT_CANT_SPEAK, ChannelRights::flags, GetFlags(), Object::GetGUID(), GetName(), GetNumPlayers(), Player::GetSession(), WorldSession::HasPermission(), rbac::RBAC_PERM_SILENTLY_JOIN_CHANNEL, SendToAllWatching(), and SMSG_USERLIST_REMOVE.

Referenced by KickOrBan(), and LeaveChannel().

◆ List()

void Channel::List ( Player const * player )

{
    ObjectGuid guid = player->GetGUID();
 
    if (!IsOn(guid))
    {
        WorldPacket data;
        MakeNotMember(&data);
        SendToOne(&data, guid);
        return;
    }
 
    LOG_DEBUG("chat.system", "SMSG_CHANNEL_LIST {} Channel: {}", player->GetSession()->GetPlayerInfo(), GetName());
    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?
 
    std::size_t pos = data.wpos();
    data << uint32(0);                                  // size of list, placeholder
 
    uint32 gmLevelInWhoList = sWorld->getIntConfig(CONFIG_GM_LEVEL_IN_WHO_LIST);
 
    uint32 count  = 0;
    if (!(_channelRights.flags & CHANNEL_RIGHT_CANT_SPEAK))
        for (PlayerContainer::const_iterator i = playersStore.begin(); i != playersStore.end(); ++i)
            if (Player* member = i->second.plrPtr)
                if ((player->GetSession()->HasPermission(rbac::RBAC_PERM_WHO_SEE_ALL_SEC_LEVELS) ||
                     member->GetSession()->GetSecurity() <= AccountTypes(gmLevelInWhoList)) &&
                    member->IsVisibleGloballyFor(player))
                {
                    data << i->first;
                    data << uint8(i->second.flags); // flags seems to be changed...
                    ++count;
                }
 
    data.put<uint32>(pos, count);
 
    SendToOne(&data, guid);
}

References _channelRights, CHANNEL_RIGHT_CANT_SPEAK, CONFIG_GM_LEVEL_IN_WHO_LIST, ChannelRights::flags, GetFlags(), Object::GetGUID(), GetName(), WorldSession::GetPlayerInfo(), Player::GetSession(), WorldSession::HasPermission(), IsOn(), LOG_DEBUG, MakeNotMember(), playersStore, ByteBuffer::put(), rbac::RBAC_PERM_WHO_SEE_ALL_SEC_LEVELS, SendToOne(), SMSG_CHANNEL_LIST, sWorld, and ByteBuffer::wpos().

◆ MakeAnnouncementsOff()

void Channel::MakeAnnouncementsOff	(	WorldPacket *	data,
		ObjectGuid	guid
	)

private

{
    MakeNotifyPacket(data, CHAT_ANNOUNCEMENTS_OFF_NOTICE);
    *data << guid;
}

References CHAT_ANNOUNCEMENTS_OFF_NOTICE, and MakeNotifyPacket().

Referenced by Announce().

◆ MakeAnnouncementsOn()

void Channel::MakeAnnouncementsOn	(	WorldPacket *	data,
		ObjectGuid	guid
	)

private

{
    MakeNotifyPacket(data, CHAT_ANNOUNCEMENTS_ON_NOTICE);
    *data << guid;
}

References CHAT_ANNOUNCEMENTS_ON_NOTICE, and MakeNotifyPacket().

Referenced by Announce().

◆ MakeBanned()

void Channel::MakeBanned ( WorldPacket * data )

private

{
    MakeNotifyPacket(data, CHAT_BANNED_NOTICE);
}

References CHAT_BANNED_NOTICE, and MakeNotifyPacket().

Referenced by JoinChannel().

◆ MakeChannelOwner()

void Channel::MakeChannelOwner ( WorldPacket * data )

private

{
    std::string name = "";
 
    if (!sCharacterCache->GetCharacterNameByGuid(_ownerGUID, name) || name.empty())
        name = "PLAYER_NOT_FOUND";
 
    MakeNotifyPacket(data, CHAT_CHANNEL_OWNER_NOTICE);
    *data << ((IsConstant() || !_ownerGUID) ? "Nobody" : name);
}

References _ownerGUID, CHAT_CHANNEL_OWNER_NOTICE, IsConstant(), MakeNotifyPacket(), and sCharacterCache.

Referenced by SendWhoOwner().

◆ MakeInvalidName()

void Channel::MakeInvalidName ( WorldPacket * data )

private

{
    MakeNotifyPacket(data, CHAT_INVALID_NAME_NOTICE);
}

References CHAT_INVALID_NAME_NOTICE, and MakeNotifyPacket().

◆ MakeInvite()

void Channel::MakeInvite	(	WorldPacket *	data,
		ObjectGuid	guid
	)

private

{
    MakeNotifyPacket(data, CHAT_INVITE_NOTICE);
    *data << guid;
}

References CHAT_INVITE_NOTICE, and MakeNotifyPacket().

Referenced by Invite().

◆ MakeInviteWrongFaction()

void Channel::MakeInviteWrongFaction ( WorldPacket * data )

private

{
    MakeNotifyPacket(data, CHAT_INVITE_WRONG_FACTION_NOTICE);
}

References CHAT_INVITE_WRONG_FACTION_NOTICE, and MakeNotifyPacket().

Referenced by Invite().

◆ MakeJoined()

void Channel::MakeJoined	(	WorldPacket *	data,
		ObjectGuid	guid
	)

private

{
    MakeNotifyPacket(data, CHAT_JOINED_NOTICE);
    *data << guid;
}

References CHAT_JOINED_NOTICE, and MakeNotifyPacket().

Referenced by JoinChannel().

◆ MakeLeft()

void Channel::MakeLeft	(	WorldPacket *	data,
		ObjectGuid	guid
	)

private

{
    MakeNotifyPacket(data, CHAT_LEFT_NOTICE);
    *data << guid;
}

References CHAT_LEFT_NOTICE, and MakeNotifyPacket().

Referenced by LeaveChannel().

◆ MakeModeChange()

void Channel::MakeModeChange	(	WorldPacket *	data,
		ObjectGuid	guid,
		uint8	oldflags
	)

private

{
    MakeNotifyPacket(data, CHAT_MODE_CHANGE_NOTICE);
    *data << guid;
    *data << uint8(oldflags);
    *data << uint8(GetPlayerFlags(guid));
}

References CHAT_MODE_CHANGE_NOTICE, GetPlayerFlags(), and MakeNotifyPacket().

Referenced by SetModerator(), SetMute(), and SetOwner().

◆ MakeModerationOff()

void Channel::MakeModerationOff	(	WorldPacket *	data,
		ObjectGuid	guid
	)

private

{
    MakeNotifyPacket(data, CHAT_MODERATION_OFF_NOTICE);
    *data << guid;
}

References CHAT_MODERATION_OFF_NOTICE, and MakeNotifyPacket().

Referenced by ToggleModeration().

◆ MakeModerationOn()

void Channel::MakeModerationOn	(	WorldPacket *	data,
		ObjectGuid	guid
	)

private

{
    MakeNotifyPacket(data, CHAT_MODERATION_ON_NOTICE);
    *data << guid;
}

References CHAT_MODERATION_ON_NOTICE, and MakeNotifyPacket().

Referenced by ToggleModeration().

◆ MakeMuted()

void Channel::MakeMuted ( WorldPacket * data )

private

{
    MakeNotifyPacket(data, CHAT_MUTED_NOTICE);
}

References CHAT_MUTED_NOTICE, and MakeNotifyPacket().

Referenced by Say().

◆ MakeNotifyPacket()

void Channel::MakeNotifyPacket	(	WorldPacket *	data,
		uint8	notify_type
	)

private

{
    data->Initialize(SMSG_CHANNEL_NOTIFY, 1 + _name.size());
    *data << uint8(notify_type);
    *data << _name;
}

References _name, WorldPacket::Initialize(), and SMSG_CHANNEL_NOTIFY.

Referenced by MakeAnnouncementsOff(), MakeAnnouncementsOn(), MakeBanned(), MakeChannelOwner(), MakeInvalidName(), MakeInvite(), MakeInviteWrongFaction(), MakeJoined(), MakeLeft(), MakeModeChange(), MakeModerationOff(), MakeModerationOn(), MakeMuted(), MakeNotInArea(), MakeNotInLfg(), MakeNotMember(), MakeNotModerated(), MakeNotModerator(), MakeNotOwner(), MakeOwnerChanged(), MakePasswordChanged(), MakePlayerAlreadyMember(), MakePlayerBanned(), MakePlayerInviteBanned(), MakePlayerInvited(), MakePlayerKicked(), MakePlayerNotBanned(), MakePlayerNotFound(), MakePlayerUnbanned(), MakeThrottled(), MakeVoiceOff(), MakeVoiceOn(), MakeWrongFaction(), MakeWrongPassword(), MakeYouJoined(), and MakeYouLeft().

◆ MakeNotInArea()

void Channel::MakeNotInArea ( WorldPacket * data )

private

{
    MakeNotifyPacket(data, CHAT_NOT_IN_AREA_NOTICE);
}

References CHAT_NOT_IN_AREA_NOTICE, and MakeNotifyPacket().

◆ MakeNotInLfg()

void Channel::MakeNotInLfg ( WorldPacket * data )

private

{
    MakeNotifyPacket(data, CHAT_NOT_IN_LFG_NOTICE);
}

References CHAT_NOT_IN_LFG_NOTICE, and MakeNotifyPacket().

Referenced by JoinChannel().

◆ MakeNotMember()

void Channel::MakeNotMember ( WorldPacket * data )

private

{
    MakeNotifyPacket(data, CHAT_NOT_MEMBER_NOTICE);
}

References CHAT_NOT_MEMBER_NOTICE, and MakeNotifyPacket().

Referenced by Announce(), Invite(), KickOrBan(), LeaveChannel(), List(), Password(), Say(), SendWhoOwner(), SetMode(), SetOwner(), ToggleModeration(), and UnBan().

◆ MakeNotModerated()

void Channel::MakeNotModerated ( WorldPacket * data )

private

{
    MakeNotifyPacket(data, CHAT_NOT_MODERATED_NOTICE);
}

References CHAT_NOT_MODERATED_NOTICE, and MakeNotifyPacket().

◆ MakeNotModerator()

void Channel::MakeNotModerator ( WorldPacket * data )

private

{
    MakeNotifyPacket(data, CHAT_NOT_MODERATOR_NOTICE);
}

References CHAT_NOT_MODERATOR_NOTICE, and MakeNotifyPacket().

Referenced by Announce(), KickOrBan(), Password(), SetMode(), ToggleModeration(), and UnBan().

◆ MakeNotOwner()

void Channel::MakeNotOwner ( WorldPacket * data )

private

{
    MakeNotifyPacket(data, CHAT_NOT_OWNER_NOTICE);
}

References CHAT_NOT_OWNER_NOTICE, and MakeNotifyPacket().

Referenced by KickOrBan(), SetMode(), and SetOwner().

◆ MakeOwnerChanged()

void Channel::MakeOwnerChanged	(	WorldPacket *	data,
		ObjectGuid	guid
	)

private

{
    MakeNotifyPacket(data, CHAT_OWNER_CHANGED_NOTICE);
    *data << guid;
}

References CHAT_OWNER_CHANGED_NOTICE, and MakeNotifyPacket().

Referenced by SetOwner().

◆ MakePasswordChanged()

void Channel::MakePasswordChanged	(	WorldPacket *	data,
		ObjectGuid	guid
	)

private

{
    MakeNotifyPacket(data, CHAT_PASSWORD_CHANGED_NOTICE);
    *data << guid;
}

References CHAT_PASSWORD_CHANGED_NOTICE, and MakeNotifyPacket().

Referenced by Password().

◆ MakePlayerAlreadyMember()

void Channel::MakePlayerAlreadyMember	(	WorldPacket *	data,
		ObjectGuid	guid
	)

private

{
    MakeNotifyPacket(data, CHAT_PLAYER_ALREADY_MEMBER_NOTICE);
    *data << guid;
}

References CHAT_PLAYER_ALREADY_MEMBER_NOTICE, and MakeNotifyPacket().

Referenced by Invite(), and JoinChannel().

◆ MakePlayerBanned()

void Channel::MakePlayerBanned	(	WorldPacket *	data,
		ObjectGuid	bad,
		ObjectGuid	good
	)

private

{
    MakeNotifyPacket(data, CHAT_PLAYER_BANNED_NOTICE);
    *data << bad;
    *data << good;
}

References CHAT_PLAYER_BANNED_NOTICE, and MakeNotifyPacket().

Referenced by KickOrBan().

◆ MakePlayerInviteBanned()

void Channel::MakePlayerInviteBanned	(	WorldPacket *	data,
		std::string const &	name
	)

private

{
    MakeNotifyPacket(data, CHAT_PLAYER_INVITE_BANNED_NOTICE);
    *data << name;
}

References CHAT_PLAYER_INVITE_BANNED_NOTICE, and MakeNotifyPacket().

Referenced by Invite().

◆ MakePlayerInvited()

void Channel::MakePlayerInvited	(	WorldPacket *	data,
		std::string const &	name
	)

private

{
    MakeNotifyPacket(data, CHAT_PLAYER_INVITED_NOTICE);
    *data << name;
}

References CHAT_PLAYER_INVITED_NOTICE, and MakeNotifyPacket().

Referenced by Invite().

◆ MakePlayerKicked()

void Channel::MakePlayerKicked	(	WorldPacket *	data,
		ObjectGuid	bad,
		ObjectGuid	good
	)

private

{
    MakeNotifyPacket(data, CHAT_PLAYER_KICKED_NOTICE);
    *data << bad;
    *data << good;
}

References CHAT_PLAYER_KICKED_NOTICE, and MakeNotifyPacket().

Referenced by KickOrBan().

◆ MakePlayerNotBanned()

void Channel::MakePlayerNotBanned	(	WorldPacket *	data,
		std::string const &	name
	)

private

{
    MakeNotifyPacket(data, CHAT_PLAYER_NOT_BANNED_NOTICE);
    *data << name;
}

References CHAT_PLAYER_NOT_BANNED_NOTICE, and MakeNotifyPacket().

◆ MakePlayerNotFound()

void Channel::MakePlayerNotFound	(	WorldPacket *	data,
		std::string const &	name
	)

private

{
    MakeNotifyPacket(data, CHAT_PLAYER_NOT_FOUND_NOTICE);
    *data << name;
}

References CHAT_PLAYER_NOT_FOUND_NOTICE, and MakeNotifyPacket().

Referenced by Invite(), KickOrBan(), SetMode(), SetOwner(), and UnBan().

◆ MakePlayerUnbanned()

void Channel::MakePlayerUnbanned	(	WorldPacket *	data,
		ObjectGuid	bad,
		ObjectGuid	good
	)

private

{
    MakeNotifyPacket(data, CHAT_PLAYER_UNBANNED_NOTICE);
    *data << bad;
    *data << good;
}

References CHAT_PLAYER_UNBANNED_NOTICE, and MakeNotifyPacket().

Referenced by UnBan().

◆ MakeThrottled()

void Channel::MakeThrottled ( WorldPacket * data )

private

{
    MakeNotifyPacket(data, CHAT_THROTTLED_NOTICE);
}

References CHAT_THROTTLED_NOTICE, and MakeNotifyPacket().

◆ MakeVoiceOff()

void Channel::MakeVoiceOff	(	WorldPacket *	data,
		ObjectGuid	guid
	)

private

{
    MakeNotifyPacket(data, CHAT_VOICE_OFF_NOTICE);
    *data << guid;
}

References CHAT_VOICE_OFF_NOTICE, and MakeNotifyPacket().

◆ MakeVoiceOn()

void Channel::MakeVoiceOn	(	WorldPacket *	data,
		ObjectGuid	guid
	)

private

{
    MakeNotifyPacket(data, CHAT_VOICE_ON_NOTICE);
    *data << guid;
}

References CHAT_VOICE_ON_NOTICE, and MakeNotifyPacket().

◆ MakeWrongFaction()

void Channel::MakeWrongFaction ( WorldPacket * data )

private

{
    MakeNotifyPacket(data, CHAT_WRONG_FACTION_NOTICE);
}

References CHAT_WRONG_FACTION_NOTICE, and MakeNotifyPacket().

◆ MakeWrongPassword()

void Channel::MakeWrongPassword ( WorldPacket * data )

private

{
    MakeNotifyPacket(data, CHAT_WRONG_PASSWORD_NOTICE);
}

References CHAT_WRONG_PASSWORD_NOTICE, and MakeNotifyPacket().

Referenced by JoinChannel().

◆ MakeYouJoined()

void Channel::MakeYouJoined ( WorldPacket * data )

private

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

References CHAT_YOU_JOINED_NOTICE, GetChannelId(), GetFlags(), and MakeNotifyPacket().

Referenced by JoinChannel().

◆ MakeYouLeft()

void Channel::MakeYouLeft ( WorldPacket * data )

private

{
    MakeNotifyPacket(data, CHAT_YOU_LEFT_NOTICE);
    *data << uint32(GetChannelId());
    *data << uint8(IsConstant());
}

References CHAT_YOU_LEFT_NOTICE, GetChannelId(), IsConstant(), and MakeNotifyPacket().

Referenced by LeaveChannel().

◆ Password()

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

{
    ObjectGuid guid = player->GetGUID();
 
    ChatHandler chat(player->GetSession());
    if (!IsOn(guid))
    {
        WorldPacket data;
        MakeNotMember(&data);
        SendToOne(&data, guid);
        return;
    }
 
    if (!playersStore[guid].IsModerator() && !player->GetSession()->HasPermission(rbac::RBAC_PERM_CHANGE_CHANNEL_NOT_MODERATOR))
    {
        WorldPacket data;
        MakeNotModerator(&data);
        SendToOne(&data, guid);
        return;
    }
 
    if (_channelRights.flags & CHANNEL_RIGHT_CANT_CHANGE_PASSWORD)
    {
        WorldPacket data;
        MakeNotModerator(&data);
        SendToOne(&data, guid);
        return;
    }
 
    _password = pass;
 
    WorldPacket data;
    MakePasswordChanged(&data, guid);
    SendToAll(&data);
 
    UpdateChannelInDB();
}

References _channelRights, _password, CHANNEL_RIGHT_CANT_CHANGE_PASSWORD, ChannelRights::flags, Object::GetGUID(), Player::GetSession(), WorldSession::HasPermission(), IsOn(), MakeNotMember(), MakeNotModerator(), MakePasswordChanged(), playersStore, rbac::RBAC_PERM_CHANGE_CHANNEL_NOT_MODERATOR, SendToAll(), SendToOne(), and UpdateChannelInDB().

◆ RemoveChannelBanFromDB()

void Channel::RemoveChannelBanFromDB ( ObjectGuid guid ) const

private

{
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHANNEL_BAN);
    stmt->SetData(0, _channelDBId);
    stmt->SetData(1, guid.GetCounter());
    CharacterDatabase.Execute(stmt);
}

References _channelDBId, CHAR_DEL_CHANNEL_BAN, CharacterDatabase, ObjectGuid::GetCounter(), and PreparedStatementBase::SetData().

Referenced by UnBan(), and UnBan().

◆ RemoveWatching()

void Channel::RemoveWatching ( Player * p )

{
    PlayersWatchingContainer::iterator itr = playersWatchingStore.find(p);
    if (itr != playersWatchingStore.end())
        playersWatchingStore.erase(itr);
}

References playersWatchingStore.

Referenced by KickOrBan(), and LeaveChannel().

◆ Say()

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

{
    if (what.empty())
        return;
 
    if (sWorld->getBoolConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_CHANNEL))
        lang = LANG_UNIVERSAL;
 
    if (!IsOn(guid))
    {
        WorldPacket data;
        MakeNotMember(&data);
        SendToOne(&data, guid);
        return;
    }
 
    PlayerInfo& pinfo = playersStore[guid];
 
    if (pinfo.IsMuted())
    {
        WorldPacket data;
        MakeMuted(&data);
        SendToOne(&data, guid);
        return;
    }
 
    Player* player = pinfo.plrPtr;
    WorldPacket data;
 
    if (player)
    {
        ChatHandler::BuildChatPacket(data, CHAT_MSG_CHANNEL, Language(lang), player, player, what, 0, _name);
    }
    else
    {
        ChatHandler::BuildChatPacket(data, CHAT_MSG_CHANNEL, Language(lang), guid, guid, what, 0, "", "", 0, false, _name);
    }
 
    SendToAll(&data, pinfo.IsModerator() ? ObjectGuid::Empty : guid);
}

References _name, ChatHandler::BuildChatPacket(), CHAT_MSG_CHANNEL, CONFIG_ALLOW_TWO_SIDE_INTERACTION_CHANNEL, ObjectGuid::Empty, Channel::PlayerInfo::IsModerator(), Channel::PlayerInfo::IsMuted(), IsOn(), LANG_UNIVERSAL, MakeMuted(), MakeNotMember(), playersStore, Channel::PlayerInfo::plrPtr, SendToAll(), SendToOne(), and sWorld.

◆ SendToAll()

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

private

{
    for (PlayerContainer::const_iterator i = playersStore.begin(); i != playersStore.end(); ++i)
        if (!guid || !i->second.plrPtr->GetSocial()->HasIgnore(guid))
            i->second.plrPtr->SendDirectMessage(data);
}

References playersStore.

Referenced by Announce(), JoinChannel(), KickOrBan(), LeaveChannel(), Password(), Say(), SetModerator(), SetMute(), SetOwner(), ToggleModeration(), and UnBan().

◆ SendToAllButOne()

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

private

{
    for (PlayerContainer::const_iterator i = playersStore.begin(); i != playersStore.end(); ++i)
        if (i->first != who)
            i->second.plrPtr->SendDirectMessage(data);
}

References playersStore.

◆ SendToAllWatching()

void Channel::SendToAllWatching ( WorldPacket * data )

private

{
    for (PlayersWatchingContainer::const_iterator i = playersWatchingStore.begin(); i != playersWatchingStore.end(); ++i)
        (*i)->SendDirectMessage(data);
}

References playersWatchingStore.

Referenced by FlagsNotify(), JoinNotify(), and LeaveNotify().

◆ SendToOne()

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

private

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

References ObjectAccessor::FindConnectedPlayer().

Referenced by Announce(), Invite(), JoinChannel(), KickOrBan(), LeaveChannel(), List(), Password(), Say(), SendWhoOwner(), SetMode(), SetOwner(), ToggleModeration(), and UnBan().

◆ SendWhoOwner()

void Channel::SendWhoOwner ( ObjectGuid guid )

{
    WorldPacket data;
    if (IsOn(guid))
        MakeChannelOwner(&data);
    else
        MakeNotMember(&data);
    SendToOne(&data, guid);
}

References IsOn(), MakeChannelOwner(), MakeNotMember(), and SendToOne().

◆ SetMode()

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

{
    ObjectGuid guid = player->GetGUID();
 
    if (!IsOn(guid))
    {
        WorldPacket data;
        MakeNotMember(&data);
        SendToOne(&data, guid);
        return;
    }
 
    if (!playersStore[guid].IsModerator() && !player->GetSession()->HasPermission(rbac::RBAC_PERM_CHANGE_CHANNEL_NOT_MODERATOR))
    {
        WorldPacket data;
        MakeNotModerator(&data);
        SendToOne(&data, guid);
        return;
    }
 
    if (guid == _ownerGUID && std::string(p2n) == player->GetName() && mod)
        return;
 
    Player* newp = ObjectAccessor::FindPlayerByName(p2n, false);
    ObjectGuid victim = newp ? newp->GetGUID() : ObjectGuid::Empty;
 
    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
            ((!player->GetSession()->HasPermission(rbac::RBAC_PERM_TWO_SIDE_INTERACTION_CHANNEL) || !newp->GetSession()->HasPermission(rbac::RBAC_PERM_TWO_SIDE_INTERACTION_CHANNEL)) && player->GetTeamId() != newp->GetTeamId() &&
             !sWorld->getBoolConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_CHANNEL)))
    {
        WorldPacket data;
        MakePlayerNotFound(&data, p2n);
        SendToOne(&data, guid);
        return;
    }
 
    if (_ownerGUID == victim && _ownerGUID != guid)
    {
        WorldPacket data;
        MakeNotOwner(&data);
        SendToOne(&data, guid);
        return;
    }
 
    if (mod)
    {
        bool isBadConstantModerator = _channelRights.moderators.find(newp->GetSession()->GetAccountId()) != _channelRights.moderators.end();
        if (!isBadConstantModerator)
            SetModerator(newp->GetGUID(), set);
    }
    else
    {
        bool isGoodConstantModerator = _channelRights.moderators.find(player->GetSession()->GetAccountId()) != _channelRights.moderators.end();
        if (!player->GetSession()->HasPermission(rbac::RBAC_PERM_CHANGE_CHANNEL_NOT_MODERATOR) && !isGoodConstantModerator)
        {
            if (_channelRights.flags & CHANNEL_RIGHT_CANT_MUTE)
            {
                WorldPacket data;
                MakeNotModerator(&data);
                SendToOne(&data, guid);
                return;
            }
        }
 
        SetMute(newp->GetGUID(), set);
    }
}

References _channelRights, _ownerGUID, CHANNEL_RIGHT_CANT_MUTE, CONFIG_ALLOW_TWO_SIDE_INTERACTION_CHANNEL, ObjectGuid::Empty, ObjectAccessor::FindPlayerByName(), ChannelRights::flags, WorldSession::GetAccountId(), Object::GetGUID(), WorldObject::GetName(), Player::GetSession(), Player::GetTeamId(), WorldSession::HasPermission(), IsOn(), MakeNotMember(), MakeNotModerator(), MakeNotOwner(), MakePlayerNotFound(), ChannelRights::moderators, playersStore, rbac::RBAC_PERM_CHANGE_CHANNEL_NOT_MODERATOR, rbac::RBAC_PERM_TWO_SIDE_INTERACTION_CHANNEL, SendToOne(), SetModerator(), SetMute(), and sWorld.

Referenced by SetModerator(), SetMute(), UnsetModerator(), and UnsetMute().

◆ SetModerator() [1/2]

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

inlineprivate

    {
        PlayerInfo& pinfo = playersStore[guid];
        if (pinfo.IsModerator() != set)
        {
            uint8 oldFlag = pinfo.flags;
            pinfo.SetModerator(set);
 
            WorldPacket data;
            MakeModeChange(&data, guid, oldFlag);
            SendToAll(&data);
 
            FlagsNotify(pinfo.plrPtr);
        }
    }

References Channel::PlayerInfo::flags, FlagsNotify(), Channel::PlayerInfo::IsModerator(), MakeModeChange(), playersStore, Channel::PlayerInfo::plrPtr, SendToAll(), and Channel::PlayerInfo::SetModerator().

◆ SetModerator() [2/2]

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

inline

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

Channel::SetMode

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

Definition Channel.cpp:573

References SetMode().

Referenced by SetMode().

◆ SetMute() [1/2]

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

inlineprivate

    {
        PlayerInfo& pinfo = playersStore[guid];
        if (pinfo.IsMuted() != set)
        {
            uint8 oldFlag = pinfo.flags;
            pinfo.SetMuted(set);
 
            WorldPacket data;
            MakeModeChange(&data, guid, oldFlag);
            SendToAll(&data);
        }
    }

References Channel::PlayerInfo::flags, Channel::PlayerInfo::IsMuted(), MakeModeChange(), playersStore, SendToAll(), and Channel::PlayerInfo::SetMuted().

◆ SetMute() [2/2]

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

inline

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

References SetMode().

Referenced by SetMode().

◆ SetOwner() [1/2]

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

{
    if (_ownerGUID)
    {
        // [] will re-add player after it possible removed
        PlayerContainer::iterator p_itr = playersStore.find(_ownerGUID);
        if (p_itr != playersStore.end())
        {
            p_itr->second.SetOwner(false);
            FlagsNotify(p_itr->second.plrPtr);
        }
    }
 
    _ownerGUID = guid;
    if (_ownerGUID)
    {
        PlayerInfo& pinfo = playersStore[_ownerGUID];
 
        pinfo.SetModerator(true);
        uint8 oldFlag = pinfo.flags;
        pinfo.SetOwner(true);
        FlagsNotify(pinfo.plrPtr);
 
        Player* player = ObjectAccessor::FindPlayer(_ownerGUID);
        if (player)
        {
            if (ShouldAnnouncePlayer(player))
            {
                WorldPacket data;
 
                MakeModeChange(&data, _ownerGUID, oldFlag);
                SendToAll(&data);
 
                if (exclaim)
                {
                    // MakeOwnerChanged will reset the packet for us
                    MakeOwnerChanged(&data, _ownerGUID);
                    SendToAll(&data);
                }
            }
        }
    }
}

References _ownerGUID, ObjectAccessor::FindPlayer(), Channel::PlayerInfo::flags, FlagsNotify(), MakeModeChange(), MakeOwnerChanged(), playersStore, Channel::PlayerInfo::plrPtr, SendToAll(), Channel::PlayerInfo::SetModerator(), Channel::PlayerInfo::SetOwner(), and ShouldAnnouncePlayer().

Referenced by JoinChannel(), KickOrBan(), LeaveChannel(), and SetOwner().

◆ SetOwner() [2/2]

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

{
    ObjectGuid guid = player->GetGUID();
 
    if (!IsOn(guid))
    {
        WorldPacket data;
        MakeNotMember(&data);
        SendToOne(&data, guid);
        return;
    }
 
    bool isGoodConstantModerator = _channelRights.moderators.find(player->GetSession()->GetAccountId()) != _channelRights.moderators.end();
    if (!player->GetSession()->HasPermission(rbac::RBAC_PERM_CHANGE_CHANNEL_NOT_MODERATOR) && guid != _ownerGUID && !isGoodConstantModerator)
    {
        WorldPacket data;
        MakeNotOwner(&data);
        SendToOne(&data, guid);
        return;
    }
 
    Player* newp = ObjectAccessor::FindPlayerByName(newname, false);
    ObjectGuid victim = newp ? newp->GetGUID() : ObjectGuid::Empty;
 
    if (!victim || !IsOn(victim) || (newp->GetTeamId() != player->GetTeamId() &&
                                     !sWorld->getBoolConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_CHANNEL)))
    {
        WorldPacket data;
        MakePlayerNotFound(&data, newname);
        SendToOne(&data, guid);
        return;
    }
 
    SetOwner(victim);
}

References _channelRights, _ownerGUID, CONFIG_ALLOW_TWO_SIDE_INTERACTION_CHANNEL, ObjectGuid::Empty, ObjectAccessor::FindPlayerByName(), WorldSession::GetAccountId(), Object::GetGUID(), Player::GetSession(), Player::GetTeamId(), WorldSession::HasPermission(), IsOn(), MakeNotMember(), MakeNotOwner(), MakePlayerNotFound(), ChannelRights::moderators, rbac::RBAC_PERM_CHANGE_CHANNEL_NOT_MODERATOR, SendToOne(), SetOwner(), and sWorld.

◆ SetPassword()

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

inline

186{ _password = npassword; }

References _password.

Referenced by ChannelMgr::LoadChannels().

◆ ShouldAnnouncePlayer()

bool Channel::ShouldAnnouncePlayer ( Player const * player ) const

private

{
    return !(player->GetSession()->HasPermission(rbac::RBAC_PERM_SILENTLY_JOIN_CHANNEL) && sWorld->getBoolConfig(CONFIG_SILENTLY_GM_JOIN_TO_CHANNEL));
}

References CONFIG_SILENTLY_GM_JOIN_TO_CHANNEL, Player::GetSession(), WorldSession::HasPermission(), rbac::RBAC_PERM_SILENTLY_JOIN_CHANNEL, and sWorld.

Referenced by JoinChannel(), KickOrBan(), LeaveChannel(), and SetOwner().

◆ ToggleModeration()

void Channel::ToggleModeration ( Player * p )

{
    ObjectGuid guid = player->GetGUID();
 
    if (!IsOn(guid))
    {
        WorldPacket data;
        MakeNotMember(&data);
        SendToOne(&data, guid);
        return;
    }
 
    const bool gm = player->GetSession()->HasPermission(rbac::RBAC_PERM_CHANGE_CHANNEL_NOT_MODERATOR);
 
    if (!playersStore[guid].IsModerator() && !gm)
    {
        WorldPacket data;
        MakeNotModerator(&data);
        SendToOne(&data, guid);
        return;
    }
 
    // toggle channel moderation
    _moderation = !_moderation;
 
    WorldPacket data;
    if (_moderation)
    {
        MakeModerationOn(&data, guid);
    }
    else
    {
        MakeModerationOff(&data, guid);
    }
 
    SendToAll(&data);
}

References _moderation, Object::GetGUID(), Player::GetSession(), WorldSession::HasPermission(), IsOn(), MakeModerationOff(), MakeModerationOn(), MakeNotMember(), MakeNotModerator(), playersStore, rbac::RBAC_PERM_CHANGE_CHANNEL_NOT_MODERATOR, SendToAll(), and SendToOne().

◆ UnBan() [1/2]

void Channel::UnBan ( ObjectGuid guid )

{
    if (!IsBanned(guid))
        return;
    bannedStore.erase(guid);
    RemoveChannelBanFromDB(guid);
}

References bannedStore, IsBanned(), and RemoveChannelBanFromDB().

◆ UnBan() [2/2]

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

{
    ObjectGuid good = player->GetGUID();
 
    if (!IsOn(good))
    {
        WorldPacket data;
        MakeNotMember(&data);
        SendToOne(&data, good);
        return;
    }
 
    if (!playersStore[good].IsModerator() && !player->GetSession()->HasPermission(rbac::RBAC_PERM_CHANGE_CHANNEL_NOT_MODERATOR))
    {
        WorldPacket data;
        MakeNotModerator(&data);
        SendToOne(&data, good);
        return;
    }
 
    ObjectGuid victim;
    if (ObjectGuid guid = sCharacterCache->GetCharacterGuidByName(badname))
    {
        victim = guid;
    }
 
    if (!victim || !IsBanned(victim))
    {
        WorldPacket data;
        MakePlayerNotFound(&data, badname);
        SendToOne(&data, good);
        return;
    }
 
    bool isConstantModerator = _channelRights.moderators.find(player->GetSession()->GetAccountId()) != _channelRights.moderators.end();
    if (!player->GetSession()->HasPermission(rbac::RBAC_PERM_CHANGE_CHANNEL_NOT_MODERATOR) && !isConstantModerator)
    {
        if (_channelRights.flags & CHANNEL_RIGHT_CANT_BAN)
        {
            WorldPacket data;
            MakeNotModerator(&data);
            SendToOne(&data, good);
            return;
        }
    }
 
    if (_channelRights.flags & CHANNEL_RIGHT_CANT_BAN)
        LOG_GM(player->GetSession()->GetAccountId(), "Command: /unban {} {} (Moderator {} [{}, account: {}] unbanned {} [{}])",
            GetName(), badname, player->GetName(), player->GetGUID().ToString(), player->GetSession()->GetAccountId(),
            badname, victim.ToString());
 
    bannedStore.erase(victim);
    RemoveChannelBanFromDB(victim);
 
    WorldPacket data;
    MakePlayerUnbanned(&data, victim, good);
    SendToAll(&data);
}

References _channelRights, bannedStore, CHANNEL_RIGHT_CANT_BAN, ChannelRights::flags, WorldSession::GetAccountId(), Object::GetGUID(), GetName(), WorldObject::GetName(), Player::GetSession(), WorldSession::HasPermission(), IsBanned(), IsOn(), LOG_GM, MakeNotMember(), MakeNotModerator(), MakePlayerNotFound(), MakePlayerUnbanned(), ChannelRights::moderators, playersStore, rbac::RBAC_PERM_CHANGE_CHANNEL_NOT_MODERATOR, RemoveChannelBanFromDB(), sCharacterCache, SendToAll(), SendToOne(), and ObjectGuid::ToString().

◆ UnsetModerator()

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

inline

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

References SetMode().

◆ UnsetMute()

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

inline

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

References SetMode().

◆ UpdateChannelInDB()

void Channel::UpdateChannelInDB ( ) const

private

{
    if (_IsSaved)
    {
        CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_CHANNEL);
        stmt->SetData(0, _announce);
        stmt->SetData(1, _password);
        stmt->SetData(2, _channelDBId);
        CharacterDatabase.Execute(stmt);
 
        LOG_DEBUG("chat.system", "Channel({}) updated in database", _name);
    }
}

References _announce, _channelDBId, _IsSaved, _name, _password, CHAR_UPD_CHANNEL, CharacterDatabase, LOG_DEBUG, and PreparedStatementBase::SetData().

Referenced by Announce(), and Password().

◆ UpdateChannelUseageInDB()

void Channel::UpdateChannelUseageInDB ( ) const

private

{
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_CHANNEL_USAGE);
    stmt->SetData(0, _channelDBId);
    CharacterDatabase.Execute(stmt);
}

References _channelDBId, CHAR_UPD_CHANNEL_USAGE, CharacterDatabase, and PreparedStatementBase::SetData().

Referenced by JoinChannel(), and LeaveChannel().

◆ Voice()

void Channel::Voice	(	ObjectGuid	guid1,
		ObjectGuid	guid2
	)

945{

946}

Member Data Documentation

◆ _announce

bool Channel::_announce

private

Referenced by Announce(), Channel(), IsAnnounce(), JoinChannel(), LeaveChannel(), and UpdateChannelInDB().

◆ _channelDBId

uint32 Channel::_channelDBId

private

Referenced by AddChannelBanToDB(), Channel(), GetChannelDBId(), RemoveChannelBanFromDB(), UpdateChannelInDB(), and UpdateChannelUseageInDB().

◆ _channelId

uint32 Channel::_channelId

private

Referenced by GetChannelId(), and IsConstant().

◆ _channelRights

ChannelRights Channel::_channelRights

private

Referenced by Announce(), Channel(), FlagsNotify(), JoinChannel(), JoinNotify(), KickOrBan(), LeaveNotify(), List(), Password(), SetMode(), SetOwner(), and UnBan().

◆ _flags

uint8 Channel::_flags

private

Referenced by Channel(), GetFlags(), and HasFlag().

◆ _isOwnerGM

bool Channel::_isOwnerGM

private

Referenced by JoinChannel(), and LeaveChannel().

◆ _IsSaved

bool Channel::_IsSaved

private

Referenced by Channel(), and UpdateChannelInDB().

◆ _moderation

bool Channel::_moderation

private

Referenced by ToggleModeration().

◆ _name

std::string Channel::_name

private

Referenced by Channel(), GetName(), MakeNotifyPacket(), Say(), and UpdateChannelInDB().

◆ _ownerGUID

ObjectGuid Channel::_ownerGUID

private

Referenced by JoinChannel(), KickOrBan(), MakeChannelOwner(), SetMode(), SetOwner(), and SetOwner().

◆ _ownership

bool Channel::_ownership

private

Referenced by Channel(), JoinChannel(), KickOrBan(), and LeaveChannel().

◆ _password

std::string Channel::_password

private

Referenced by GetPassword(), JoinChannel(), Password(), SetPassword(), and UpdateChannelInDB().

◆ _teamId

TeamId Channel::_teamId

private

Referenced by Channel().

◆ bannedStore

BannedContainer Channel::bannedStore

private

Referenced by AddBan(), IsBanned(), KickOrBan(), UnBan(), and UnBan().

◆ playersStore

PlayerContainer Channel::playersStore

private

Referenced by Announce(), GetNumPlayers(), GetPlayerFlags(), IsOn(), JoinChannel(), KickOrBan(), LeaveChannel(), List(), Password(), Say(), SendToAll(), SendToAllButOne(), SetMode(), SetModerator(), SetMute(), SetOwner(), ToggleModeration(), and UnBan().

◆ playersWatchingStore

PlayersWatchingContainer Channel::playersWatchingStore

private

Referenced by AddWatching(), RemoveWatching(), and SendToAllWatching().

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

azerothcore-wotlk/src/server/game/Chat/Channels/Channel.h
azerothcore-wotlk/src/server/game/Chat/Channels/Channel.cpp

Classes

Public Member Functions

Static Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ BannedContainer

◆ PlayerContainer

◆ PlayersWatchingContainer

Constructor & Destructor Documentation

◆ Channel()

Member Function Documentation

◆ AddBan()

◆ AddChannelBanToDB()

◆ AddWatching()

◆ Announce()

◆ Ban()

◆ CleanOldChannelsInDB()

◆ DeVoice()

◆ FlagsNotify()

◆ GetChannelDBId()

◆ GetChannelId()

◆ GetFlags()

◆ GetName()

◆ GetNumPlayers()

◆ GetPassword()

◆ GetPlayerFlags()

◆ HasFlag()

◆ Invite()

◆ IsAnnounce()

◆ IsBanned()

◆ IsConstant()

◆ IsLFG()

◆ IsOn()

◆ JoinChannel()

◆ JoinNotify()

◆ Kick()

◆ KickOrBan()

◆ LeaveChannel()

◆ LeaveNotify()

◆ List()

◆ MakeAnnouncementsOff()

◆ MakeAnnouncementsOn()

◆ MakeBanned()

◆ MakeChannelOwner()

◆ MakeInvalidName()

◆ MakeInvite()

◆ MakeInviteWrongFaction()

◆ MakeJoined()

◆ MakeLeft()

◆ MakeModeChange()

◆ MakeModerationOff()

◆ MakeModerationOn()

◆ MakeMuted()

◆ MakeNotifyPacket()

◆ MakeNotInArea()

◆ MakeNotInLfg()

◆ MakeNotMember()

◆ MakeNotModerated()

◆ MakeNotModerator()

◆ MakeNotOwner()

◆ MakeOwnerChanged()

◆ MakePasswordChanged()

◆ MakePlayerAlreadyMember()

◆ MakePlayerBanned()

◆ MakePlayerInviteBanned()

◆ MakePlayerInvited()

◆ MakePlayerKicked()

◆ MakePlayerNotBanned()

◆ MakePlayerNotFound()

◆ MakePlayerUnbanned()

◆ MakeThrottled()

◆ MakeVoiceOff()

◆ MakeVoiceOn()

◆ MakeWrongFaction()

◆ MakeWrongPassword()

◆ MakeYouJoined()

◆ MakeYouLeft()