PlayerSocial Class Reference

#include "SocialMgr.h"

Public Member Functions
	PlayerSocial ()
bool	AddToSocialList (ObjectGuid friend_guid, SocialFlag flag)
void	RemoveFromSocialList (ObjectGuid friend_guid, SocialFlag flag)
void	SetFriendNote (ObjectGuid friendGuid, std::string note)
void	SendSocialList (Player *player, uint32 flags)
bool	HasFriend (ObjectGuid friend_guid) const
bool	HasIgnore (ObjectGuid ignore_guid) const
ObjectGuid	GetPlayerGUID () const
void	SetPlayerGUID (ObjectGuid guid)
uint32	GetNumberOfSocialsWithFlag (SocialFlag flag) const

Private Types
typedef std::map< ObjectGuid, FriendInfo >	PlayerSocialMap

Private Member Functions
bool	_checkContact (ObjectGuid guid, SocialFlag flags) const

Private Attributes
PlayerSocialMap	m_playerSocialMap
ObjectGuid	m_playerGUID

Friends
class	SocialMgr

Detailed Description

Member Typedef Documentation

PlayerSocialMap

typedef std::map<ObjectGuid, FriendInfo> PlayerSocial::PlayerSocialMap

private

Constructor & Destructor Documentation

PlayerSocial()

PlayerSocial::PlayerSocial

(

)

: m_playerGUID() { }

Member Function Documentation

_checkContact()

bool PlayerSocial::_checkContact ( ObjectGuid  guid, SocialFlag  flags  ) const

private

{
    auto const& itr = m_playerSocialMap.find(guid);
    if (itr != m_playerSocialMap.end())
        return (itr->second.Flags & flags) != 0;
 
    return false;
}

References m_playerSocialMap.

Referenced by HasFriend(), and HasIgnore().

AddToSocialList()

bool PlayerSocial::AddToSocialList	(	ObjectGuid	friend_guid,
		SocialFlag	flag
	)

{
    // check client limits
    if (GetNumberOfSocialsWithFlag(flag) >= (((flag & SOCIAL_FLAG_FRIEND) != 0) ? SOCIALMGR_FRIEND_LIMIT : SOCIALMGR_IGNORE_LIMIT))
        return false;
 
    auto itr = m_playerSocialMap.find(friendGuid);
    if (itr != m_playerSocialMap.end())
    {
        itr->second.Flags |= flag;
 
        CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_ADD_CHARACTER_SOCIAL_FLAGS);
 
        stmt->SetData(0, itr->second.Flags);
        stmt->SetData(1, GetPlayerGUID().GetCounter());
        stmt->SetData(2, friendGuid.GetCounter());
 
        CharacterDatabase.Execute(stmt);
    }
    else
    {
        m_playerSocialMap[friendGuid].Flags |= flag;
 
        CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_CHARACTER_SOCIAL);
 
        stmt->SetData(0, GetPlayerGUID().GetCounter());
        stmt->SetData(1, friendGuid.GetCounter());
        stmt->SetData(2, flag);
 
        CharacterDatabase.Execute(stmt);
    }
    return true;
}

References CHAR_INS_CHARACTER_SOCIAL, CHAR_UPD_ADD_CHARACTER_SOCIAL_FLAGS, CharacterDatabase, ObjectGuid::GetCounter(), GetNumberOfSocialsWithFlag(), GetPlayerGUID(), m_playerSocialMap, PreparedStatementBase::SetData(), SOCIAL_FLAG_FRIEND, SOCIALMGR_FRIEND_LIMIT, and SOCIALMGR_IGNORE_LIMIT.

GetNumberOfSocialsWithFlag()

uint32 PlayerSocial::GetNumberOfSocialsWithFlag

(

SocialFlag

flag

)

const

{
    uint32 counter = 0;
    for (auto const& itr : m_playerSocialMap)
    {
        if ((itr.second.Flags & flag) != 0)
            ++counter;
    }
    return counter;
}

References m_playerSocialMap.

Referenced by AddToSocialList().

GetPlayerGUID()

ObjectGuid PlayerSocial::GetPlayerGUID ( ) const

inline

{ return m_playerGUID; }

References m_playerGUID.

Referenced by AddToSocialList(), RemoveFromSocialList(), and SetFriendNote().

HasFriend()

bool PlayerSocial::HasFriend

(

ObjectGuid

friend_guid

)

const

{
    return _checkContact(friend_guid, SOCIAL_FLAG_FRIEND);
}

References _checkContact(), and SOCIAL_FLAG_FRIEND.

Referenced by WorldSession::HandleGroupInviteOpcode().

HasIgnore()

bool PlayerSocial::HasIgnore

(

ObjectGuid

ignore_guid

)

const

{
    return _checkContact(ignore_guid, SOCIAL_FLAG_IGNORED);
}

References _checkContact(), and SOCIAL_FLAG_IGNORED.

Referenced by Spell::EffectDuel(), WorldSession::HandleArenaTeamInviteOpcode(), WorldSession::HandleGroupInviteOpcode(), WorldSession::HandleInitiateTradeOpcode(), Guild::HandleInviteMember(), lfg::LFGMgr::HasIgnore(), and Channel::Invite().

RemoveFromSocialList()

void PlayerSocial::RemoveFromSocialList	(	ObjectGuid	friend_guid,
		SocialFlag	flag
	)

