Channel Class Reference

#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

{ bannedStore[guid] = time; }

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()->IsGMAccount())
    {
        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::IsGMAccount(), IsOn(), MakeAnnouncementsOff(), MakeAnnouncementsOn(), MakeNotMember(), MakeNotModerator(), playersStore, SendToAll(), SendToOne(), and UpdateChannelInDB().

Ban()

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

inline

{ KickOrBan(player, badname, true); }

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
	)

{
}

FlagsNotify()

void Channel::FlagsNotify

(

Player *

p

)

{
    if (_channelRights.flags & CHANNEL_RIGHT_CANT_SPEAK)
        return;
    if (!AccountMgr::IsPlayerAccount(p->GetSession()->GetSecurity()))
        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(), WorldSession::GetSecurity(), Player::GetSession(), AccountMgr::IsPlayerAccount(), SendToAllWatching(), and SMSG_USERLIST_UPDATE.

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

GetChannelDBId()

uint32 Channel::GetChannelDBId ( ) const

inline

{ return _channelDBId; }

References _channelDBId.

GetChannelId()

uint32 Channel::GetChannelId ( ) const

inline

{ return _channelId; }

References _channelId.

Referenced by MakeYouJoined(), and MakeYouLeft().

GetFlags()

uint8 Channel::GetFlags ( ) const

inline

{ return _flags; }

References _flags.

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

GetName()

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

inline

{ return _name; }

References _name.

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

GetNumPlayers()

uint32 Channel::GetNumPlayers ( ) const

inline

{ return playersStore.size(); }

References playersStore.

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

GetPassword()

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

inline

{ 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

{ return _flags & flag; }

References _flags.

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

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

{ 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

{ return _channelId != 0; }

References _channelId.

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

IsLFG()

bool Channel::IsLFG ( ) const

inline

{ return HasFlag(CHANNEL_FLAG_LFG); }

References CHANNEL_FLAG_LFG, and HasFlag().

Referenced by JoinChannel().

IsOn()

bool Channel::IsOn ( ObjectGuid  who ) const

inlineprivate

{ 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()->IsGMAccount());
 
    // 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(), IsBanned(), IsConstant(), WorldSession::IsGMAccount(), 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(), 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 (!AccountMgr::IsPlayerAccount(p->GetSession()->GetSecurity()))
        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(), WorldSession::GetSecurity(), Player::GetSession(), AccountMgr::IsPlayerAccount(), SendToAllWatching(), and SMSG_USERLIST_ADD.

Referenced by JoinChannel().

Kick()

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

inline

{ 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()->IsGMAccount())
    {
        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()->IsGMAccount() || 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()->IsGMAccount() && !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()->IsGMAccount())
        {
            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()->GetSecurity())
                    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(), IsBanned(), WorldSession::IsGMAccount(), IsOn(), LeaveNotify(), Player::LeftChannel(), MakeNotMember(), MakeNotModerator(), MakeNotOwner(), MakePlayerBanned(), MakePlayerKicked(), MakePlayerNotFound(), ChannelRights::moderators, playersStore, ChatHandler::PSendSysMessage(), 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()->IsGMAccount())
                        _isOwnerGM = true;
                    else
                        _isOwnerGM = false;
                    if (!itr->second.plrPtr->GetSession()->GetSecurity())
                        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, 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 (!AccountMgr::IsPlayerAccount(p->GetSession()->GetSecurity()))
        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(), WorldSession::GetSecurity(), Player::GetSession(), AccountMgr::IsPlayerAccount(), 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 count  = 0;
    if (!(_channelRights.flags & CHANNEL_RIGHT_CANT_SPEAK))
        for (PlayerContainer::const_iterator i = playersStore.begin(); i != playersStore.end(); ++i)
            if (AccountMgr::IsPlayerAccount(i->second.plrPtr->GetSession()->GetSecurity()))
            {
                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, ChannelRights::flags, GetFlags(), Object::GetGUID(), GetName(), WorldSession::GetPlayerInfo(), Player::GetSession(), IsOn(), AccountMgr::IsPlayerAccount(), LOG_DEBUG, MakeNotMember(), playersStore, ByteBuffer::put(), SendToOne(), SMSG_CHANNEL_LIST, 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()->IsGMAccount())
    {
        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::IsGMAccount(), IsOn(), MakeNotMember(), MakeNotModerator(), MakePasswordChanged(), playersStore, 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->GetSession()->SendPacket(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->GetSession()->SendPacket(data);
}

References playersStore.

SendToAllWatching()

void Channel::SendToAllWatching ( WorldPacket *  data )

private

{
    for (PlayersWatchingContainer::const_iterator i = playersWatchingStore.begin(); i != playersWatchingStore.end(); ++i)
        (*i)->GetSession()->SendPacket(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->GetSession()->SendPacket(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()->IsGMAccount())
    {
        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()->IsGMAccount() || !newp->GetSession()->IsGMAccount()) && 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()->IsGMAccount() && !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::IsGMAccount(), IsOn(), MakeNotMember(), MakeNotModerator(), MakeNotOwner(), MakePlayerNotFound(), ChannelRights::moderators, playersStore, 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

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

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

{ 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()->IsGMAccount() && 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::IsGMAccount(), IsOn(), MakeNotMember(), MakeNotOwner(), MakePlayerNotFound(), ChannelRights::moderators, SendToOne(), SetOwner(), and sWorld.

SetPassword()

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

inline

{ _password = npassword; }

References _password.

Referenced by ChannelMgr::LoadChannels().

ShouldAnnouncePlayer()

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

private

{
    return !(player->GetSession()->IsGMAccount() && sWorld->getBoolConfig(CONFIG_SILENTLY_GM_JOIN_TO_CHANNEL));
}

References CONFIG_SILENTLY_GM_JOIN_TO_CHANNEL, Player::GetSession(), WorldSession::IsGMAccount(), 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 uint32 level = sWorld->getIntConfig(CONFIG_GM_LEVEL_CHANNEL_MODERATION);
    const bool gm = (level && player->GetSession()->GetSecurity() >= level);
 
    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, CONFIG_GM_LEVEL_CHANNEL_MODERATION, Object::GetGUID(), WorldSession::GetSecurity(), Player::GetSession(), IsOn(), MakeModerationOff(), MakeModerationOn(), MakeNotMember(), MakeNotModerator(), playersStore, SendToAll(), SendToOne(), and sWorld.

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()->IsGMAccount())
    {
        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()->IsGMAccount() && !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(), IsBanned(), WorldSession::IsGMAccount(), IsOn(), LOG_GM, MakeNotMember(), MakeNotModerator(), MakePlayerNotFound(), MakePlayerUnbanned(), ChannelRights::moderators, playersStore, RemoveChannelBanFromDB(), sCharacterCache, SendToAll(), SendToOne(), and ObjectGuid::ToString().

UnsetModerator()

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

inline

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

References SetMode().

UnsetMute()

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

inline

{ 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
	)

{
}

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