{
    auto itr = m_playerSocialMap.find(friendGuid);
    if (itr == m_playerSocialMap.end())                     // not exist
        return;
 
    itr->second.Flags &= ~flag;
 
    if (itr->second.Flags == 0)
    {
        CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHARACTER_SOCIAL);
 
        stmt->SetData(0, GetPlayerGUID().GetCounter());
        stmt->SetData(1, friendGuid.GetCounter());
 
        CharacterDatabase.Execute(stmt);
 
        m_playerSocialMap.erase(itr);
    }
    else
    {
        CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_REM_CHARACTER_SOCIAL_FLAGS);
 
        stmt->SetData(0, flag);
        stmt->SetData(1, GetPlayerGUID().GetCounter());
        stmt->SetData(2, friendGuid.GetCounter());
 
        CharacterDatabase.Execute(stmt);
    }
}

References CHAR_DEL_CHARACTER_SOCIAL, CHAR_UPD_REM_CHARACTER_SOCIAL_FLAGS, CharacterDatabase, ObjectGuid::GetCounter(), GetPlayerGUID(), m_playerSocialMap, and PreparedStatementBase::SetData().

Referenced by WorldSession::HandleDelFriendOpcode(), and WorldSession::HandleDelIgnoreOpcode().

SendSocialList()

void PlayerSocial::SendSocialList	(	Player *	player,
		uint32	flags
	)

{
    if (!player)
        return;
 
    uint32 friendsCount = 0;
    uint32 ignoredCount = 0;
    uint32 totalCount = 0;
 
    WorldPacket data(SMSG_CONTACT_LIST, (4 + 4 + m_playerSocialMap.size() * 25)); // just can guess size
    data << uint32(flags);                                                        // 0x1 = Friendlist update. 0x2 = Ignorelist update. 0x4 = Mutelist update.
    std::size_t countPos = data.wpos();
    data << uint32(0);                                                           // contacts count placeholder
 
    for (auto& itr : m_playerSocialMap)
    {
        FriendInfo& friendInfo = itr.second;
        uint8 contactFlags = friendInfo.Flags;
        if (!(contactFlags & flags))
            continue;
 
        // Check client limit for friends list
        if (contactFlags & SOCIAL_FLAG_FRIEND)
            if (++friendsCount > SOCIALMGR_FRIEND_LIMIT)
                continue;
 
        // Check client limit for ignore list
        if (contactFlags & SOCIAL_FLAG_IGNORED)
            if (++ignoredCount > SOCIALMGR_IGNORE_LIMIT)
                continue;
 
        ++totalCount;
 
        sSocialMgr->GetFriendInfo(player, itr.first, friendInfo);
 
        data << itr.first;                                    // player guid
        data << uint32(contactFlags);                         // player flag (0x1 = Friend, 0x2 = Ignored, 0x4 = Muted)
        data << friendInfo.Note;                              // string note
        if (contactFlags & SOCIAL_FLAG_FRIEND)                // if IsFriend()
        {
            data << uint8(friendInfo.Status);                 // online/offline/etc?
            if (friendInfo.Status)                            // if online
            {
                data << uint32(friendInfo.Area);              // player area
                data << uint32(friendInfo.Level);             // player level
                data << uint32(friendInfo.Class);             // player class
            }
        }
    }
 
    data.put<uint32>(countPos, totalCount);
    player->GetSession()->SendPacket(&data);
    LOG_DEBUG("network", "WORLD: Sent SMSG_CONTACT_LIST");
}

References FriendInfo::Area, FriendInfo::Class, FriendInfo::Flags, Player::GetSession(), FriendInfo::Level, LOG_DEBUG, m_playerSocialMap, FriendInfo::Note, ByteBuffer::put(), WorldSession::SendPacket(), SMSG_CONTACT_LIST, SOCIAL_FLAG_FRIEND, SOCIAL_FLAG_IGNORED, SOCIALMGR_FRIEND_LIMIT, SOCIALMGR_IGNORE_LIMIT, sSocialMgr, FriendInfo::Status, and ByteBuffer::wpos().

Referenced by WorldSession::HandleContactListOpcode(), and Player::SendInitialPacketsBeforeAddToMap().

SetFriendNote()

void PlayerSocial::SetFriendNote	(	ObjectGuid	friendGuid,
		std::string	note
	)

{
    auto itr = m_playerSocialMap.find(friendGuid);
    if (itr == m_playerSocialMap.end())                     // not exist
        return;
 
    utf8truncate(note, 48);                                  // DB and client size limitation
 
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_CHARACTER_SOCIAL_NOTE);
 
    stmt->SetData(0, note);
    stmt->SetData(1, GetPlayerGUID().GetCounter());
    stmt->SetData(2, friendGuid.GetCounter());
 
    CharacterDatabase.Execute(stmt);
 
    m_playerSocialMap[friendGuid].Note = note;
}

References CHAR_UPD_CHARACTER_SOCIAL_NOTE, CharacterDatabase, ObjectGuid::GetCounter(), GetPlayerGUID(), m_playerSocialMap, PreparedStatementBase::SetData(), and utf8truncate().

Referenced by WorldSession::HandleAddFriendOpcode(), and WorldSession::HandleSetContactNotesOpcode().

SetPlayerGUID()

void PlayerSocial::SetPlayerGUID ( ObjectGuid  guid )

inline

{ m_playerGUID = guid; }

References m_playerGUID.

Referenced by SocialMgr::LoadFromDB().

Friends And Related Function Documentation

SocialMgr

friend class SocialMgr

friend

Member Data Documentation

m_playerGUID

ObjectGuid PlayerSocial::m_playerGUID

private

Referenced by GetPlayerGUID(), and SetPlayerGUID().

m_playerSocialMap

PlayerSocialMap PlayerSocial::m_playerSocialMap

private

Referenced by _checkContact(), AddToSocialList(), SocialMgr::GetFriendInfo(), GetNumberOfSocialsWithFlag(), SocialMgr::LoadFromDB(), RemoveFromSocialList(), SendSocialList(), and SetFriendNote().