Group Class Reference

#include "Group.h"

Classes
struct	MemberSlot

Public Types
typedef std::list< MemberSlot >	MemberSlotList
typedef MemberSlotList::const_iterator	member_citerator

Public Member Functions
	Group ()
	~Group ()
bool	Create (Player *leader)
bool	LoadGroupFromDB (Field *field)
void	LoadMemberFromDB (ObjectGuid::LowType guidLow, uint8 memberFlags, uint8 subgroup, uint8 roles)
bool	AddInvite (Player *player)
void	RemoveInvite (Player *player)
void	RemoveAllInvites ()
bool	AddLeaderInvite (Player *player)
bool	AddMember (Player *player, uint8 roles=0)
bool	RemoveMember (ObjectGuid guid, RemoveMethod const &method=GROUP_REMOVEMETHOD_DEFAULT, ObjectGuid kicker=ObjectGuid::Empty, char const *reason=nullptr)
void	ChangeLeader (ObjectGuid guid)
void	SetLootMethod (LootMethod method)
void	SetLooterGuid (ObjectGuid guid)
void	SetMasterLooterGuid (ObjectGuid guid)
void	UpdateLooterGuid (WorldObject *pLootedObject, bool ifneed=false)
void	SetLootThreshold (ItemQualities threshold)
void	Disband (bool hideDestroy=false)
void	SetLfgRoles (ObjectGuid guid, const uint8 roles)
bool	IsFull () const
bool	isLFGGroup (bool restricted=false) const
bool	isRaidGroup () const
bool	isBFGroup () const
bool	isBGGroup () const
bool	IsCreated () const
GroupType	GetGroupType () const
ObjectGuid	GetLeaderGUID () const
Player *	GetLeader ()
ObjectGuid	GetGUID () const
char const *	GetLeaderName () const
LootMethod	GetLootMethod () const
ObjectGuid	GetLooterGuid () const
ObjectGuid	GetMasterLooterGuid () const
ItemQualities	GetLootThreshold () const
bool	IsMember (ObjectGuid guid) const
bool	IsLeader (ObjectGuid guid) const
ObjectGuid	GetMemberGUID (std::string const &name)
bool	IsAssistant (ObjectGuid guid) const
Player *	GetInvited (ObjectGuid guid) const
Player *	GetInvited (std::string const &name) const
bool	SameSubGroup (ObjectGuid guid1, ObjectGuid guid2) const
bool	SameSubGroup (ObjectGuid guid1, MemberSlot const *slot2) const
bool	SameSubGroup (Player const *member1, Player const *member2) const
bool	HasFreeSlotSubGroup (uint8 subgroup) const
MemberSlotList const &	GetMemberSlots () const
GroupReference *	GetFirstMember ()
GroupReference const *	GetFirstMember () const
uint32	GetMembersCount () const
uint32	GetInviteeCount () const
uint8	GetMemberGroup (ObjectGuid guid) const
void	ConvertToLFG (bool restricted=true)
bool	CheckLevelForRaid ()
void	ConvertToRaid ()
void	SetBattlegroundGroup (Battleground *bg)
void	SetBattlefieldGroup (Battlefield *bf)
GroupJoinBattlegroundResult	CanJoinBattlegroundQueue (Battleground const *bgTemplate, BattlegroundQueueTypeId bgQueueTypeId, uint32 MinPlayerCount, uint32 MaxPlayerCount, bool isRated, uint32 arenaSlot)
void	DoMinimapPing (ObjectGuid sourceGuid, float mapX, float mapY)
void	ChangeMembersGroup (ObjectGuid guid, uint8 group)
void	SetTargetIcon (uint8 id, ObjectGuid whoGuid, ObjectGuid targetGuid)
void	SetGroupMemberFlag (ObjectGuid guid, bool apply, GroupMemberFlags flag)
void	RemoveUniqueGroupMemberFlag (GroupMemberFlags flag)
ObjectGuid	GetTargetIcon (uint8 id) const
Difficulty	GetDifficulty (bool isRaid) const
Difficulty	GetDungeonDifficulty () const
Difficulty	GetRaidDifficulty () const
void	SetDungeonDifficulty (Difficulty difficulty)
void	SetRaidDifficulty (Difficulty difficulty)
uint16	InInstance ()
void	ResetInstances (uint8 method, bool isRaid, Player *leader)
void	SendTargetIconList (WorldSession *session)
void	SendUpdate ()
void	SendUpdateToPlayer (ObjectGuid playerGUID, MemberSlot *slot=nullptr)
void	UpdatePlayerOutOfRange (Player *player)
void	BroadcastPacket (WorldPacket const *packet, bool ignorePlayersInBGRaid, int group=-1, ObjectGuid ignore=ObjectGuid::Empty)
void	BroadcastReadyCheck (WorldPacket const *packet)
void	OfflineReadyCheck ()
bool	isRollLootActive () const
void	SendLootStartRoll (uint32 CountDown, uint32 mapid, Roll const &r)
void	SendLootStartRollToPlayer (uint32 countDown, uint32 mapId, Player *p, bool canNeed, Roll const &r)
void	SendPendingRollsToPlayer (Player *player, Map *map)
void	SendLootRoll (ObjectGuid SourceGuid, ObjectGuid TargetGuid, uint8 RollNumber, uint8 RollType, Roll const &r, bool autoPass=false)
void	SendLootRollWon (ObjectGuid SourceGuid, ObjectGuid TargetGuid, uint8 RollNumber, uint8 RollType, Roll const &r)
void	SendLootAllPassed (Roll const &roll)
void	SendLooter (Creature *creature, Player *pLooter)
void	GroupLoot (Loot *loot, WorldObject *pLootedObject)
void	NeedBeforeGreed (Loot *loot, WorldObject *pLootedObject)
void	MasterLoot (Loot *loot, WorldObject *pLootedObject)
Rolls::iterator	GetRoll (ObjectGuid Guid)
void	CountTheRoll (Rolls::iterator roll)
bool	CountRollVote (ObjectGuid playerGUID, ObjectGuid Guid, uint8 Choise)
void	EndRoll (Loot *loot)
void	RemovePlayerFromRolls (ObjectGuid guid)
std::vector< Roll const * >	GetRolls () const
void	ResetMaxEnchantingLevel ()
void	LinkMember (GroupReference *pRef)
void	BroadcastGroupUpdate (void)
void	AddLfgBuffFlag ()
void	AddLfgRandomInstanceFlag ()
void	AddLfgHeroicFlag ()
bool	IsLfgWithBuff () const
bool	IsLfgRandomInstance () const
bool	IsLfgHeroic () const
uint32	GetDifficultyChangePreventionTime () const
DifficultyPreventionChangeType	GetDifficultyChangePreventionReason () const
void	SetDifficultyChangePrevention (DifficultyPreventionChangeType type)
void	DoForAllMembers (std::function< void(Player *)> const &worker)

Public Attributes
DataMap	CustomData

Protected Types
typedef MemberSlotList::iterator	member_witerator
typedef std::set< Player * >	InvitesList
typedef std::vector< Roll * >	Rolls

Protected Member Functions
void	_homebindIfInstance (Player *player)
void	_cancelHomebindIfInstance (Player *player)
void	_initRaidSubGroupsCounter ()
member_citerator	_getMemberCSlot (ObjectGuid Guid) const
member_witerator	_getMemberWSlot (ObjectGuid Guid)
void	SubGroupCounterIncrease (uint8 subgroup)
void	SubGroupCounterDecrease (uint8 subgroup)
void	ToggleGroupMemberFlag (member_witerator slot, uint8 flag, bool apply)
void	AddMemberWithGuid (ObjectGuid guid)
void	ForcedDisband (bool hideDestroy=false)

Protected Attributes
MemberSlotList	m_memberSlots
GroupRefMgr	m_memberMgr
InvitesList	m_invitees
ObjectGuid	m_leaderGuid
std::string	m_leaderName
GroupType	m_groupType
Difficulty	m_dungeonDifficulty
Difficulty	m_raidDifficulty
Battlefield *	m_bfGroup
Battleground *	m_bgGroup
ObjectGuid	m_targetIcons [TARGETICONCOUNT]
LootMethod	m_lootMethod
ItemQualities	m_lootThreshold
ObjectGuid	m_looterGuid
ObjectGuid	m_masterLooterGuid
Rolls	RollId
uint8 *	m_subGroupsCounts
ObjectGuid	m_guid
uint32	m_counter
uint32	m_maxEnchantingLevel
uint8	m_lfgGroupFlags
uint32	_difficultyChangePreventionTime
DifficultyPreventionChangeType	_difficultyChangePreventionType

Friends
class	ToCloud9GroupHooks

Detailed Description

request member stats checken todo: uninvite people that not accepted invite

Member Typedef Documentation

InvitesList

typedef std::set<Player*> Group::InvitesList

protected

member_citerator

typedef MemberSlotList::const_iterator Group::member_citerator

member_witerator

typedef MemberSlotList::iterator Group::member_witerator

protected

MemberSlotList

typedef std::list<MemberSlot> Group::MemberSlotList

Rolls

typedef std::vector<Roll*> Group::Rolls

protected

Constructor & Destructor Documentation

Group()

Group::Group

(

)

             : m_leaderName(""), m_groupType(GROUPTYPE_NORMAL),
    m_dungeonDifficulty(DUNGEON_DIFFICULTY_NORMAL), m_raidDifficulty(RAID_DIFFICULTY_10MAN_NORMAL),
    m_bfGroup(nullptr), m_bgGroup(nullptr), m_lootMethod(FREE_FOR_ALL), m_lootThreshold(ITEM_QUALITY_UNCOMMON),
    m_subGroupsCounts(nullptr), m_counter(0), m_maxEnchantingLevel(0), _difficultyChangePreventionTime(0),
    _difficultyChangePreventionType(DIFFICULTY_PREVENTION_CHANGE_NONE)
{
    sScriptMgr->OnConstructGroup(this);
}

References sScriptMgr.

~Group()

Group::~Group

(

)

{
    sScriptMgr->OnDestructGroup(this);
 
    if (m_bgGroup)
    {
        LOG_DEBUG("bg.battleground", "Group::~Group: battleground group being deleted.");
 
        if (m_bgGroup->GetBgRaid(TEAM_ALLIANCE) == this)
        {
            m_bgGroup->SetBgRaid(TEAM_ALLIANCE, nullptr);
        }
        else if (m_bgGroup->GetBgRaid(TEAM_HORDE) == this)
        {
            m_bgGroup->SetBgRaid(TEAM_HORDE, nullptr);
        }
        else
            LOG_ERROR("bg.battleground", "Group::~Group: battleground group is not linked to the correct battleground.");
    }
 
    Rolls::iterator itr;
    while (!RollId.empty())
    {
        itr = RollId.begin();
        Roll* r = *itr;
        RollId.erase(itr);
        delete(r);
    }
 
    // Sub group counters clean up
    delete[] m_subGroupsCounts;
}

References Battleground::GetBgRaid(), LOG_DEBUG, LOG_ERROR, m_bgGroup, m_subGroupsCounts, RollId, Battleground::SetBgRaid(), sScriptMgr, TEAM_ALLIANCE, and TEAM_HORDE.

Member Function Documentation

_cancelHomebindIfInstance()

void Group::_cancelHomebindIfInstance ( Player *  player )

protected

{
    // if player is reinvited to group and in the instance - cancel homebind timer
    if (!player->FindMap() || !player->FindMap()->IsDungeon())
        return;
    InstancePlayerBind* bind = sInstanceSaveMgr->PlayerGetBoundInstance(player->GetGUID(), player->FindMap()->GetId(), player->GetDifficulty(player->FindMap()->IsRaid()));
    if (bind && bind->save->GetInstanceId() == player->GetInstanceId())
        player->m_InstanceValid = true;
}

References WorldObject::FindMap(), Player::GetDifficulty(), Object::GetGUID(), Map::GetId(), WorldObject::GetInstanceId(), InstanceSave::GetInstanceId(), Map::IsDungeon(), Map::IsRaid(), Player::m_InstanceValid, InstancePlayerBind::save, and sInstanceSaveMgr.

Referenced by AddMember().

_getMemberCSlot()

Group::member_citerator Group::_getMemberCSlot ( ObjectGuid  Guid ) const

protected

{
    for (member_citerator itr = m_memberSlots.begin(); itr != m_memberSlots.end(); ++itr)
        if (itr->guid == Guid)
            return itr;
    return m_memberSlots.end();
}

References m_memberSlots.

Referenced by GetMemberGroup(), IsAssistant(), IsMember(), SameSubGroup(), SameSubGroup(), and UpdateLooterGuid().

_getMemberWSlot()

Group::member_witerator Group::_getMemberWSlot ( ObjectGuid  Guid )

protected

{
    for (member_witerator itr = m_memberSlots.begin(); itr != m_memberSlots.end(); ++itr)
        if (itr->guid == Guid)
            return itr;
    return m_memberSlots.end();
}

References m_memberSlots.

Referenced by ChangeLeader(), ChangeMembersGroup(), RemoveMember(), SendUpdateToPlayer(), SetGroupMemberFlag(), and SetLfgRoles().

_homebindIfInstance()

void Group::_homebindIfInstance ( Player *  player )

protected

{
    if (player && !player->IsGameMaster() && player->FindMap() && sMapStore.LookupEntry(player->GetMapId())->IsDungeon())
        player->m_InstanceValid = false;
}

References WorldObject::FindMap(), WorldLocation::GetMapId(), Map::IsDungeon(), Player::IsGameMaster(), Player::m_InstanceValid, and sMapStore.

Referenced by ForcedDisband(), and RemoveMember().

_initRaidSubGroupsCounter()

void Group::_initRaidSubGroupsCounter ( )

protected

{
    // Sub group counters initialization
    if (!m_subGroupsCounts)
        m_subGroupsCounts = new uint8[MAX_RAID_SUBGROUPS];
 
    memset((void*)m_subGroupsCounts, 0, (MAX_RAID_SUBGROUPS)*sizeof(uint8));
 
    for (member_citerator itr = m_memberSlots.begin(); itr != m_memberSlots.end(); ++itr)
        ++m_subGroupsCounts[itr->group];
}

References m_memberSlots, m_subGroupsCounts, and MAX_RAID_SUBGROUPS.

Referenced by ConvertToRaid(), Create(), LoadGroupFromDB(), and ToCloud9GroupHooks::OnGroupCreated().

AddInvite()

bool Group::AddInvite

(

Player *

player

)

{
    if (!player || player->GetGroupInvite())
        return false;
    Group* group = player->GetGroup();
    if (group && (group->isBGGroup() || group->isBFGroup()))
        group = player->GetOriginalGroup();
    if (group)
        return false;
 
    RemoveInvite(player);
 
    m_invitees.insert(player);
 
    player->SetGroupInvite(this);
 
    sScriptMgr->OnGroupInviteMember(this, player->GetGUID());
 
    return true;
}

References Player::GetGroup(), Player::GetGroupInvite(), Object::GetGUID(), Player::GetOriginalGroup(), isBFGroup(), isBGGroup(), m_invitees, RemoveInvite(), Player::SetGroupInvite(), and sScriptMgr.

Referenced by AddLeaderInvite(), and WorldSession::HandleGroupInviteOpcode().

AddLeaderInvite()

bool Group::AddLeaderInvite

(

Player *

player

)

{
    if (!AddInvite(player))
        return false;
 
    m_leaderGuid = player->GetGUID();
    m_leaderName = player->GetName();
    return true;
}

References AddInvite(), Object::GetGUID(), WorldObject::GetName(), m_leaderGuid, and m_leaderName.

Referenced by WorldSession::HandleGroupInviteOpcode().

AddLfgBuffFlag()

void Group::AddLfgBuffFlag ( )

inline

{ m_lfgGroupFlags |= GROUP_LFG_FLAG_APPLY_RANDOM_BUFF; }

References GROUP_LFG_FLAG_APPLY_RANDOM_BUFF, and m_lfgGroupFlags.

Referenced by lfg::LFGMgr::MakeNewGroup().

AddLfgHeroicFlag()

void Group::AddLfgHeroicFlag ( )

inline

{ m_lfgGroupFlags |= GROUP_LFG_FLAG_IS_HEROIC; }

References GROUP_LFG_FLAG_IS_HEROIC, and m_lfgGroupFlags.

Referenced by lfg::LFGMgr::MakeNewGroup().

AddLfgRandomInstanceFlag()

void Group::AddLfgRandomInstanceFlag ( )

inline

{ m_lfgGroupFlags |= GROUP_LFG_FLAG_IS_RANDOM_INSTANCE; }

References GROUP_LFG_FLAG_IS_RANDOM_INSTANCE, and m_lfgGroupFlags.

Referenced by lfg::LFGMgr::MakeNewGroup().

AddMember()

bool Group::AddMember	(	Player *	player,
		uint8	roles = 0
	)

{
    if (!player)
        return false;
 
    // Get first not-full group
    uint8 subGroup = 0;
    if (m_subGroupsCounts)
    {
        bool groupFound = false;
        for (; subGroup < MAX_RAID_SUBGROUPS; ++subGroup)
        {
            if (m_subGroupsCounts[subGroup] < MAXGROUPSIZE)
            {
                groupFound = true;
                break;
            }
        }
        // We are raid group and no one slot is free
        if (!groupFound)
            return false;
    }
 
    MemberSlot member;
    member.guid      = player->GetGUID();
    member.name      = player->GetName();
    member.group     = subGroup;
    member.flags     = 0;
    member.roles     = roles;
    m_memberSlots.push_back(member);
 
    if (!isBGGroup() && !isBFGroup())
    {
        sCharacterCache->UpdateCharacterGroup(player->GetGUID(), GetGUID());
    }
 
    SubGroupCounterIncrease(subGroup);
 
    // The inviting group keeps a raw Player* that would dangle once the player logs out
    if (Group* invitingGroup = player->GetGroupInvite())
        invitingGroup->RemoveInvite(player);
 
    if (player->GetGroup())
    {
        if (isBGGroup() || isBFGroup()) // if player is in group and he is being added to BG raid group, then call SetBattlegroundRaid()
            player->SetBattlegroundOrBattlefieldRaid(this, subGroup);
        else //if player is in bg raid and we are adding him to normal group, then call SetOriginalGroup()
            player->SetOriginalGroup(this, subGroup);
    }
    else //if player is not in group, then call set group
        player->SetGroup(this, subGroup);
 
    // if the same group invites the player back, cancel the homebind timer
    _cancelHomebindIfInstance(player);
 
    if (!isRaidGroup())                                      // reset targetIcons for non-raid-groups
    {
        for (uint8 i = 0; i < TARGETICONCOUNT; ++i)
            m_targetIcons[i].Clear();
    }
 
    if (!isBGGroup() && !isBFGroup())
    {
        CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_REP_GROUP_MEMBER);
        stmt->SetData(0, GetGUID().GetCounter());
        stmt->SetData(1, member.guid.GetCounter());
        stmt->SetData(2, member.flags);
        stmt->SetData(3, member.group);
        stmt->SetData(4, member.roles);
        CharacterDatabase.Execute(stmt);
    }
 
    SendUpdate();
 
    if (player)
    {
        sScriptMgr->OnGroupAddMember(this, player->GetGUID());
 
        if (!IsLeader(player->GetGUID()) && !isBGGroup() && !isBFGroup())
        {
            Player::ResetInstances(player->GetGUID(), INSTANCE_RESET_GROUP_JOIN, false);
 
            if (player->GetDungeonDifficulty() != GetDungeonDifficulty())
            {
                player->SetDungeonDifficulty(GetDungeonDifficulty());
                player->SendDungeonDifficulty(true);
            }
            if (player->GetRaidDifficulty() != GetRaidDifficulty())
            {
                player->SetRaidDifficulty(GetRaidDifficulty());
                player->SendRaidDifficulty(true);
            }
        }
        else if (IsLeader(player->GetGUID()) && isLFGGroup()) // pussywizard
        {
            Player::ResetInstances(player->GetGUID(), INSTANCE_RESET_GROUP_JOIN, false);
        }
 
        player->SetGroupUpdateFlag(GROUP_UPDATE_FULL);
        UpdatePlayerOutOfRange(player);
 
        // quest related GO state dependent from raid membership
        if (isRaidGroup())
            player->UpdateForQuestWorldObjects();
 
        {
            // Broadcast new player group member fields to rest of the group
            player->SetFieldNotifyFlag(UF_FLAG_PARTY_MEMBER);
 
            UpdateData groupData;
            WorldPacket groupDataPacket;
 
            // Broadcast group members' fields to player
            for (GroupReference* itr = GetFirstMember(); itr != nullptr; itr = itr->next())
            {
                if (itr->GetSource() == player) // pussywizard: no check same map, adding members is single threaded
                {
                    continue;
                }
 
                if (Player* itrMember = itr->GetSource())
                {
                    if (player->HaveAtClient(itrMember))
                    {
                        itrMember->SetFieldNotifyFlag(UF_FLAG_PARTY_MEMBER);
                        itrMember->BuildValuesUpdateBlockForPlayer(&groupData, player);
                        itrMember->RemoveFieldNotifyFlag(UF_FLAG_PARTY_MEMBER);
                    }
 
                    if (itrMember->HaveAtClient(player))
                    {
                        UpdateData newData;
                        WorldPacket newDataPacket;
                        player->BuildValuesUpdateBlockForPlayer(&newData, itrMember);
                        if (newData.HasData())
                        {
                            newData.BuildPacket(newDataPacket);
                            itrMember->SendDirectMessage(&newDataPacket);
                        }
                    }
                }
            }
 
            if (groupData.HasData())
            {
                groupData.BuildPacket(groupDataPacket);
                player->SendDirectMessage(&groupDataPacket);
            }
 
            player->RemoveFieldNotifyFlag(UF_FLAG_PARTY_MEMBER);
        }
 
        if (m_maxEnchantingLevel < player->GetSkillValue(SKILL_ENCHANTING))
            m_maxEnchantingLevel = player->GetSkillValue(SKILL_ENCHANTING);
    }
 
    return true;
}

References _cancelHomebindIfInstance(), UpdateData::BuildPacket(), Object::BuildValuesUpdateBlockForPlayer(), CHAR_REP_GROUP_MEMBER, CharacterDatabase, Group::MemberSlot::flags, ObjectGuid::GetCounter(), Player::GetDungeonDifficulty(), GetDungeonDifficulty(), GetFirstMember(), Player::GetGroup(), Player::GetGroupInvite(), GetGUID(), Object::GetGUID(), WorldObject::GetName(), Player::GetRaidDifficulty(), GetRaidDifficulty(), Player::GetSkillValue(), Group::MemberSlot::group, GROUP_UPDATE_FULL, Group::MemberSlot::guid, UpdateData::HasData(), Player::HaveAtClient(), INSTANCE_RESET_GROUP_JOIN, isBFGroup(), isBGGroup(), IsLeader(), isLFGGroup(), isRaidGroup(), m_maxEnchantingLevel, m_memberSlots, m_subGroupsCounts, m_targetIcons, MAX_RAID_SUBGROUPS, MAXGROUPSIZE, Group::MemberSlot::name, GroupReference::next(), Object::RemoveFieldNotifyFlag(), Player::ResetInstances(), Group::MemberSlot::roles, sCharacterCache, Player::SendDirectMessage(), Player::SendDungeonDifficulty(), Player::SendRaidDifficulty(), SendUpdate(), Player::SetBattlegroundOrBattlefieldRaid(), PreparedStatementBase::SetData(), Player::SetDungeonDifficulty(), Object::SetFieldNotifyFlag(), Player::SetGroup(), Player::SetGroupUpdateFlag(), Player::SetOriginalGroup(), Player::SetRaidDifficulty(), SKILL_ENCHANTING, sScriptMgr, SubGroupCounterIncrease(), TARGETICONCOUNT, UF_FLAG_PARTY_MEMBER, Player::UpdateForQuestWorldObjects(), and UpdatePlayerOutOfRange().

Referenced by AddMemberWithGuid(), Battlefield::AddOrSetPlayerToCorrectBfGroup(), Battleground::AddOrSetPlayerToCorrectBgGroup(), Arena::AddPlayer(), Create(), group_commandscript::HandleGroupJoinCommand(), and lfg::LFGMgr::MakeNewGroup().

AddMemberWithGuid()

void Group::AddMemberWithGuid ( ObjectGuid  guid )

protected

{
    // Idempotent under sidecar event redelivery: never duplicate a MemberSlot.
    if (IsMember(guid))
        return;
 
    if (Player* player = ObjectAccessor::FindPlayer(guid))
    {
        AddMember(player);
        return;
    }
 
    // Get first not-full group
    uint8 subGroup = 0;
    if (m_subGroupsCounts)
    {
        bool groupFound = false;
        for (; subGroup < MAX_RAID_SUBGROUPS; ++subGroup)
        {
            if (m_subGroupsCounts[subGroup] < MAXGROUPSIZE)
            {
                groupFound = true;
                break;
            }
        }
        // We are raid group and no one slot is free
        if (!groupFound)
            return;
    }
 
    MemberSlot member;
    member.guid      = guid;
    sCharacterCache->GetCharacterNameByGuid(guid, member.name);
    member.group     = subGroup;
    member.flags     = 0;
    member.roles     = 0;
    m_memberSlots.push_back(member);
 
    if (!isBGGroup() && !isBFGroup())
    {
        sCharacterCache->UpdateCharacterGroup(guid, GetGUID());
    }
 
    SubGroupCounterIncrease(subGroup);
}

References AddMember(), ObjectAccessor::FindPlayer(), Group::MemberSlot::flags, GetGUID(), Group::MemberSlot::group, Group::MemberSlot::guid, isBFGroup(), isBGGroup(), IsMember(), m_memberSlots, m_subGroupsCounts, MAX_RAID_SUBGROUPS, MAXGROUPSIZE, Group::MemberSlot::name, Group::MemberSlot::roles, sCharacterCache, and SubGroupCounterIncrease().

Referenced by ToCloud9GroupHooks::OnGroupCreated().

BroadcastGroupUpdate()

void Group::BroadcastGroupUpdate

(

void

)

{
    // FG: HACK: force flags update on group leave - for values update hack
    // -- not very efficient but safe
    for (member_citerator citr = m_memberSlots.begin(); citr != m_memberSlots.end(); ++citr)
    {
        Player* pp = ObjectAccessor::FindPlayer(citr->guid);
        if (pp)
        {
            pp->ForceValuesUpdateAtIndex(UNIT_FIELD_BYTES_2);
            pp->ForceValuesUpdateAtIndex(UNIT_FIELD_FACTIONTEMPLATE);
            LOG_DEBUG("group", "-- Forced group value update for '{}'", pp->GetName());
        }
    }
}

References ObjectAccessor::FindPlayer(), Object::ForceValuesUpdateAtIndex(), WorldObject::GetName(), LOG_DEBUG, m_memberSlots, UNIT_FIELD_BYTES_2, and UNIT_FIELD_FACTIONTEMPLATE.

Referenced by group_commandscript::HandleGroupJoinCommand(), and RemoveMember().

BroadcastPacket()

void Group::BroadcastPacket	(	WorldPacket const *	packet,
		bool	ignorePlayersInBGRaid,
		int	group = -1,
		ObjectGuid	ignore = ObjectGuid::Empty
	)

{
    for (GroupReference* itr = GetFirstMember(); itr != nullptr; itr = itr->next())
    {
        Player* player = itr->GetSource();
        if (!player || (ignore && player->GetGUID() == ignore) || (ignorePlayersInBGRaid && player->GetGroup() != this))
            continue;
 
        if (group == -1 || itr->getSubGroup() == group)
            player->SendDirectMessage(packet);
    }
}

References GetFirstMember(), Player::GetGroup(), Object::GetGUID(), GroupReference::next(), and Player::SendDirectMessage().

Referenced by ChangeLeader(), DoMinimapPing(), WorldSession::HandleMessagechatOpcode(), WorldSession::HandleRaidReadyCheckFinishedOpcode(), WorldSession::HandleRaidReadyCheckOpcode(), Unit::Kill(), SendLooter(), Player::SendNewItem(), and SetTargetIcon().

BroadcastReadyCheck()

void Group::BroadcastReadyCheck

(

WorldPacket const *

packet

)

{
    for (GroupReference* itr = GetFirstMember(); itr != nullptr; itr = itr->next())
    {
        Player* player = itr->GetSource();
        if (player)
            if (IsLeader(player->GetGUID()) || IsAssistant(player->GetGUID()))
                player->SendDirectMessage(packet);
    }
}

References GetFirstMember(), Object::GetGUID(), IsAssistant(), IsLeader(), GroupReference::next(), and Player::SendDirectMessage().

Referenced by WorldSession::HandleRaidReadyCheckOpcode(), and OfflineReadyCheck().

CanJoinBattlegroundQueue()

GroupJoinBattlegroundResult Group::CanJoinBattlegroundQueue	(	Battleground const *	bgTemplate,
		BattlegroundQueueTypeId	bgQueueTypeId,
		uint32	MinPlayerCount,
		uint32	MaxPlayerCount,
		bool	isRated,
		uint32	arenaSlot
	)

{
    // check if this group is LFG group
    if (isLFGGroup())
        return ERR_LFG_CANT_USE_BATTLEGROUND;
 
    BattlemasterListEntry const* bgEntry = sBattlemasterListStore.LookupEntry(bgTemplate->GetBgTypeID());
    if (!bgEntry)
        return ERR_GROUP_JOIN_BATTLEGROUND_FAIL;
 
    // too many players in the group
    if (GetMembersCount() > bgEntry->maxGroupSize)
        return ERR_BATTLEGROUND_NONE;
 
    // get a player as reference, to compare other players' stats to (arena team id, level bracket, etc.)
    Player* reference = GetFirstMember()->GetSource();
    if (!reference)
        return ERR_BATTLEGROUND_JOIN_FAILED;
 
    PvPDifficultyEntry const* bracketEntry = GetBattlegroundBracketByLevel(bgTemplate->GetMapId(), reference->GetLevel());
    if (!bracketEntry)
        return ERR_BATTLEGROUND_JOIN_FAILED;
 
    uint32 arenaTeamId = reference->GetArenaTeamId(arenaSlot);
    TeamId teamId = reference->GetTeamId();
 
    BattlegroundQueueTypeId bgQueueTypeIdRandom = BattlegroundMgr::BGQueueTypeId(BATTLEGROUND_RB, 0);
 
    // check every member of the group to be able to join
    uint32 memberscount = 0;
    for (GroupReference* itr = GetFirstMember(); itr != nullptr; itr = itr->next(), ++memberscount)
    {
        Player* member = itr->GetSource();
 
        // don't let join with offline members
        if (!member)
            return ERR_BATTLEGROUND_JOIN_FAILED;
 
        if (!sScriptMgr->CanGroupJoinBattlegroundQueue(this, member, bgTemplate, MinPlayerCount, isRated, arenaSlot))
            return ERR_BATTLEGROUND_JOIN_FAILED;
 
        // don't allow cross-faction groups to join queue
        if (member->GetTeamId() != teamId && !sWorld->getBoolConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_GROUP))
            return ERR_BATTLEGROUND_JOIN_TIMED_OUT;
 
        // don't let join rated matches if the arena team id doesn't match
        if (isRated && member->GetArenaTeamId(arenaSlot) != arenaTeamId)
            return ERR_BATTLEGROUND_JOIN_FAILED;
 
        // not in the same battleground level braket, don't let join
        PvPDifficultyEntry const* memberBracketEntry = GetBattlegroundBracketByLevel(bracketEntry->mapId, member->GetLevel());
        if (memberBracketEntry != bracketEntry)
            return ERR_BATTLEGROUND_JOIN_RANGE_INDEX;
 
        // check for deserter debuff in case not arena queue
        if (bgTemplate->GetBgTypeID() != BATTLEGROUND_AA && !member->CanJoinToBattleground(bgTemplate))
            return ERR_GROUP_JOIN_BATTLEGROUND_DESERTERS;
 
        // check if someone in party is using dungeon system
        lfg::LfgState lfgState = sLFGMgr->GetState(member->GetGUID());
        if (lfgState > lfg::LFG_STATE_NONE && (lfgState != lfg::LFG_STATE_QUEUED || !sWorld->getBoolConfig(CONFIG_ALLOW_JOIN_BG_AND_LFG)))
            return ERR_LFG_CANT_USE_BATTLEGROUND;
 
        // pussywizard: prevent joining when any member is in bg/arena
        if (member->InBattleground())
            return ERR_BATTLEGROUND_JOIN_FAILED;
 
        // pussywizard: check for free slot, this is actually ensured before calling this function, but just in case
        if (!member->HasFreeBattlegroundQueueId())
            return ERR_BATTLEGROUND_TOO_MANY_QUEUES;
 
        // don't let join if someone from the group is already in that bg queue
        if (member->InBattlegroundQueueForBattlegroundQueueType(bgQueueTypeId))
            return ERR_BATTLEGROUND_JOIN_FAILED;
 
        // don't let join if someone from the group is in bg queue random
        if (member->InBattlegroundQueueForBattlegroundQueueType(bgQueueTypeIdRandom))
            return ERR_IN_RANDOM_BG;
 
        // don't let join to bg queue random if someone from the group is already in bg queue
        if (bgTemplate->GetBgTypeID() == BATTLEGROUND_RB && member->InBattlegroundQueue())
            return ERR_IN_NON_RANDOM_BG;
 
        // don't let Death Knights join BG queues when they are not allowed to be teleported yet
        if (member->IsClass(CLASS_DEATH_KNIGHT, CLASS_CONTEXT_TELEPORT) && member->GetMapId() == MAP_EBON_HOLD && !member->IsGameMaster() && !member->HasSpell(50977))
            return ERR_GROUP_JOIN_BATTLEGROUND_FAIL;
 
        if (!member->GetBGAccessByLevel(bgTemplate->GetBgTypeID()))
            return ERR_BATTLEGROUND_JOIN_TIMED_OUT;
 
        if (member->HasPlayerFlag(PLAYER_FLAGS_NO_PLAY_TIME)) // Assumed to only apply to full restriction rather than partial
            return ERR_GROUP_JOIN_BATTLEGROUND_FAIL; // ERR_ARENA_EXPIRED_CAIS does not seem to be a result, so using this error instead
    }
 
    // for arenas: check party size is proper
    if (bgTemplate->isArena() && memberscount != MinPlayerCount)
        return ERR_ARENA_TEAM_PARTY_SIZE;
 
    //check against other arena team members
    if (isRated)
    {
        ArenaTeam* arenaTeam = sArenaTeamMgr->GetArenaTeamById(arenaTeamId);
        for (auto const& itr : arenaTeam->GetMembers())
        {
            Player* teamMember = ObjectAccessor::FindConnectedPlayer(itr.Guid);
            //are they online and not a member of this current group?
            if (teamMember && !IsMember(teamMember->GetGUID()))
            {
                //are they already in queue for a rated arena?
                if (teamMember->InBattlegroundQueueForBattlegroundQueueType(bgQueueTypeId))
                {
                    GroupQueueInfo ginfo;
                    BattlegroundQueue& queue = sBattlegroundMgr->GetBattlegroundQueue(bgQueueTypeId);
                    if (queue.GetPlayerGroupInfoData(teamMember->GetGUID(), &ginfo))
                    {
                        if (ginfo.IsRated)
                            return ERR_BATTLEGROUND_JOIN_FAILED;
                    }
                }
                //are they currently in an arena match?
                Battleground* bg = teamMember->GetBattleground(false);
                if (bg && bg->isRated() && bg->GetMinPlayersPerTeam() == MinPlayerCount)
                    return ERR_BATTLEGROUND_JOIN_FAILED;
            }
        }
    }
 
    return GroupJoinBattlegroundResult(bgTemplate->GetBgTypeID());
}

References BATTLEGROUND_AA, BATTLEGROUND_RB, BattlegroundMgr::BGQueueTypeId(), Player::CanJoinToBattleground(), CLASS_CONTEXT_TELEPORT, CLASS_DEATH_KNIGHT, CONFIG_ALLOW_JOIN_BG_AND_LFG, CONFIG_ALLOW_TWO_SIDE_INTERACTION_GROUP, ERR_ARENA_TEAM_PARTY_SIZE, ERR_BATTLEGROUND_JOIN_FAILED, ERR_BATTLEGROUND_JOIN_RANGE_INDEX, ERR_BATTLEGROUND_JOIN_TIMED_OUT, ERR_BATTLEGROUND_NONE, ERR_BATTLEGROUND_TOO_MANY_QUEUES, ERR_GROUP_JOIN_BATTLEGROUND_DESERTERS, ERR_GROUP_JOIN_BATTLEGROUND_FAIL, ERR_IN_NON_RANDOM_BG, ERR_IN_RANDOM_BG, ERR_LFG_CANT_USE_BATTLEGROUND, ObjectAccessor::FindConnectedPlayer(), Player::GetArenaTeamId(), Player::GetBattleground(), GetBattlegroundBracketByLevel(), Player::GetBGAccessByLevel(), Battleground::GetBgTypeID(), GetFirstMember(), Object::GetGUID(), Unit::GetLevel(), Battleground::GetMapId(), WorldLocation::GetMapId(), ArenaTeam::GetMembers(), GetMembersCount(), Battleground::GetMinPlayersPerTeam(), BattlegroundQueue::GetPlayerGroupInfoData(), Reference< TO, FROM >::GetSource(), Player::GetTeamId(), Player::HasFreeBattlegroundQueueId(), Player::HasPlayerFlag(), Player::HasSpell(), Player::InBattleground(), Player::InBattlegroundQueue(), Player::InBattlegroundQueueForBattlegroundQueueType(), Battleground::isArena(), Player::IsClass(), Player::IsGameMaster(), isLFGGroup(), IsMember(), Battleground::isRated(), GroupQueueInfo::IsRated, lfg::LFG_STATE_NONE, lfg::LFG_STATE_QUEUED, MAP_EBON_HOLD, PvPDifficultyEntry::mapId, BattlemasterListEntry::maxGroupSize, GroupReference::next(), PLAYER_FLAGS_NO_PLAY_TIME, sArenaTeamMgr, sBattlegroundMgr, sBattlemasterListStore, sLFGMgr, sScriptMgr, and sWorld.

Referenced by WorldSession::HandleBattlemasterJoinArena(), and WorldSession::HandleBattlemasterJoinOpcode().

ChangeLeader()

void Group::ChangeLeader

(

ObjectGuid

guid

)

{
    member_witerator slot = _getMemberWSlot(newLeaderGuid);
 
    if (slot == m_memberSlots.end())
        return;
 
    Player* newLeader = ObjectAccessor::FindConnectedPlayer(slot->guid);
 
    // Don't allow switching leader to offline players
    if (!newLeader)
        return;
 
    if (!isBGGroup() && !isBFGroup())
    {
        CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
        // Update the group leader
        CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_GROUP_LEADER);
        stmt->SetData(0, newLeader->GetGUID().GetCounter());
        stmt->SetData(1, GetGUID().GetCounter());
        trans->Append(stmt);
        CharacterDatabase.CommitTransaction(trans);
 
        sInstanceSaveMgr->CopyBinds(m_leaderGuid, newLeaderGuid, newLeader);
    }
 
    if (Player* oldLeader = ObjectAccessor::FindConnectedPlayer(m_leaderGuid))
        oldLeader->RemovePlayerFlag(PLAYER_FLAGS_GROUP_LEADER);
 
    newLeader->SetPlayerFlag(PLAYER_FLAGS_GROUP_LEADER);
    ObjectGuid const oldLeaderGuid = m_leaderGuid;
    m_leaderGuid = newLeader->GetGUID();
    m_leaderName = newLeader->GetName();
    ToggleGroupMemberFlag(slot, MEMBER_FLAG_ASSISTANT, false);
 
    WorldPacket data(SMSG_GROUP_SET_LEADER, m_leaderName.size() + 1);
    data << slot->name;
    BroadcastPacket(&data, true);
 
    sScriptMgr->OnGroupChangeLeader(this, newLeaderGuid, oldLeaderGuid); // This hook should be executed at the end
}

References _getMemberWSlot(), BroadcastPacket(), CHAR_UPD_GROUP_LEADER, CharacterDatabase, ObjectAccessor::FindConnectedPlayer(), ObjectGuid::GetCounter(), GetGUID(), Object::GetGUID(), WorldObject::GetName(), isBFGroup(), isBGGroup(), m_leaderGuid, m_leaderName, m_memberSlots, MEMBER_FLAG_ASSISTANT, PLAYER_FLAGS_GROUP_LEADER, PreparedStatementBase::SetData(), Player::SetPlayerFlag(), sInstanceSaveMgr, SMSG_GROUP_SET_LEADER, sScriptMgr, and ToggleGroupMemberFlag().

Referenced by Battleground::AddOrSetPlayerToCorrectBgGroup(), group_commandscript::HandleGroupLeaderCommand(), WorldSession::HandleGroupSetLeaderOpcode(), and RemoveMember().

ChangeMembersGroup()

void Group::ChangeMembersGroup	(	ObjectGuid	guid,
		uint8	group
	)

{
    // Only raid groups have sub groups
    if (!isRaidGroup())
        return;
 
    // Check if player is really in the raid
    member_witerator slot = _getMemberWSlot(guid);
    if (slot == m_memberSlots.end())
        return;
 
    // Abort if the player is already in the target sub group
    uint8 prevSubGroup = GetMemberGroup(guid);
    if (prevSubGroup == group)
        return;
 
    // Update the player slot with the new sub group setting
    slot->group = group;
 
    // Increase the counter of the new sub group..
    SubGroupCounterIncrease(group);
 
    // ..and decrease the counter of the previous one
    SubGroupCounterDecrease(prevSubGroup);
 
    // Preserve new sub group in database for non-raid groups
    if (!isBGGroup() && !isBFGroup())
    {
        CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_GROUP_MEMBER_SUBGROUP);
 
        stmt->SetData(0, group);
        stmt->SetData(1, guid.GetCounter());
 
        CharacterDatabase.Execute(stmt);
    }
 
    // In case the moved player is online, update the player object with the new sub group references
    if (Player* player = ObjectAccessor::FindConnectedPlayer(guid))
    {
        if (player->GetGroup() == this)
            player->GetGroupRef().setSubGroup(group);
        else // If player is in BG raid, it is possible that he is also in normal raid - and that normal raid is stored in m_originalGroup reference
            player->GetOriginalGroupRef().setSubGroup(group);
    }
 
    // Broadcast the changes to the group
    SendUpdate();
}

References _getMemberWSlot(), CHAR_UPD_GROUP_MEMBER_SUBGROUP, CharacterDatabase, ObjectAccessor::FindConnectedPlayer(), ObjectGuid::GetCounter(), GetMemberGroup(), isBFGroup(), isBGGroup(), isRaidGroup(), m_memberSlots, SendUpdate(), PreparedStatementBase::SetData(), SubGroupCounterDecrease(), and SubGroupCounterIncrease().

Referenced by WorldSession::HandleGroupChangeSubGroupOpcode(), and WorldSession::HandleGroupSwapSubGroupOpcode().

CheckLevelForRaid()

bool Group::CheckLevelForRaid

(

)

{
    for (member_citerator citr = m_memberSlots.begin(); citr != m_memberSlots.end(); ++citr)
        if (Player* player = ObjectAccessor::FindPlayer(citr->guid))
            if (player->GetLevel() < sConfigMgr->GetOption<int32>("Group.Raid.LevelRestriction", 10))
                return true;
 
    return false;
}

References ObjectAccessor::FindPlayer(), m_memberSlots, and sConfigMgr.

Referenced by WorldSession::HandleGroupRaidConvertOpcode().

ConvertToLFG()

void Group::ConvertToLFG

(

bool

restricted = true

)

{
    m_groupType = GroupType(m_groupType | GROUPTYPE_LFG);
    if (restricted)
    {
        m_groupType  = GroupType(m_groupType | GROUPTYPE_LFG_RESTRICTED);
        m_lootMethod = NEED_BEFORE_GREED;
    }
 
    if (!isBGGroup() && !isBFGroup())
    {
        CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_GROUP_TYPE);
 
        stmt->SetData(0, uint8(m_groupType));
        stmt->SetData(1, GetGUID().GetCounter());
 
        CharacterDatabase.Execute(stmt);
    }
 
    SendUpdate();
}

References CHAR_UPD_GROUP_TYPE, CharacterDatabase, GetGUID(), GROUPTYPE_LFG, GROUPTYPE_LFG_RESTRICTED, isBFGroup(), isBGGroup(), m_groupType, m_lootMethod, NEED_BEFORE_GREED, SendUpdate(), and PreparedStatementBase::SetData().

Referenced by lfg::LFGMgr::MakeNewGroup().

ConvertToRaid()

void Group::ConvertToRaid

(

)

{
    m_groupType = GroupType(m_groupType | GROUPTYPE_RAID);
 
    _initRaidSubGroupsCounter();
 
    if (!sToCloud9Sidecar->ClusterModeEnabled() && !isBGGroup() && !isBFGroup())
    {
        CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_GROUP_TYPE);
 
        stmt->SetData(0, uint8(m_groupType));
        stmt->SetData(1, GetGUID().GetCounter());
 
        CharacterDatabase.Execute(stmt);
    }
 
    SendUpdate();
 
    // update quest related GO states (quest activity dependent from raid membership)
    for (member_citerator citr = m_memberSlots.begin(); citr != m_memberSlots.end(); ++citr)
        if (Player* player = ObjectAccessor::FindPlayer(citr->guid))
            player->UpdateForQuestWorldObjects();
 
    // pussywizard: client automatically clears df "eye" near minimap, so remove from raid browser
    if (sLFGMgr->GetState(GetLeaderGUID()) == lfg::LFG_STATE_RAIDBROWSER)
        sLFGMgr->LeaveLfg(GetLeaderGUID());
}

References _initRaidSubGroupsCounter(), CHAR_UPD_GROUP_TYPE, CharacterDatabase, ObjectAccessor::FindPlayer(), GetGUID(), GetLeaderGUID(), GROUPTYPE_RAID, isBFGroup(), isBGGroup(), lfg::LFG_STATE_RAIDBROWSER, m_groupType, m_memberSlots, SendUpdate(), PreparedStatementBase::SetData(), sLFGMgr, and sToCloud9Sidecar.

Referenced by WorldSession::HandleGroupRaidConvertOpcode().

CountRollVote()

bool Group::CountRollVote	(	ObjectGuid	playerGUID,
		ObjectGuid	Guid,
		uint8	Choise
	)

{
    Rolls::iterator rollI = GetRoll(Guid);
    if (rollI == RollId.end())
        return false;
    Roll* roll = *rollI;
 
    Roll::PlayerVote::iterator itr = roll->playerVote.find(playerGUID);
    // this condition means that player joins to the party after roll begins
    // Xinef: if choice == MAX_ROLL_TYPE, player was removed from the map in removefromgroup
    // Xinef: itr can be invalid as it is not used below
    if (Choice < MAX_ROLL_TYPE && itr == roll->playerVote.end())
        return false;
 
    if (roll->getLoot())
        if (roll->getLoot()->items.empty())
            return false;
 
    switch (Choice)
    {
        case ROLL_PASS:                                     // Player choose pass
            SendLootRoll(ObjectGuid::Empty, playerGUID, 128, ROLL_PASS, *roll);
            ++roll->totalPass;
            itr->second = PASS;
            break;
        case ROLL_NEED:                                     // player choose Need
            SendLootRoll(ObjectGuid::Empty, playerGUID, 0, 0, *roll);
            ++roll->totalNeed;
            itr->second = NEED;
            break;
        case ROLL_GREED:                                    // player choose Greed
            SendLootRoll(ObjectGuid::Empty, playerGUID, 128, ROLL_GREED, *roll);
            ++roll->totalGreed;
            itr->second = GREED;
            break;
        case ROLL_DISENCHANT:                               // player choose Disenchant
            SendLootRoll(ObjectGuid::Empty, playerGUID, 128, ROLL_DISENCHANT, *roll);
            ++roll->totalGreed;
            itr->second = DISENCHANT;
            break;
    }
 
    if (roll->totalPass + roll->totalNeed + roll->totalGreed >= roll->totalPlayersRolling)
    {
        CountTheRoll(rollI);
        return true;
    }
    return false;
}

References CountTheRoll(), DISENCHANT, ObjectGuid::Empty, Roll::getLoot(), GetRoll(), GREED, Loot::items, NEED, PASS, Roll::playerVote, ROLL_DISENCHANT, ROLL_GREED, ROLL_NEED, ROLL_PASS, RollId, SendLootRoll(), Roll::totalGreed, Roll::totalNeed, Roll::totalPass, and Roll::totalPlayersRolling.

Referenced by WorldSession::HandleLootRoll(), and RemovePlayerFromRolls().

CountTheRoll()

void Group::CountTheRoll

(

Rolls::iterator

roll

)

{
    Roll* roll = *rollI;
    if (!roll->isValid())                                   // is loot already deleted ?
    {
        RollId.erase(rollI);
        delete roll;
        return;
    }
 
    //end of the roll
    if (roll->totalNeed > 0)
    {
        if (!roll->playerVote.empty())
        {
            uint8 maxresul = 0;
            ObjectGuid maxguid; // pussywizard: start with 0 >_>
            Player* player = nullptr;
 
            for (Roll::PlayerVote::const_iterator itr = roll->playerVote.begin(); itr != roll->playerVote.end(); ++itr)
            {
                if (itr->second != NEED)
                    continue;
 
                player = ObjectAccessor::FindPlayer(itr->first);
                if (!player)
                {
                    --roll->totalNeed;
                    continue;
                }
 
                uint8 randomN = urand(1, 100);
                SendLootRoll(ObjectGuid::Empty, itr->first, randomN, ROLL_NEED, *roll);
                if (maxresul < randomN)
                {
                    maxguid  = itr->first;
                    maxresul = randomN;
                }
            }
 
            if (maxguid) // pussywizard: added condition
            {
                SendLootRollWon(roll->itemGUID, maxguid, maxresul, ROLL_NEED, *roll);
                player = ObjectAccessor::FindPlayer(maxguid);
 
                if (player)
                {
                    player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_ROLL_NEED_ON_LOOT, roll->itemid, maxresul);
 
                    ItemPosCountVec dest;
                    LootItem* item = &(roll->itemSlot >= roll->getLoot()->items.size() ? roll->getLoot()->quest_items[roll->itemSlot - roll->getLoot()->items.size()] : roll->getLoot()->items[roll->itemSlot]);
                    InventoryResult msg = player->CanStoreNewItem(NULL_BAG, NULL_SLOT, dest, roll->itemid, item->count);
                    if (msg == EQUIP_ERR_OK)
                    {
                        item->is_looted = true;
                        roll->getLoot()->NotifyItemRemoved(roll->itemSlot);
                        roll->getLoot()->unlootedCount--;
                        AllowedLooterSet looters = item->GetAllowedLooters();
                        Item* _item = player->StoreNewItem(dest, roll->itemid, true, item->randomPropertyId, looters);
                        if (_item)
                            sScriptMgr->OnPlayerGroupRollRewardItem(player, _item, item->count, NEED, roll);
                        player->UpdateLootAchievements(item, roll->getLoot());
                    }
                    else
                    {
                        if (ShouldMailRollWonItem(this, roll, msg))
                        {
                            item->is_looted = true;
                            roll->getLoot()->NotifyItemRemoved(roll->itemSlot);
                            roll->getLoot()->unlootedCount--;
                            player->SendEquipError(msg, nullptr, nullptr, roll->itemid);
                            SendRollWonItemViaMail(player, item, roll->itemid);
                        }
                        else
                        {
                            item->is_blocked = false;
                            item->rollWinnerGUID = player->GetGUID();
                            player->SendEquipError(msg, nullptr, nullptr, roll->itemid);
                        }
                    }
                }
            }
            else
                roll->totalNeed = 0;
        }
    }
    if (roll->totalNeed == 0 && roll->totalGreed > 0) // if (roll->totalNeed == 0 && ...), not else if, because totalNeed can be decremented above when a needing player is offline
    {
        if (!roll->playerVote.empty())
        {
            uint8 maxresul = 0;
            ObjectGuid maxguid; // pussywizard: start with 0
            Player* player = nullptr;
            RollVote rollvote = NOT_VALID;
 
            Roll::PlayerVote::iterator itr;
            for (itr = roll->playerVote.begin(); itr != roll->playerVote.end(); ++itr)
            {
                if (itr->second != GREED && itr->second != DISENCHANT)
                    continue;
 
                player = ObjectAccessor::FindPlayer(itr->first);
                if (!player)
                {
                    --roll->totalGreed;
                    continue;
                }
 
                uint8 randomN = urand(1, 100);
                SendLootRoll(ObjectGuid::Empty, itr->first, randomN, itr->second, *roll);
                if (maxresul < randomN)
                {
                    maxguid  = itr->first;
                    maxresul = randomN;
                    rollvote = itr->second;
                }
            }
 
            if (maxguid) // pussywizard: added condition
            {
                SendLootRollWon(roll->itemGUID, maxguid, maxresul, rollvote, *roll);
                player = ObjectAccessor::FindPlayer(maxguid);
 
                if (player)
                {
                    player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_ROLL_GREED_ON_LOOT, roll->itemid, maxresul);
 
                    LootItem* item = &(roll->itemSlot >= roll->getLoot()->items.size() ? roll->getLoot()->quest_items[roll->itemSlot - roll->getLoot()->items.size()] : roll->getLoot()->items[roll->itemSlot]);
 
                    if (rollvote == GREED)
                    {
                        ItemPosCountVec dest;
                        InventoryResult msg = player->CanStoreNewItem(NULL_BAG, NULL_SLOT, dest, roll->itemid, item->count);
                        if (msg == EQUIP_ERR_OK)
                        {
                            item->is_looted = true;
                            roll->getLoot()->NotifyItemRemoved(roll->itemSlot);
                            roll->getLoot()->unlootedCount--;
                            AllowedLooterSet looters = item->GetAllowedLooters();
                            Item* _item = player->StoreNewItem(dest, roll->itemid, true, item->randomPropertyId, looters);
                            if (_item)
                                sScriptMgr->OnPlayerGroupRollRewardItem(player, _item, item->count, GREED, roll);
                            player->UpdateLootAchievements(item, roll->getLoot());
                        }
                        else
                        {
                            if (ShouldMailRollWonItem(this, roll, msg))
                            {
                                item->is_looted = true;
                                roll->getLoot()->NotifyItemRemoved(roll->itemSlot);
                                roll->getLoot()->unlootedCount--;
                                player->SendEquipError(msg, nullptr, nullptr, roll->itemid);
                                SendRollWonItemViaMail(player, item, roll->itemid);
                            }
                            else
                            {
                                item->is_blocked = false;
                                item->rollWinnerGUID = player->GetGUID();
                                player->SendEquipError(msg, nullptr, nullptr, roll->itemid);
                            }
                        }
                    }
                    else if (rollvote == DISENCHANT)
                    {
                        item->is_looted = true;
                        roll->getLoot()->NotifyItemRemoved(roll->itemSlot);
                        roll->getLoot()->unlootedCount--;
                        ItemTemplate const* pProto = sObjectMgr->GetItemTemplate(roll->itemid);
                        player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_CAST_SPELL, 13262); // Disenchant
 
                        ItemPosCountVec dest;
                        InventoryResult msg = player->CanStoreNewItem(NULL_BAG, NULL_SLOT, dest, roll->itemid, item->count);
 
                        if (msg == EQUIP_ERR_OK)
                        {
                            player->AutoStoreLoot(pProto->DisenchantID, LootTemplates_Disenchant, true);
                        }
                        else
                        {
                            Loot loot;
                            loot.FillLoot(pProto->DisenchantID, LootTemplates_Disenchant, player, true);
 
                            uint32 max_slot = loot.GetMaxSlotInLootFor(player);
                            for(uint32 i = 0; i < max_slot; i++)
                            {
                                LootItem* lootItem = loot.LootItemInSlot(i, player);
                                player->SendEquipError(msg, nullptr, nullptr, lootItem->itemid);
                                player->SendItemRetrievalMail(lootItem->itemid, lootItem->count);
                            }
                        }
                    }
                }
            }
            else
                roll->totalGreed = 0;
        }
    }
    if (roll->totalNeed == 0 && roll->totalGreed == 0) // if, not else, because the totals can be decremented above when a rolling player is offline
    {
        SendLootAllPassed(*roll);
 
        // remove is_blocked so that the item is lootable by all players
        LootItem* item = &(roll->itemSlot >= roll->getLoot()->items.size() ? roll->getLoot()->quest_items[roll->itemSlot - roll->getLoot()->items.size()] : roll->getLoot()->items[roll->itemSlot]);
        if (item)
            item->is_blocked = false;
    }
 
    if (Loot* loot = roll->getLoot(); loot && loot->isLooted() && loot->sourceGameObject)
    {
        GameObjectTemplate const* goInfo = loot->sourceGameObject->GetGOInfo();
        if (goInfo && goInfo->type == GAMEOBJECT_TYPE_CHEST)
        {
            // Deactivate chest if the last item was rolled in group
            loot->sourceGameObject->SetLootState(GO_JUST_DEACTIVATED);
        }
    }
 
    RollId.erase(rollI);
    delete roll;
}

References ACHIEVEMENT_CRITERIA_TYPE_CAST_SPELL, ACHIEVEMENT_CRITERIA_TYPE_ROLL_GREED_ON_LOOT, ACHIEVEMENT_CRITERIA_TYPE_ROLL_NEED_ON_LOOT, Player::AutoStoreLoot(), Player::CanStoreNewItem(), LootItem::count, DISENCHANT, ItemTemplate::DisenchantID, ObjectGuid::Empty, EQUIP_ERR_OK, Loot::FillLoot(), ObjectAccessor::FindPlayer(), GAMEOBJECT_TYPE_CHEST, LootItem::GetAllowedLooters(), Object::GetGUID(), Roll::getLoot(), Loot::GetMaxSlotInLootFor(), GO_JUST_DEACTIVATED, GREED, LootItem::is_blocked, LootItem::is_looted, Loot::isLooted(), Reference< TO, FROM >::isValid(), Roll::itemGUID, Roll::itemid, LootItem::itemid, Loot::items, Roll::itemSlot, Loot::LootItemInSlot(), LootTemplates_Disenchant, NEED, NOT_VALID, Loot::NotifyItemRemoved(), NULL_BAG, NULL_SLOT, Roll::playerVote, Loot::quest_items, LootItem::randomPropertyId, ROLL_NEED, RollId, LootItem::rollWinnerGUID, Player::SendEquipError(), Player::SendItemRetrievalMail(), SendLootAllPassed(), SendLootRoll(), SendLootRollWon(), SendRollWonItemViaMail(), ShouldMailRollWonItem(), sObjectMgr, sScriptMgr, Player::StoreNewItem(), Roll::totalGreed, Roll::totalNeed, GameObjectTemplate::type, Loot::unlootedCount, Player::UpdateAchievementCriteria(), Player::UpdateLootAchievements(), and urand().

Referenced by CountRollVote(), EndRoll(), and ForcedDisband().

Create()

bool Group::Create

(

Player *

leader

)

{
    ObjectGuid leaderGuid = leader->GetGUID();
    ObjectGuid::LowType lowguid = sGroupMgr->GenerateGroupId();
 
    m_guid = ObjectGuid::Create<HighGuid::Group>(lowguid);
    m_leaderGuid = leaderGuid;
    m_leaderName = leader->GetName();
    leader->SetPlayerFlag(PLAYER_FLAGS_GROUP_LEADER);
 
    if (isBGGroup() || isBFGroup())
        m_groupType = GROUPTYPE_BGRAID;
 
    if (m_groupType & GROUPTYPE_RAID)
        _initRaidSubGroupsCounter();
 
    if (!isLFGGroup())
        m_lootMethod = GROUP_LOOT;
 
    m_lootThreshold = ITEM_QUALITY_UNCOMMON;
    m_looterGuid = leaderGuid;
    m_masterLooterGuid.Clear();
 
    m_dungeonDifficulty = DUNGEON_DIFFICULTY_NORMAL;
    m_raidDifficulty = RAID_DIFFICULTY_10MAN_NORMAL;
 
    if (!isBGGroup() && !isBFGroup())
    {
        m_dungeonDifficulty = leader->GetDungeonDifficulty();
        m_raidDifficulty = leader->GetRaidDifficulty();
 
        // Store group in database
        CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_GROUP);
 
        uint8 index = 0;
 
        stmt->SetData(index++, lowguid);
        stmt->SetData(index++, m_leaderGuid.GetCounter());
        stmt->SetData(index++, uint8(m_lootMethod));
        stmt->SetData(index++, m_looterGuid.GetCounter());
        stmt->SetData(index++, uint8(m_lootThreshold));
        stmt->SetData(index++, m_targetIcons[0].GetRawValue());
        stmt->SetData(index++, m_targetIcons[1].GetRawValue());
        stmt->SetData(index++, m_targetIcons[2].GetRawValue());
        stmt->SetData(index++, m_targetIcons[3].GetRawValue());
        stmt->SetData(index++, m_targetIcons[4].GetRawValue());
        stmt->SetData(index++, m_targetIcons[5].GetRawValue());
        stmt->SetData(index++, m_targetIcons[6].GetRawValue());
        stmt->SetData(index++, m_targetIcons[7].GetRawValue());
        stmt->SetData(index++, uint8(m_groupType));
        stmt->SetData(index++, uint8(m_dungeonDifficulty));
        stmt->SetData(index++, uint8(m_raidDifficulty));
        stmt->SetData(index++, m_masterLooterGuid.GetCounter());
 
        CharacterDatabase.Execute(stmt);
 
        ASSERT(AddMember(leader)); // If the leader can't be added to a new group because it appears full, something is clearly wrong.
 
        sScriptMgr->OnCreate(this, leader);
    }
    else if (!AddMember(leader))
        return false;
 
    return true;
}

References _initRaidSubGroupsCounter(), AddMember(), ASSERT, CHAR_INS_GROUP, CharacterDatabase, ObjectGuid::Clear(), DUNGEON_DIFFICULTY_NORMAL, ObjectGuid::GetCounter(), Player::GetDungeonDifficulty(), Object::GetGUID(), WorldObject::GetName(), Player::GetRaidDifficulty(), GROUP_LOOT, GROUPTYPE_BGRAID, GROUPTYPE_RAID, isBFGroup(), isBGGroup(), isLFGGroup(), ITEM_QUALITY_UNCOMMON, m_dungeonDifficulty, m_groupType, m_guid, m_leaderGuid, m_leaderName, m_looterGuid, m_lootMethod, m_lootThreshold, m_masterLooterGuid, m_raidDifficulty, m_targetIcons, PLAYER_FLAGS_GROUP_LEADER, RAID_DIFFICULTY_10MAN_NORMAL, PreparedStatementBase::SetData(), Player::SetPlayerFlag(), sGroupMgr, and sScriptMgr.

Referenced by Battlefield::AddOrSetPlayerToCorrectBfGroup(), Battleground::AddOrSetPlayerToCorrectBgGroup(), Arena::AddPlayer(), and lfg::LFGMgr::MakeNewGroup().

Disband()

void Group::Disband

(

bool

hideDestroy = false

)

{
    if (sToCloud9Sidecar->ClusterModeEnabled() && !this->isBFGroup() && !this->isBGGroup())
        return;
 
    ForcedDisband(hideDestroy);
}

References ForcedDisband(), and sToCloud9Sidecar.

Referenced by Arena::AddPlayer(), group_commandscript::HandleGroupDisbandCommand(), WorldSession::HandleGroupDisbandOpcode(), RemoveMember(), and Player::UninviteFromGroup().

DoForAllMembers()

void Group::DoForAllMembers

(

std::function< void(Player *)> const &

worker

)

{
    for (GroupReference* itr = GetFirstMember(); itr != nullptr; itr = itr->next())
    {
        Player* member = itr->GetSource();
        if (!member)
            continue;
 
        worker(member);
    }
}

References GetFirstMember(), and GroupReference::next().

Referenced by BattlegroundQueue::AddGroup(), WorldSession::HandleBattlemasterJoinArena(), and WorldSession::HandleBattlemasterJoinOpcode().

DoMinimapPing()

void Group::DoMinimapPing	(	ObjectGuid	sourceGuid,
		float	mapX,
		float	mapY
	)

{
    WorldPackets::Misc::MinimapPing minimapPing;
    minimapPing.SourceGuid = sourceGuid;
    minimapPing.MapX = mapX;
    minimapPing.MapY = mapY;
 
    BroadcastPacket(minimapPing.Write(), true, -1, sourceGuid);
}

References BroadcastPacket(), WorldPackets::Misc::MinimapPing::MapX, WorldPackets::Misc::MinimapPing::MapY, WorldPackets::Misc::MinimapPing::SourceGuid, and WorldPackets::Misc::MinimapPing::Write().

Referenced by WorldSession::HandleMinimapPingOpcode().

EndRoll()

void Group::EndRoll

(

Loot *

loot

)

{
    for (Rolls::iterator itr = RollId.begin(); itr != RollId.end();)
    {
        if ((*itr)->getLoot() == pLoot)
        {
            Roll* roll = *itr;
            for (auto& [playerGuid, vote] : roll->playerVote)
            {
                if (vote != NOT_EMITED_YET)
                    continue;
 
                vote = PASS;
                ++roll->totalPass;
                SendLootRoll(roll->itemGUID, playerGuid, 128, ROLL_PASS, *roll);
            }
 
            CountTheRoll(itr);
            itr = RollId.begin();
        }
        else
            ++itr;
    }
}

References CountTheRoll(), Roll::itemGUID, NOT_EMITED_YET, PASS, Roll::playerVote, ROLL_PASS, RollId, SendLootRoll(), and Roll::totalPass.

Referenced by GameObject::Update(), and Creature::Update().

ForcedDisband()

void Group::ForcedDisband ( bool  hideDestroy = false )

protected

{
    sScriptMgr->OnGroupDisband(this);
 
    // Settle open rolls: only CountTheRoll unblocks a rolled item, and the looted object's roll timer
    // can't once the group is gone, so the item would stay locked
    while (!RollId.empty())
        CountTheRoll(RollId.begin());
 
    Player* player;
    uint32 instanceId = 0;
 
    for (member_citerator citr = m_memberSlots.begin(); citr != m_memberSlots.end(); ++citr)
    {
        if (!isBGGroup() && !isBFGroup())
        {
            sCharacterCache->ClearCharacterGroup(citr->guid);
        }
 
        player = ObjectAccessor::FindConnectedPlayer(citr->guid);
 
        if (player && !instanceId && !isBGGroup() && !isBFGroup())
        {
            instanceId = player->GetInstanceId();
        }
 
        _homebindIfInstance(player);
        if (!isBGGroup() && !isBFGroup())
            Player::ResetInstances(citr->guid, INSTANCE_RESET_GROUP_LEAVE, false);
 
        if (!player)
            continue;
 
        //we cannot call _removeMember because it would invalidate member iterator
        //if we are removing player from battleground raid
        if (isBGGroup() || isBFGroup())
            player->RemoveFromBattlegroundOrBattlefieldRaid();
        else
        {
            //we can remove player who is in battleground from his original group
            if (player->GetOriginalGroup() == this)
                player->SetOriginalGroup(nullptr);
            else
                player->SetGroup(nullptr);
        }
 
        // quest related GO state dependent from raid membership
        if (isRaidGroup())
            player->UpdateForQuestWorldObjects();
 
        WorldPacket data;
        if (!hideDestroy)
        {
            data.Initialize(SMSG_GROUP_DESTROYED, 0);
            player->SendDirectMessage(&data);
        }
 
        //we already removed player from group and in player->GetGroup() is his original group, send update
        if (Group* group = player->GetGroup())
        {
            group->SendUpdate();
        }
        else
        {
            data.Initialize(SMSG_GROUP_LIST, 1 + 1 + 1 + 1 + 8 + 4 + 4 + 8);
            data << uint8(0x10) << uint8(0) << uint8(0) << uint8(0);
            data << m_guid << uint32(m_counter) << uint32(0) << uint64(0);
            player->SendDirectMessage(&data);
        }
    }
    RollId.clear();
    m_memberSlots.clear();
 
    RemoveAllInvites();
 
    if (!isBGGroup() && !isBFGroup())
    {
        CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
 
        CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GROUP);
        stmt->SetData(0, GetGUID().GetCounter());
        trans->Append(stmt);
 
        stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GROUP_MEMBER_ALL);
        stmt->SetData(0, GetGUID().GetCounter());
        trans->Append(stmt);
 
        CharacterDatabase.CommitTransaction(trans);
 
        stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_LFG_DATA);
        stmt->SetData(0, GetGUID().GetCounter());
        CharacterDatabase.Execute(stmt);
    }
 
    // Cleaning up instance saved data for gameobjects when a group is disbanded
    sInstanceSaveMgr->DeleteInstanceSavedData(instanceId);
 
    sGroupMgr->RemoveGroup(this);
    delete this;
}

References _homebindIfInstance(), CHAR_DEL_GROUP, CHAR_DEL_GROUP_MEMBER_ALL, CHAR_DEL_LFG_DATA, CharacterDatabase, CountTheRoll(), ObjectAccessor::FindConnectedPlayer(), Player::GetGroup(), GetGUID(), WorldObject::GetInstanceId(), Player::GetOriginalGroup(), WorldPacket::Initialize(), INSTANCE_RESET_GROUP_LEAVE, isBFGroup(), isBGGroup(), isRaidGroup(), m_counter, m_guid, m_memberSlots, RemoveAllInvites(), Player::RemoveFromBattlegroundOrBattlefieldRaid(), Player::ResetInstances(), RollId, sCharacterCache, Player::SendDirectMessage(), PreparedStatementBase::SetData(), Player::SetGroup(), Player::SetOriginalGroup(), sGroupMgr, sInstanceSaveMgr, SMSG_GROUP_DESTROYED, SMSG_GROUP_LIST, sScriptMgr, and Player::UpdateForQuestWorldObjects().

Referenced by Disband().

GetDifficulty()

Difficulty Group::GetDifficulty

(

bool

isRaid

)

const

{
    return isRaid ? m_raidDifficulty : m_dungeonDifficulty;
}

References m_dungeonDifficulty, and m_raidDifficulty.

Referenced by MapInstanced::CreateInstanceForPlayer().

GetDifficultyChangePreventionReason()

DifficultyPreventionChangeType Group::GetDifficultyChangePreventionReason ( ) const

inline

{ return _difficultyChangePreventionType; }

References _difficultyChangePreventionType.

Referenced by WorldSession::HandleSetRaidDifficultyOpcode().

GetDifficultyChangePreventionTime()

uint32 Group::GetDifficultyChangePreventionTime

(

)

const

{
    return _difficultyChangePreventionTime > GameTime::GetGameTime().count() ? _difficultyChangePreventionTime - GameTime::GetGameTime().count() : 0;
}

References _difficultyChangePreventionTime, and GameTime::GetGameTime().

Referenced by WorldSession::HandleSetRaidDifficultyOpcode().

GetDungeonDifficulty()

Difficulty Group::GetDungeonDifficulty

(

)

const

{
    return m_dungeonDifficulty;
}

References m_dungeonDifficulty.

Referenced by AddMember().

GetFirstMember() [1/2]

GroupReference * Group::GetFirstMember ( )

inline

{ return m_memberMgr.getFirst(); }

References GroupRefMgr::getFirst(), and m_memberMgr.

Referenced by KillRewarder::_InitGroupData(), KillRewarder::_RewardGroup(), AddMember(), BroadcastPacket(), BroadcastReadyCheck(), CanJoinBattlegroundQueue(), Player::CanUninviteFromGroup(), DoForAllMembers(), Loot::FillLoot(), Player::GetNextRandomRaidMember(), Unit::GetNextRandomRaidMemberOrPet(), Unit::GetPartyMembers(), GroupLoot(), Unit::HandleAuraRaidProcFromChargeWithValue(), WorldSession::HandleBattlemasterJoinArena(), group_commandscript::HandleGroupReviveCommand(), misc_commandscript::HandleGroupSummonCommand(), lfg_commandscript::HandleLfgGroupInfoCommand(), WorldSession::HandleLfgPartyLockInfoRequestOpcode(), WorldSession::HandleLootMoneyOpcode(), WorldSession::HandleSetDungeonDifficultyOpcode(), WorldSession::HandleSetRaidDifficultyOpcode(), tele_commandscript::HandleTeleGroupCommand(), lfg::LFGMgr::JoinLfg(), npc_darnavan::npc_darnavanAI::JustDied(), lfg::LFGMgr::MakeNewGroup(), MasterLoot(), NeedBeforeGreed(), lfg::LFGPlayerScript::OnPlayerMapChanged(), Player::SelectCharmedAIGroupTarget(), SetDungeonDifficulty(), SetRaidDifficulty(), PetAI::UpdateAllies(), and UpdatePlayerOutOfRange().

GetFirstMember() [2/2]

GroupReference const * Group::GetFirstMember ( ) const

inline

{ return m_memberMgr.getFirst(); }

References GroupRefMgr::getFirst(), and m_memberMgr.

GetGroupType()

GroupType Group::GetGroupType

(

)

const

{
    return m_groupType;
}

References m_groupType.

GetGUID()

ObjectGuid Group::GetGUID

(

)

const

{
    return m_guid;
}

References m_guid.

Referenced by GroupMgr::AddGroup(), AddMember(), AddMemberWithGuid(), Battlefield::AddOrSetPlayerToCorrectBfGroup(), npc_coren_direbrew::CanBeSeen(), go_loosely_turned_soil::go_loosely_turned_soilAI::CanBeSeen(), Player::CanUninviteFromGroup(), ChangeLeader(), ConvertToLFG(), ConvertToRaid(), ArenaTeam::DelMember(), ForcedDisband(), GroupLoot(), lfg_commandscript::HandleLfgGroupInfoCommand(), WorldSession::HandleLfgLeaveOpcode(), WorldSession::HandleLfgSetRolesOpcode(), lfg::LFGMgr::JoinLfg(), boss_headless_horseman::JustDied(), LoadGroupFromDB(), GroupMgr::LoadGroups(), LoadMemberFromDB(), lfg::LFGMgr::MakeNewGroup(), NeedBeforeGreed(), lfg::LFGGroupScript::OnAddMember(), lfg::LFGGroupScript::OnChangeLeader(), lfg::LFGGroupScript::OnDisband(), ToCloud9GroupHooks::OnGroupCreated(), lfg::LFGGroupScript::OnInviteMember(), lfg::LFGPlayerScript::OnPlayerLogin(), lfg::LFGPlayerScript::OnPlayerLogout(), lfg::LFGGroupScript::OnRemoveMember(), MapMgr::PlayerCannotEnter(), GroupMgr::RemoveGroup(), RemoveMember(), SetDungeonDifficulty(), GameObject::SetLootRecipient(), SetRaidDifficulty(), lfg::LFGMgr::TeleportPlayer(), and lfg::LFGMgr::UpdateRaidBrowser().

GetInvited() [1/2]

Player * Group::GetInvited

(

ObjectGuid

guid

)

const

{
    for (InvitesList::const_iterator itr = m_invitees.begin(); itr != m_invitees.end(); ++itr)
    {
        if ((*itr) && (*itr)->GetGUID() == guid)
            return (*itr);
    }
    return nullptr;
}

References m_invitees.

Referenced by WorldSession::HandleGroupUninviteGuidOpcode(), and WorldSession::HandleGroupUninviteOpcode().

GetInvited() [2/2]

Player * Group::GetInvited

(

std::string const &

name

)

const

{
    for (InvitesList::const_iterator itr = m_invitees.begin(); itr != m_invitees.end(); ++itr)
    {
        if ((*itr) && (*itr)->GetName() == name)
            return (*itr);
    }
    return nullptr;
}

References m_invitees.

GetInviteeCount()

uint32 Group::GetInviteeCount ( ) const

inline

{ return m_invitees.size(); }

References m_invitees.

Referenced by Player::UninviteFromGroup().

GetLeader()

Player * Group::GetLeader

(

)

{
    return ObjectAccessor::FindConnectedPlayer(m_leaderGuid);
}

References ObjectAccessor::FindConnectedPlayer(), and m_leaderGuid.

GetLeaderGUID()

ObjectGuid Group::GetLeaderGUID

(

)

const

{
    return m_leaderGuid;
}

References m_leaderGuid.

Referenced by ConvertToRaid(), WorldSession::HandleBattlemasterJoinArena(), WorldSession::HandleBattlemasterJoinOpcode(), WorldSession::HandleGroupDeclineOpcode(), WorldSession::HandleGroupDisbandOpcode(), WorldSession::HandleGroupInviteOpcode(), group_commandscript::HandleGroupLeaderCommand(), misc_commandscript::HandleGroupSummonCommand(), WorldSession::HandleLfgLeaveOpcode(), misc_commandscript::HandleSummonCommand(), lfg::LFGMgr::InitializeLockedDungeons(), IsLeader(), lfg::LFGMgr::JoinLfg(), lfg::LFGMgr::MakeNewGroup(), lfg::LFGGroupScript::OnAddMember(), lfg::LFGGroupScript::OnDisband(), lfg::LFGGroupScript::OnInviteMember(), RemoveMember(), and Player::Satisfy().

GetLeaderName()

char const * Group::GetLeaderName

(

)

const

{
    return m_leaderName.c_str();
}

References m_leaderName.

Referenced by ChatLogScript::OnPlayerCanUseChat(), and Player::Satisfy().

GetLooterGuid()

ObjectGuid Group::GetLooterGuid

(

)

const

{
    return m_looterGuid;
}

References m_looterGuid.

Referenced by Unit::Kill(), and UpdateLooterGuid().

GetLootMethod()

LootMethod Group::GetLootMethod

(

)

const

{
    return m_lootMethod;
}

References m_lootMethod.

Referenced by Loot::FillQuestLoot(), WorldSession::HandleLootMasterGiveOpcode(), Player::isAllowedToLoot(), Unit::Kill(), Player::SendLoot(), SendLooter(), SendPendingRollsToPlayer(), and UpdateLooterGuid().

GetLootThreshold()

ItemQualities Group::GetLootThreshold

(

)

const

{
    return m_lootThreshold;
}

References m_lootThreshold.

Referenced by Loot::FillLoot().

GetMasterLooterGuid()

ObjectGuid Group::GetMasterLooterGuid

(

)

const

{
    return m_masterLooterGuid;
}

References m_masterLooterGuid.

Referenced by Loot::FillQuestLoot(), WorldSession::HandleLootMasterGiveOpcode(), Player::SendLoot(), and SendLooter().

GetMemberGroup()

uint8 Group::GetMemberGroup

(

ObjectGuid

guid

)

const

{
    member_citerator mslot = _getMemberCSlot(guid);
    if (mslot == m_memberSlots.end())
        return (MAX_RAID_SUBGROUPS + 1);
    return mslot->group;
}

References _getMemberCSlot(), m_memberSlots, and MAX_RAID_SUBGROUPS.

Referenced by Battlefield::AddOrSetPlayerToCorrectBfGroup(), Battleground::AddOrSetPlayerToCorrectBgGroup(), ChangeMembersGroup(), WorldSession::HandleGroupSwapSubGroupOpcode(), WorldSession::HandleMessagechatOpcode(), and Unit::Kill().

GetMemberGUID()

ObjectGuid Group::GetMemberGUID

(

std::string const &

name

)

{
    for (member_citerator itr = m_memberSlots.begin(); itr != m_memberSlots.end(); ++itr)
        if (itr->name == name)
            return itr->guid;
 
    return ObjectGuid::Empty;
}

References ObjectGuid::Empty, and m_memberSlots.

Referenced by WorldSession::HandleGroupSwapSubGroupOpcode(), and WorldSession::HandleGroupUninviteOpcode().

GetMembersCount()

uint32 Group::GetMembersCount ( ) const

inline

{ return m_memberSlots.size(); }

References m_memberSlots.

Referenced by CanJoinBattlegroundQueue(), Player::CanUninviteFromGroup(), Player::GetNextRandomRaidMember(), Unit::GetNextRandomRaidMemberOrPet(), WorldSession::HandleBattlemasterJoinOpcode(), group_commandscript::HandleGroupListCommand(), WorldSession::HandleGroupRaidConvertOpcode(), misc_commandscript::HandleSkirmishCommand(), IsCreated(), lfg::LFGMgr::JoinLfg(), lfg::LFGMgr::MakeNewGroup(), RemoveMember(), SendUpdateToPlayer(), Player::UninviteFromGroup(), and PetAI::UpdateAllies().

GetMemberSlots()

MemberSlotList const & Group::GetMemberSlots ( ) const

inline

{ return m_memberSlots; }

References m_memberSlots.

Referenced by Arena::AddPlayer(), group_commandscript::HandleGroupListCommand(), and lfg::LFGMgr::UpdateRaidBrowser().

GetRaidDifficulty()

Difficulty Group::GetRaidDifficulty

(

)

const

{
    return m_raidDifficulty;
}

References m_raidDifficulty.

Referenced by AddMember().

GetRoll()

Group::Rolls::iterator Group::GetRoll

(

ObjectGuid

Guid

)

{
    Rolls::iterator iter;
    for (iter = RollId.begin(); iter != RollId.end(); ++iter)
        if ((*iter)->itemGUID == Guid && (*iter)->isValid())
            return iter;
    return RollId.end();
}

References RollId.

Referenced by CountRollVote().

GetRolls()

std::vector< Roll const * > Group::GetRolls ( ) const

inline

{ return { RollId.begin(), RollId.end() }; }

References RollId.

GetTargetIcon()

ObjectGuid Group::GetTargetIcon ( uint8  id ) const

inline

{ return id < TARGETICONCOUNT ? m_targetIcons[id] : ObjectGuid::Empty; }

References ObjectGuid::Empty, m_targetIcons, and TARGETICONCOUNT.

GroupLoot()

void Group::GroupLoot	(	Loot *	loot,
		WorldObject *	pLootedObject
	)

{
    std::vector<LootItem>::iterator i;
    ItemTemplate const* item;
    uint8 itemSlot = 0;
 
    for (i = loot->items.begin(); i != loot->items.end(); ++i, ++itemSlot)
    {
        if (i->freeforall)
            continue;
 
        item = sObjectMgr->GetItemTemplate(i->itemid);
        if (!item)
        {
            continue;
        }
 
        // roll for over-threshold item if it's one-player loot
        if (item->Quality >= uint32(m_lootThreshold))
        {
            ObjectGuid newitemGUID = ObjectGuid::Create<HighGuid::Item>(sObjectMgr->GetGenerator<HighGuid::Item>().Generate());
            Roll* r = new Roll(newitemGUID, *i, pLootedObject->GetMap()->IsRaid());
 
            //a vector is filled with only near party members
            for (GroupReference* itr = GetFirstMember(); itr != nullptr; itr = itr->next())
            {
                Player* member = itr->GetSource();
                if (!member || !member->GetSession())
                    continue;
 
                bool canLoot = member->IsAtLootRewardDistance(pLootedObject);
                if (!canLoot && !pLootedObject->GetAllowedLooters().empty())
                    canLoot = pLootedObject->HasAllowedLooter(member->GetGUID());
 
                if (canLoot)
                {
                    r->totalPlayersRolling++;
 
                    RollVote vote = member->GetPassOnGroupLoot() ? PASS : NOT_EMITED_YET;
                    if (!CanRollOnItem(*i, member, loot))
                    {
                        vote = PASS;
                        ++r->totalPass;
                    }
 
                    r->playerVote[member->GetGUID()] = vote;
                }
            }
 
            if (r->totalPlayersRolling > 0)
            {
                r->setLoot(loot);
                r->itemSlot = itemSlot;
                if (item->DisenchantID && m_maxEnchantingLevel >= item->RequiredDisenchantSkill)
                    r->rollVoteMask |= ROLL_FLAG_TYPE_DISENCHANT;
 
                loot->items[itemSlot].is_blocked = true;
 
                // If there is any "auto pass", broadcast the pass now.
                if (r->totalPass)
                {
                    for (Roll::PlayerVote::const_iterator itr = r->playerVote.begin(); itr != r->playerVote.end(); ++itr)
                    {
                        Player* p = ObjectAccessor::FindPlayer(itr->first);
                        if (!p)
                            continue;
 
                        if (itr->second == PASS)
                            SendLootRoll(newitemGUID, p->GetGUID(), 128, ROLL_PASS, *r, true);
                    }
                }
 
                if (r->totalPass == r->totalPlayersRolling)
                    delete r;
                else
                {
                    SendLootStartRoll(60000, pLootedObject->GetMapId(), *r);
 
                    RollId.push_back(r);
 
                    if (Creature* creature = pLootedObject->ToCreature())
                    {
                        creature->m_groupLootTimer = 60000;
                        creature->lootingGroupLowGUID = GetGUID().GetCounter();
                    }
                    else if (GameObject* go = pLootedObject->ToGameObject())
                    {
                        go->m_groupLootTimer = 60000;
                        go->lootingGroupLowGUID = GetGUID().GetCounter();
                    }
                }
            }
            else
                delete r;
        }
        else
            i->is_underthreshold = true;
    }
 
    for (i = loot->quest_items.begin(); i != loot->quest_items.end(); ++i, ++itemSlot)
    {
        if (!i->follow_loot_rules)
            continue;
 
        item = sObjectMgr->GetItemTemplate(i->itemid);
        if (!item)
        {
            continue;
        }
 
        ObjectGuid newitemGUID = ObjectGuid::Create<HighGuid::Item>(sObjectMgr->GetGenerator<HighGuid::Item>().Generate());
        Roll* r = new Roll(newitemGUID, *i, pLootedObject->GetMap()->IsRaid());
 
        //a vector is filled with only near party members
        for (GroupReference* itr = GetFirstMember(); itr != nullptr; itr = itr->next())
        {
            Player* member = itr->GetSource();
            if (!member || !member->GetSession())
                continue;
 
            bool canLoot = member->IsAtLootRewardDistance(pLootedObject);
            if (!canLoot && !pLootedObject->GetAllowedLooters().empty())
                canLoot = pLootedObject->HasAllowedLooter(member->GetGUID());
 
            if (canLoot)
            {
                r->totalPlayersRolling++;
 
                RollVote vote = NOT_EMITED_YET;
                if (!CanRollOnItem(*i, member, loot))
                {
                    vote = PASS;
                    ++r->totalPass;
                }
                r->playerVote[member->GetGUID()] = vote;
            }
        }
 
        if (r->totalPlayersRolling > 0)
        {
            r->setLoot(loot);
            r->itemSlot = itemSlot;
 
            loot->quest_items[itemSlot - loot->items.size()].is_blocked = true;
 
            SendLootStartRoll(60000, pLootedObject->GetMapId(), *r);
 
            RollId.push_back(r);
 
            if (Creature* creature = pLootedObject->ToCreature())
            {
                creature->m_groupLootTimer = 60000;
                creature->lootingGroupLowGUID = GetGUID().GetCounter();
            }
            else if (GameObject* go = pLootedObject->ToGameObject())
            {
                go->m_groupLootTimer = 60000;
                go->lootingGroupLowGUID = GetGUID().GetCounter();
            }
        }
        else
            delete r;
    }
}

References CanRollOnItem(), ItemTemplate::DisenchantID, ObjectAccessor::FindPlayer(), WorldObject::GetAllowedLooters(), ObjectGuid::GetCounter(), GetFirstMember(), GetGUID(), Object::GetGUID(), WorldObject::GetMap(), WorldLocation::GetMapId(), Player::GetPassOnGroupLoot(), Player::GetSession(), WorldObject::HasAllowedLooter(), Player::IsAtLootRewardDistance(), Map::IsRaid(), Item, Loot::items, Roll::itemSlot, m_lootThreshold, m_maxEnchantingLevel, GroupReference::next(), NOT_EMITED_YET, PASS, Roll::playerVote, ItemTemplate::Quality, Loot::quest_items, ItemTemplate::RequiredDisenchantSkill, ROLL_FLAG_TYPE_DISENCHANT, ROLL_PASS, RollId, Roll::rollVoteMask, SendLootRoll(), SendLootStartRoll(), Roll::setLoot(), sObjectMgr, Object::ToCreature(), Object::ToGameObject(), Roll::totalPass, and Roll::totalPlayersRolling.

Referenced by Player::SendLoot().

HasFreeSlotSubGroup()

bool Group::HasFreeSlotSubGroup

(

uint8

subgroup

)

const

{
    return (m_subGroupsCounts && m_subGroupsCounts[subgroup] < MAXGROUPSIZE);
}

References m_subGroupsCounts, and MAXGROUPSIZE.

Referenced by WorldSession::HandleGroupChangeSubGroupOpcode().

InInstance()

uint16 Group::InInstance

(

)

IsAssistant()

bool Group::IsAssistant

(

ObjectGuid

guid

)

const

{
    member_citerator mslot = _getMemberCSlot(guid);
    if (mslot == m_memberSlots.end())
        return false;
    return mslot->flags & MEMBER_FLAG_ASSISTANT;
}

References _getMemberCSlot(), m_memberSlots, and MEMBER_FLAG_ASSISTANT.

Referenced by BroadcastReadyCheck(), Player::CanUninviteFromGroup(), WorldSession::HandleGroupChangeSubGroupOpcode(), WorldSession::HandleGroupInviteOpcode(), WorldSession::HandleGroupSwapSubGroupOpcode(), WorldSession::HandleMessagechatOpcode(), WorldSession::HandlePartyAssignmentOpcode(), WorldSession::HandleRaidReadyCheckFinishedOpcode(), WorldSession::HandleRaidReadyCheckOpcode(), and WorldSession::HandleRaidTargetUpdateOpcode().

isBFGroup()

bool Group::isBFGroup

(

)

const

{
    return m_bfGroup != nullptr;
}

References m_bfGroup.

Referenced by AddInvite(), AddMember(), AddMemberWithGuid(), Battlefield::AddOrSetPlayerToCorrectBfGroup(), Battleground::AddOrSetPlayerToCorrectBgGroup(), Player::CanUninviteFromGroup(), ChangeLeader(), ChangeMembersGroup(), ConvertToLFG(), ConvertToRaid(), Create(), ForcedDisband(), misc_commandscript::HandleSkirmishCommand(), lfg::LFGMgr::JoinLfg(), LoadMemberFromDB(), RemoveMember(), ResetInstances(), SendUpdateToPlayer(), SetDungeonDifficulty(), and SetRaidDifficulty().

isBGGroup()

bool Group::isBGGroup

(

)

const

{
    return m_bgGroup != nullptr;
}

References m_bgGroup.

Referenced by AddInvite(), AddMember(), AddMemberWithGuid(), Battlefield::AddOrSetPlayerToCorrectBfGroup(), Battleground::AddOrSetPlayerToCorrectBgGroup(), ChangeLeader(), ChangeMembersGroup(), ConvertToLFG(), ConvertToRaid(), Create(), ForcedDisband(), WorldSession::HandleGroupInviteOpcode(), WorldSession::HandleMessagechatOpcode(), misc_commandscript::HandleSkirmishCommand(), lfg::LFGMgr::JoinLfg(), LoadMemberFromDB(), RemoveMember(), ResetInstances(), SendUpdateToPlayer(), SetDungeonDifficulty(), and SetRaidDifficulty().

IsCreated()

bool Group::IsCreated

(

)

const

{
    return GetMembersCount() > 0;
}

References GetMembersCount().

Referenced by Player::UninviteFromGroup().

IsFull()

bool Group::IsFull

(

)

const

{
    return isRaidGroup() ? (m_memberSlots.size() >= MAXRAIDSIZE) : (m_memberSlots.size() >= MAXGROUPSIZE);
}

References isRaidGroup(), m_memberSlots, MAXGROUPSIZE, and MAXRAIDSIZE.

Referenced by WorldSession::HandleGroupInviteOpcode(), group_commandscript::HandleGroupJoinCommand(), and lfg::LFGMgr::MakeNewGroup().

IsLeader()

bool Group::IsLeader

(

ObjectGuid

guid

)

const

{
    return (GetLeaderGUID() == guid);
}

References GetLeaderGUID().

Referenced by AddMember(), BroadcastReadyCheck(), Player::CanUninviteFromGroup(), WorldSession::HandleGroupAssistantLeaderOpcode(), WorldSession::HandleGroupChangeSubGroupOpcode(), WorldSession::HandleGroupInviteOpcode(), WorldSession::HandleGroupRaidConvertOpcode(), WorldSession::HandleGroupSetLeaderOpcode(), WorldSession::HandleGroupSwapSubGroupOpcode(), WorldSession::HandleGroupUninviteGuidOpcode(), WorldSession::HandleLootMethodOpcode(), WorldSession::HandleMessagechatOpcode(), WorldSession::HandlePartyAssignmentOpcode(), WorldSession::HandleRaidReadyCheckFinishedOpcode(), WorldSession::HandleRaidReadyCheckOpcode(), WorldSession::HandleRaidTargetUpdateOpcode(), WorldSession::HandleSetDungeonDifficultyOpcode(), WorldSession::HandleSetRaidDifficultyOpcode(), lfg::LFGMgr::MakeNewGroup(), and npc_icc_buff_switcher::OnGossipSelect().

isLFGGroup()

bool Group::isLFGGroup

(

bool

restricted = false

)

const

{
    bool isLFG = m_groupType & GROUPTYPE_LFG;
    return isLFG && (!restricted || (m_groupType & GROUPTYPE_LFG_RESTRICTED) != 0);
}

References GROUPTYPE_LFG, GROUPTYPE_LFG_RESTRICTED, and m_groupType.

Referenced by AddMember(), InstanceMap::AddPlayerToMap(), CanJoinBattlegroundQueue(), Player::CanUninviteFromGroup(), Create(), WorldSession::HandleGroupRaidConvertOpcode(), WorldSession::HandleGroupUninviteGuidOpcode(), WorldSession::HandleInstanceLockResponse(), lfg_commandscript::HandleLfgGroupInfoCommand(), WorldSession::HandleLootMethodOpcode(), misc_commandscript::HandleSkirmishCommand(), IsLfgHeroic(), IsLfgRandomInstance(), IsLfgWithBuff(), lfg::LFGMgr::JoinLfg(), WorldSession::LogoutPlayer(), lfg::LFGGroupScript::OnAddMember(), lfg::LFGPlayerScript::OnPlayerLogout(), lfg::LFGGroupScript::OnRemoveMember(), MapMgr::PlayerCannotEnter(), RemoveMember(), ResetInstances(), SendUpdateToPlayer(), ShouldMailRollWonItem(), and lfg::LFGMgr::TeleportPlayer().

IsLfgHeroic()

bool Group::IsLfgHeroic ( ) const

inline

{ return isLFGGroup() && (m_lfgGroupFlags & GROUP_LFG_FLAG_IS_HEROIC); }

References GROUP_LFG_FLAG_IS_HEROIC, isLFGGroup(), and m_lfgGroupFlags.

IsLfgRandomInstance()

bool Group::IsLfgRandomInstance ( ) const

inline

{ return isLFGGroup() && (m_lfgGroupFlags & GROUP_LFG_FLAG_IS_RANDOM_INSTANCE); }

References GROUP_LFG_FLAG_IS_RANDOM_INSTANCE, isLFGGroup(), and m_lfgGroupFlags.

Referenced by InstanceMap::AddPlayerToMap(), WorldSession::HandleInstanceLockResponse(), and MapMgr::PlayerCannotEnter().

IsLfgWithBuff()

bool Group::IsLfgWithBuff ( ) const

inline

{ return isLFGGroup() && (m_lfgGroupFlags & GROUP_LFG_FLAG_APPLY_RANDOM_BUFF); }

References GROUP_LFG_FLAG_APPLY_RANDOM_BUFF, isLFGGroup(), and m_lfgGroupFlags.

Referenced by lfg::LFGMgr::MakeNewGroup(), and lfg::LFGPlayerScript::OnPlayerMapChanged().

IsMember()

bool Group::IsMember

(

ObjectGuid

guid

)

const

{
    return _getMemberCSlot(guid) != m_memberSlots.end();
}

References _getMemberCSlot(), and m_memberSlots.

Referenced by AddMemberWithGuid(), Battlefield::AddOrSetPlayerToCorrectBfGroup(), Battleground::AddOrSetPlayerToCorrectBgGroup(), CanJoinBattlegroundQueue(), ArenaTeam::GetAverageMMR(), WorldSession::HandleGroupUninviteGuidOpcode(), WorldSession::HandleLootMethodOpcode(), Acore::MostHPMissingGroupInRange::operator()(), and GameObject::Use().

isRaidGroup()

bool Group::isRaidGroup

(

)

const

{
    return m_groupType & GROUPTYPE_RAID;
}

References GROUPTYPE_RAID, and m_groupType.

Referenced by KillRewarder::_RewardGroup(), AddMember(), ChangeMembersGroup(), ForcedDisband(), group_commandscript::HandleGroupListCommand(), WorldSession::HandleGroupSwapSubGroupOpcode(), WorldSession::HandleMessagechatOpcode(), WorldSession::HandleRaidTargetUpdateOpcode(), WorldSession::HandleSetRaidDifficultyOpcode(), misc_commandscript::HandleSkirmishCommand(), IsFull(), Unit::IsInPartyWith(), WorldSession::LogoutPlayer(), npc_icc_buff_switcher::OnGossipSelect(), MapMgr::PlayerCannotEnter(), SetGroupMemberFlag(), and PetAI::UpdateAllies().

isRollLootActive()

bool Group::isRollLootActive

(

)

const

{
    return !RollId.empty();
}

References RollId.

Referenced by Player::CanUninviteFromGroup().

LinkMember()

void Group::LinkMember

(

GroupReference *

pRef

)

{
    m_memberMgr.insertFirst(pRef);
}

References LinkedListHead::insertFirst(), and m_memberMgr.

Referenced by GroupReference::targetObjectBuildLink().

LoadGroupFromDB()

bool Group::LoadGroupFromDB

(

Field *

field

)

{
    ObjectGuid::LowType groupLowGuid = fields[16].Get<uint32>();
    m_guid = ObjectGuid::Create<HighGuid::Group>(groupLowGuid);
 
    m_leaderGuid = ObjectGuid::Create<HighGuid::Player>(fields[0].Get<uint32>());
 
    // group leader not exist
    if (!sCharacterCache->GetCharacterNameByGuid(m_leaderGuid, m_leaderName))
    {
        CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
        CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GROUP);
        stmt->SetData(0, groupLowGuid);
        trans->Append(stmt);
        stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GROUP_MEMBER_ALL);
        stmt->SetData(0, groupLowGuid);
        trans->Append(stmt);
        CharacterDatabase.CommitTransaction(trans);
        stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_LFG_DATA);
        stmt->SetData(0, groupLowGuid);
        CharacterDatabase.Execute(stmt);
        return false;
    }
 
    m_lootMethod = LootMethod(fields[1].Get<uint8>());
    m_looterGuid = ObjectGuid::Create<HighGuid::Player>(fields[2].Get<uint32>());
    m_lootThreshold = ItemQualities(fields[3].Get<uint8>());
 
    for (uint8 i = 0; i < TARGETICONCOUNT; ++i)
        m_targetIcons[i].Set(fields[4 + i].Get<uint64>());
 
    m_groupType  = GroupType(fields[12].Get<uint8>());
    if (m_groupType & GROUPTYPE_RAID)
        _initRaidSubGroupsCounter();
 
    uint32 diff = fields[13].Get<uint8>();
    if (diff >= MAX_DUNGEON_DIFFICULTY)
        m_dungeonDifficulty = DUNGEON_DIFFICULTY_NORMAL;
    else
        m_dungeonDifficulty = Difficulty(diff);
 
    uint32 r_diff = fields[14].Get<uint8>();
    if (r_diff >= MAX_RAID_DIFFICULTY)
        m_raidDifficulty = RAID_DIFFICULTY_10MAN_NORMAL;
    else
        m_raidDifficulty = Difficulty(r_diff);
 
    m_masterLooterGuid = ObjectGuid::Create<HighGuid::Player>(fields[15].Get<uint32>());
 
    if (m_groupType & GROUPTYPE_LFG)
        sLFGMgr->_LoadFromDB(fields, GetGUID());
 
    return true;
}

References _initRaidSubGroupsCounter(), CHAR_DEL_GROUP, CHAR_DEL_GROUP_MEMBER_ALL, CHAR_DEL_LFG_DATA, CharacterDatabase, DUNGEON_DIFFICULTY_NORMAL, Field::Get(), GetGUID(), GROUPTYPE_LFG, GROUPTYPE_RAID, m_dungeonDifficulty, m_groupType, m_guid, m_leaderGuid, m_leaderName, m_looterGuid, m_lootMethod, m_lootThreshold, m_masterLooterGuid, m_raidDifficulty, m_targetIcons, MAX_DUNGEON_DIFFICULTY, MAX_RAID_DIFFICULTY, RAID_DIFFICULTY_10MAN_NORMAL, sCharacterCache, PreparedStatementBase::SetData(), sLFGMgr, and TARGETICONCOUNT.

Referenced by GroupMgr::LoadGroups().

LoadMemberFromDB()

void Group::LoadMemberFromDB	(	ObjectGuid::LowType	guidLow,
		uint8	memberFlags,
		uint8	subgroup,
		uint8	roles
	)

{
    MemberSlot member;
    member.guid = ObjectGuid::Create<HighGuid::Player>(guidLow);
 
    // skip non-existed member
    if (!sCharacterCache->GetCharacterNameByGuid(member.guid, member.name))
    {
        CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GROUP_MEMBER);
        stmt->SetData(0, guidLow);
        stmt->SetData(1, GetGUID().GetCounter());
        CharacterDatabase.Execute(stmt);
        return;
    }
 
    member.group = subgroup;
    member.flags = memberFlags;
    member.roles = roles;
 
    m_memberSlots.push_back(member);
 
    if (!isBGGroup() && !isBFGroup())
    {
        sCharacterCache->UpdateCharacterGroup(ObjectGuid(HighGuid::Player, guidLow), GetGUID());
    }
 
    SubGroupCounterIncrease(subgroup);
 
    sLFGMgr->SetupGroupMember(member.guid, GetGUID());
}

References CHAR_DEL_GROUP_MEMBER, CharacterDatabase, Group::MemberSlot::flags, GetGUID(), Group::MemberSlot::group, Group::MemberSlot::guid, isBFGroup(), isBGGroup(), m_memberSlots, Group::MemberSlot::name, Player, Group::MemberSlot::roles, sCharacterCache, PreparedStatementBase::SetData(), sLFGMgr, and SubGroupCounterIncrease().

Referenced by GroupMgr::LoadGroups().

MasterLoot()

void Group::MasterLoot	(	Loot *	loot,
		WorldObject *	pLootedObject
	)

{
    LOG_DEBUG("network", "Group::MasterLoot (SMSG_LOOT_MASTER_LIST, 330)");
 
    for (std::vector<LootItem>::iterator i = loot->items.begin(); i != loot->items.end(); ++i)
    {
        if (i->freeforall)
            continue;
 
        i->is_blocked = !i->is_underthreshold;
    }
 
    for (std::vector<LootItem>::iterator i = loot->quest_items.begin(); i != loot->quest_items.end(); ++i)
    {
        if (!i->follow_loot_rules)
            continue;
 
        i->is_blocked = !i->is_underthreshold;
    }
 
    std::vector<Player*> looters;
    bool hasAllowedLooters = !pLootedObject->GetAllowedLooters().empty();
    for (GroupReference* itr = GetFirstMember(); itr != nullptr; itr = itr->next())
    {
        Player* looter = itr->GetSource();
        if (!looter->IsInWorld())
        {
            continue;
        }
 
        bool canLoot = looter->IsAtLootRewardDistance(pLootedObject);
        if (!canLoot && hasAllowedLooters)
            canLoot = pLootedObject->HasAllowedLooter(looter->GetGUID());
 
        if (canLoot)
        {
            looters.push_back(looter);
        }
    }
 
    WorldPacket data(SMSG_LOOT_MASTER_LIST, 1 + looters.size() * (1 + 8));
    data << uint8(looters.size());
 
    for (Player* looter : looters)
    {
        data << looter->GetGUID();
    }
 
    for (Player* looter : looters)
    {
        looter->SendDirectMessage(&data);
    }
}

References WorldObject::GetAllowedLooters(), GetFirstMember(), Object::GetGUID(), WorldObject::HasAllowedLooter(), Player::IsAtLootRewardDistance(), Object::IsInWorld(), Loot::items, LOG_DEBUG, GroupReference::next(), Loot::quest_items, and SMSG_LOOT_MASTER_LIST.

Referenced by Player::SendLoot().

NeedBeforeGreed()

void Group::NeedBeforeGreed	(	Loot *	loot,
		WorldObject *	pLootedObject
	)

{
    ItemTemplate const* item;
    uint8 itemSlot = 0;
    for (std::vector<LootItem>::iterator i = loot->items.begin(); i != loot->items.end(); ++i, ++itemSlot)
    {
        if (i->freeforall)
            continue;
 
        item = sObjectMgr->GetItemTemplate(i->itemid);
 
        //roll for over-threshold item if it's one-player loot
        if (item->Quality >= uint32(m_lootThreshold))
        {
            ObjectGuid newitemGUID = ObjectGuid::Create<HighGuid::Item>(sObjectMgr->GetGenerator<HighGuid::Item>().Generate());
            Roll* r = new Roll(newitemGUID, *i, lootedObject->GetMap()->IsRaid());
 
            for (GroupReference* itr = GetFirstMember(); itr != nullptr; itr = itr->next())
            {
                Player* playerToRoll = itr->GetSource();
                if (!playerToRoll || !playerToRoll->GetSession())
                    continue;
 
                bool canLoot = playerToRoll->IsAtGroupRewardDistance(lootedObject);
                if (!canLoot && !lootedObject->GetAllowedLooters().empty())
                    canLoot = lootedObject->HasAllowedLooter(playerToRoll->GetGUID());
 
                if (canLoot)
                {
                    r->totalPlayersRolling++;
 
                    RollVote vote = playerToRoll->GetPassOnGroupLoot() ? PASS : NOT_EMITED_YET;
                    if (!CanRollOnItem(*i, playerToRoll, loot))
                    {
                        vote = PASS;
                        r->totalPass++; // Can't broadcast the pass now. need to wait until all rolling players are known
                    }
 
                    r->playerVote[playerToRoll->GetGUID()] = vote;
                }
            }
 
            if (r->totalPlayersRolling > 0)
            {
                r->setLoot(loot);
                r->itemSlot = itemSlot;
                if (item->DisenchantID && m_maxEnchantingLevel >= item->RequiredDisenchantSkill)
                    r->rollVoteMask |= ROLL_FLAG_TYPE_DISENCHANT;
 
                if (item->HasFlag2(ITEM_FLAG2_CAN_ONLY_ROLL_GREED))
                    r->rollVoteMask &= ~ROLL_FLAG_TYPE_NEED;
 
                loot->items[itemSlot].is_blocked = true;
 
                //Broadcast Pass and Send Rollstart
                for (Roll::PlayerVote::const_iterator itr = r->playerVote.begin(); itr != r->playerVote.end(); ++itr)
                {
                    Player* p = ObjectAccessor::FindPlayer(itr->first);
                    if (!p)
                        continue;
 
                    if (itr->second == PASS)
                        SendLootRoll(newitemGUID, p->GetGUID(), 128, ROLL_PASS, *r);
                    else
                        SendLootStartRollToPlayer(60000, lootedObject->GetMapId(), p, p->CanRollForItemInLFG(item, lootedObject) == EQUIP_ERR_OK, *r);
                }
 
                RollId.push_back(r);
 
                if (Creature* creature = lootedObject->ToCreature())
                {
                    creature->m_groupLootTimer = 60000;
                    creature->lootingGroupLowGUID = GetGUID().GetCounter();
                }
                else if (GameObject* go = lootedObject->ToGameObject())
                {
                    go->m_groupLootTimer = 60000;
                    go->lootingGroupLowGUID = GetGUID().GetCounter();
                }
            }
            else
                delete r;
        }
        else
            i->is_underthreshold = true;
    }
 
    for (std::vector<LootItem>::iterator i = loot->quest_items.begin(); i != loot->quest_items.end(); ++i, ++itemSlot)
    {
        if (!i->follow_loot_rules)
            continue;
 
        item = sObjectMgr->GetItemTemplate(i->itemid);
        ObjectGuid newitemGUID = ObjectGuid::Create<HighGuid::Item>(sObjectMgr->GetGenerator<HighGuid::Item>().Generate());
        Roll* r = new Roll(newitemGUID, *i, lootedObject->GetMap()->IsRaid());
 
        for (GroupReference* itr = GetFirstMember(); itr != nullptr; itr = itr->next())
        {
            Player* playerToRoll = itr->GetSource();
            if (!playerToRoll || !playerToRoll->GetSession())
                continue;
 
            if (playerToRoll->IsAtGroupRewardDistance(lootedObject))
            {
                r->totalPlayersRolling++;
 
                RollVote vote = playerToRoll->GetPassOnGroupLoot() ? PASS : NOT_EMITED_YET;
                if (!CanRollOnItem(*i, playerToRoll, loot))
                {
                    vote = PASS;
                    r->totalPass++; // Can't broadcast the pass now. need to wait until all rolling players are known
                }
 
                r->playerVote[playerToRoll->GetGUID()] = vote;
            }
        }
 
        if (r->totalPlayersRolling > 0)
        {
            r->setLoot(loot);
            r->itemSlot = itemSlot;
 
            loot->quest_items[itemSlot - loot->items.size()].is_blocked = true;
 
            //Broadcast Pass and Send Rollstart
            for (Roll::PlayerVote::const_iterator itr = r->playerVote.begin(); itr != r->playerVote.end(); ++itr)
            {
                Player* p = ObjectAccessor::FindPlayer(itr->first);
                if (!p)
                    continue;
 
                if (itr->second == PASS)
                    SendLootRoll(newitemGUID, p->GetGUID(), 128, ROLL_PASS, *r);
                else
                    SendLootStartRollToPlayer(60000, lootedObject->GetMapId(), p, p->CanRollForItemInLFG(item, lootedObject) == EQUIP_ERR_OK, *r);
            }
 
            RollId.push_back(r);
 
            if (Creature* creature = lootedObject->ToCreature())
            {
                creature->m_groupLootTimer = 60000;
                creature->lootingGroupLowGUID = GetGUID().GetCounter();
            }
            else if (GameObject* go = lootedObject->ToGameObject())
            {
                go->m_groupLootTimer = 60000;
                go->lootingGroupLowGUID = GetGUID().GetCounter();
            }
        }
        else
            delete r;
    }
}

References Player::CanRollForItemInLFG(), CanRollOnItem(), ItemTemplate::DisenchantID, EQUIP_ERR_OK, ObjectAccessor::FindPlayer(), WorldObject::GetAllowedLooters(), ObjectGuid::GetCounter(), GetFirstMember(), GetGUID(), Object::GetGUID(), WorldObject::GetMap(), WorldLocation::GetMapId(), Player::GetPassOnGroupLoot(), Player::GetSession(), WorldObject::HasAllowedLooter(), ItemTemplate::HasFlag2(), Player::IsAtGroupRewardDistance(), Map::IsRaid(), Item, ITEM_FLAG2_CAN_ONLY_ROLL_GREED, Loot::items, Roll::itemSlot, m_lootThreshold, m_maxEnchantingLevel, GroupReference::next(), NOT_EMITED_YET, PASS, Roll::playerVote, ItemTemplate::Quality, Loot::quest_items, ItemTemplate::RequiredDisenchantSkill, ROLL_FLAG_TYPE_DISENCHANT, ROLL_PASS, RollId, Roll::rollVoteMask, SendLootRoll(), SendLootStartRollToPlayer(), Roll::setLoot(), sObjectMgr, Object::ToCreature(), Object::ToGameObject(), Roll::totalPass, and Roll::totalPlayersRolling.

Referenced by Player::SendLoot().

OfflineReadyCheck()

void Group::OfflineReadyCheck

(

)

{
    for (member_citerator citr = m_memberSlots.begin(); citr != m_memberSlots.end(); ++citr)
    {
        Player* player = ObjectAccessor::FindConnectedPlayer(citr->guid);
        if (!player)
        {
            WorldPacket data(MSG_RAID_READY_CHECK_CONFIRM, 9);
            data << citr->guid;
            data << uint8(0);
            BroadcastReadyCheck(&data);
        }
    }
}

References BroadcastReadyCheck(), ObjectAccessor::FindConnectedPlayer(), m_memberSlots, and MSG_RAID_READY_CHECK_CONFIRM.

Referenced by WorldSession::HandleRaidReadyCheckOpcode().

RemoveAllInvites()

void Group::RemoveAllInvites

(

)

{
    for (Player* invitee : m_invitees)
        if (invitee && invitee->GetGroupInvite() == this)
            invitee->SetGroupInvite(nullptr);
 
    m_invitees.clear();
}

References m_invitees.

Referenced by ForcedDisband(), and Player::UninviteFromGroup().

RemoveInvite()

void Group::RemoveInvite

(

Player *

player

)

{
    if (!player)
        return;
 
    m_invitees.erase(player);
 
    // Clear pending invite from current group, Keep an invite from another group.
    if (player->GetGroupInvite() == this)
        player->SetGroupInvite(nullptr);
}

References Player::GetGroupInvite(), m_invitees, and Player::SetGroupInvite().

Referenced by AddInvite(), WorldSession::HandleGroupAcceptOpcode(), and Player::UninviteFromGroup().

RemoveMember()

bool Group::RemoveMember	(	ObjectGuid	guid,
		RemoveMethod const &	method = GROUP_REMOVEMETHOD_DEFAULT,
		ObjectGuid	kicker = ObjectGuid::Empty,
		char const *	reason = nullptr
	)

{
    BroadcastGroupUpdate();
 
    // LFG group vote kick handled in scripts
    if (isLFGGroup(true) && method == GROUP_REMOVEMETHOD_KICK)
    {
        sLFGMgr->InitBoot(GetGUID(), kicker, guid, std::string(reason ? reason : ""));
        return m_memberSlots.size() > 0;
    }
 
    // remove member and change leader (if need) only if strong more 2 members _before_ member remove (BG/BF allow 1 member group),
    // except in cluster mode, where this branch is taken for any size: the group
    // service owns the group lifecycle and local Disband() is a no-op, so always
    // unlink the removed member here; waiting for the disband event leaves the
    // last two members with a dangling group pointer whenever that event is lost
    // (group service restart).
    if (GetMembersCount() > ((isBGGroup() || isLFGGroup() || isBFGroup()) ? 1u : 2u)
        || (sToCloud9Sidecar->ClusterModeEnabled() && !isBGGroup() && !isBFGroup()))
    {
        Player* player = ObjectAccessor::FindConnectedPlayer(guid);
        if (player)
        {
            // Battleground group handling
            if (isBGGroup() || isBFGroup())
                player->RemoveFromBattlegroundOrBattlefieldRaid();
            else
                // Regular group
            {
                if (player->GetOriginalGroup() == this)
                    player->SetOriginalGroup(nullptr);
                else
                    player->SetGroup(nullptr);
 
                // quest related GO state dependent from raid membership
                player->UpdateForQuestWorldObjects();
            }
 
            // BG/BF groups stay locally owned in cluster mode (see the gates above),
            // so their removal packets must not be delegated to the group service.
            if (!sToCloud9Sidecar->ClusterModeEnabled() || isBGGroup() || isBFGroup())
            {
                WorldPacket data;
 
                if (method == GROUP_REMOVEMETHOD_KICK || method == GROUP_REMOVEMETHOD_KICK_LFG)
                {
                    data.Initialize(SMSG_GROUP_UNINVITE, 0);
                    player->GetSession()->SendPacket(&data);
                }
 
                // Do we really need to send this opcode?
                data.Initialize(SMSG_GROUP_LIST, 1 + 1 + 1 + 1 + 8 + 4 + 4 + 8);
                data << uint8(0x10) << uint8(0) << uint8(0) << uint8(0);
                data << m_guid << uint32(m_counter) << uint32(0) << uint64(0);
                player->GetSession()->SendPacket(&data);
            }
        }
 
        // Remove player from group in DB
        if (!isBGGroup() && !isBFGroup())
        {
            CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GROUP_MEMBER);
            stmt->SetData(0, guid.GetCounter());
            stmt->SetData(1, GetGUID().GetCounter());
            CharacterDatabase.Execute(stmt);
        }
 
        // Remove player from loot rolls
        RemovePlayerFromRolls(guid);
 
        // Update subgroups
        member_witerator slot = _getMemberWSlot(guid);
        if (slot != m_memberSlots.end())
        {
            SubGroupCounterDecrease(slot->group);
            m_memberSlots.erase(slot);
 
            if (!isBGGroup() && !isBFGroup())
            {
                sCharacterCache->ClearCharacterGroup(guid);
            }
        }
 
        // Reevaluate group enchanter if the leaving player had enchanting skill or the player is offline
        if (!player || player->GetSkillValue(SKILL_ENCHANTING))
        {
            ResetMaxEnchantingLevel();
        }
 
        // Pick new leader if necessary
        bool validLeader = true;
        if (m_leaderGuid == guid)
        {
            validLeader = false;
            for (member_witerator itr = m_memberSlots.begin(); itr != m_memberSlots.end(); ++itr)
            {
                if (ObjectAccessor::FindConnectedPlayer(itr->guid))
                {
                    ChangeLeader(itr->guid);
                    validLeader = true;
                    break;
                }
            }
        }
 
        _homebindIfInstance(player);
        if (!isBGGroup() && !isBFGroup())
            Player::ResetInstances(guid, INSTANCE_RESET_GROUP_LEAVE, false);
 
        sScriptMgr->OnGroupRemoveMember(this, guid, method, kicker, reason);
 
        SendUpdate();
 
        if (!validLeader)
        {
            // pussywizard: temp do nothing, something causes crashes in MakeNewGroup
            //Disband();
            //return false;
        }
 
        if (isLFGGroup() && GetMembersCount() == 1)
        {
            Player* leader = ObjectAccessor::FindConnectedPlayer(GetLeaderGUID());
            uint32 mapId = sLFGMgr->GetDungeonMapId(GetGUID());
            lfg::LfgState state = sLFGMgr->GetState(GetGUID());
            if (!mapId || !leader || (leader->IsAlive() && leader->GetMapId() != mapId) || state == lfg::LFG_STATE_NONE)
            {
                Disband();
                return false;
            }
        }
 
        if (m_memberMgr.getSize() < ((isLFGGroup() || isBGGroup() || isBFGroup()) ? 1u : 2u))
        {
            Disband();
            return false;
        }
 
        return true;
    }
    // If group size before player removal <= 2 then disband it
    else
    {
        // As in the branch above: a player who leaves or is kicked can't win a roll the disband settles
        RemovePlayerFromRolls(guid);
 
        sScriptMgr->OnGroupRemoveMember(this, guid, method, kicker, reason);
        Disband();
        return false;
    }
}

References _getMemberWSlot(), _homebindIfInstance(), BroadcastGroupUpdate(), ChangeLeader(), CHAR_DEL_GROUP_MEMBER, CharacterDatabase, Disband(), ObjectAccessor::FindConnectedPlayer(), ObjectGuid::GetCounter(), GetGUID(), GetLeaderGUID(), WorldLocation::GetMapId(), GetMembersCount(), Player::GetOriginalGroup(), Player::GetSession(), LinkedListHead::getSize(), Player::GetSkillValue(), GROUP_REMOVEMETHOD_KICK, GROUP_REMOVEMETHOD_KICK_LFG, WorldPacket::Initialize(), INSTANCE_RESET_GROUP_LEAVE, Unit::IsAlive(), isBFGroup(), isBGGroup(), isLFGGroup(), lfg::LFG_STATE_NONE, m_counter, m_guid, m_leaderGuid, m_memberMgr, m_memberSlots, Player::RemoveFromBattlegroundOrBattlefieldRaid(), RemovePlayerFromRolls(), Player::ResetInstances(), ResetMaxEnchantingLevel(), sCharacterCache, WorldSession::SendPacket(), SendUpdate(), PreparedStatementBase::SetData(), Player::SetGroup(), Player::SetOriginalGroup(), SKILL_ENCHANTING, sLFGMgr, SMSG_GROUP_LIST, SMSG_GROUP_UNINVITE, sScriptMgr, sToCloud9Sidecar, SubGroupCounterDecrease(), and Player::UpdateForQuestWorldObjects().

Referenced by group_commandscript::HandleGroupRemoveCommand(), lfg::LFGMgr::MakeNewGroup(), and Player::RemoveFromGroup().

RemovePlayerFromRolls()

void Group::RemovePlayerFromRolls

(

ObjectGuid

guid

)

{
    for (Rolls::iterator it = RollId.begin(); it != RollId.end();)
    {
        Roll* roll = *it;
        Roll::PlayerVote::iterator itr2 = roll->playerVote.find(guid);
        if (itr2 == roll->playerVote.end())
        {
            ++it;
            continue;
        }
 
        if (itr2->second == GREED || itr2->second == DISENCHANT)
            --roll->totalGreed;
        else if (itr2->second == NEED)
            --roll->totalNeed;
        else if (itr2->second == PASS)
            --roll->totalPass;
 
        if (itr2->second != NOT_VALID)
            --roll->totalPlayersRolling;
 
        roll->playerVote.erase(itr2);
 
        if (CountRollVote(guid, roll->itemGUID, MAX_ROLL_TYPE))
            it = RollId.begin();
        else
            ++it;
    }
}

References CountRollVote(), DISENCHANT, GREED, Roll::itemGUID, MAX_ROLL_TYPE, NEED, NOT_VALID, PASS, Roll::playerVote, RollId, Roll::totalGreed, Roll::totalNeed, Roll::totalPass, and Roll::totalPlayersRolling.

Referenced by RemoveMember().

RemoveUniqueGroupMemberFlag()

void Group::RemoveUniqueGroupMemberFlag

(

GroupMemberFlags

flag

)

{
    for (member_witerator itr = m_memberSlots.begin(); itr != m_memberSlots.end(); ++itr)
        if (itr->flags & flag)
            itr->flags &= ~flag;
}

References m_memberSlots.

Referenced by WorldSession::HandlePartyAssignmentOpcode(), and SetGroupMemberFlag().

ResetInstances()

void Group::ResetInstances	(	uint8	method,
		bool	isRaid,
		Player *	leader
	)

{
    if (isBGGroup() || isBFGroup() || isLFGGroup())
        return;
 
    switch (method)
    {
        case INSTANCE_RESET_ALL:
            {
                if (leader->GetDifficulty(false) != DUNGEON_DIFFICULTY_NORMAL)
                    break;
                std::vector<InstanceSave*> toUnbind;
                BoundInstancesMap const& m_boundInstances = sInstanceSaveMgr->PlayerGetBoundInstances(leader->GetGUID(), Difficulty(DUNGEON_DIFFICULTY_NORMAL));
                for (BoundInstancesMap::const_iterator itr = m_boundInstances.begin(); itr != m_boundInstances.end(); ++itr)
                {
                    InstanceSave* instanceSave = itr->second.save;
                    MapEntry const* entry = sMapStore.LookupEntry(itr->first);
                    if (!entry || entry->IsRaid() || !instanceSave->CanReset())
                        continue;
 
                    Map* map = sMapMgr->FindMap(instanceSave->GetMapId(), instanceSave->GetInstanceId());
                    if (!map || map->ToInstanceMap()->Reset(method))
                    {
                        leader->SendResetInstanceSuccess(instanceSave->GetMapId());
                        toUnbind.push_back(instanceSave);
                    }
                    else
                    {
                        leader->SendResetInstanceFailed(INSTANCE_RESET_FAILED, instanceSave->GetMapId());
                    }
 
                    sInstanceSaveMgr->DeleteInstanceSavedData(instanceSave->GetInstanceId());
                }
                for (std::vector<InstanceSave*>::const_iterator itr = toUnbind.begin(); itr != toUnbind.end(); ++itr)
                    sInstanceSaveMgr->UnbindAllFor(*itr);
            }
            break;
        case INSTANCE_RESET_CHANGE_DIFFICULTY:
            {
                std::vector<InstanceSave*> toUnbind;
                BoundInstancesMap const& m_boundInstances = sInstanceSaveMgr->PlayerGetBoundInstances(leader->GetGUID(), leader->GetDifficulty(isRaid));
                for (BoundInstancesMap::const_iterator itr = m_boundInstances.begin(); itr != m_boundInstances.end(); ++itr)
                {
                    InstanceSave* instanceSave = itr->second.save;
                    MapEntry const* entry = sMapStore.LookupEntry(itr->first);
                    if (!entry || entry->IsRaid() != isRaid || !instanceSave->CanReset())
                        continue;
 
                    Map* map = sMapMgr->FindMap(instanceSave->GetMapId(), instanceSave->GetInstanceId());
                    if (!map || map->ToInstanceMap()->Reset(method))
                    {
                        leader->SendResetInstanceSuccess(instanceSave->GetMapId());
                        toUnbind.push_back(instanceSave);
                    }
                    else
                    {
                        leader->SendResetInstanceFailed(INSTANCE_RESET_FAILED, instanceSave->GetMapId());
                    }
 
                    sInstanceSaveMgr->DeleteInstanceSavedData(instanceSave->GetInstanceId());
                }
                for (std::vector<InstanceSave*>::const_iterator itr = toUnbind.begin(); itr != toUnbind.end(); ++itr)
                    sInstanceSaveMgr->UnbindAllFor(*itr);
            }
            break;
    }
}

References InstanceSave::CanReset(), DUNGEON_DIFFICULTY_NORMAL, Player::GetDifficulty(), Object::GetGUID(), InstanceSave::GetInstanceId(), InstanceSave::GetMapId(), INSTANCE_RESET_ALL, INSTANCE_RESET_CHANGE_DIFFICULTY, INSTANCE_RESET_FAILED, isBFGroup(), isBGGroup(), isLFGGroup(), MapEntry::IsRaid(), InstanceMap::Reset(), Player::SendResetInstanceFailed(), Player::SendResetInstanceSuccess(), sInstanceSaveMgr, sMapMgr, sMapStore, and Map::ToInstanceMap().

Referenced by WorldSession::HandleSetDungeonDifficultyOpcode(), and WorldSession::HandleSetRaidDifficultyOpcode().

ResetMaxEnchantingLevel()

void Group::ResetMaxEnchantingLevel

(

)

{
    m_maxEnchantingLevel = 0;
    Player* pMember = nullptr;
    for (member_citerator citr = m_memberSlots.begin(); citr != m_memberSlots.end(); ++citr)
    {
        pMember = ObjectAccessor::FindPlayer(citr->guid);
        if (pMember && pMember->GetSession() && !pMember->GetSession()->IsSocketClosed()
            && m_maxEnchantingLevel < pMember->GetSkillValue(SKILL_ENCHANTING))
        {
            m_maxEnchantingLevel = pMember->GetSkillValue(SKILL_ENCHANTING);
        }
    }
}

References ObjectAccessor::FindPlayer(), Player::GetSession(), Player::GetSkillValue(), WorldSession::IsSocketClosed(), m_maxEnchantingLevel, m_memberSlots, and SKILL_ENCHANTING.

Referenced by WorldSession::LogoutPlayer(), and RemoveMember().

SameSubGroup() [1/3]

bool Group::SameSubGroup	(	ObjectGuid	guid1,
		MemberSlot const *	slot2
	)		const

{
    member_citerator mslot1 = _getMemberCSlot(guid1);
    if (mslot1 == m_memberSlots.end() || !slot2)
        return false;
    return (mslot1->group == slot2->group);
}

References _getMemberCSlot(), Group::MemberSlot::group, and m_memberSlots.

SameSubGroup() [2/3]

bool Group::SameSubGroup	(	ObjectGuid	guid1,
		ObjectGuid	guid2
	)		const

{
    member_citerator mslot2 = _getMemberCSlot(guid2);
    if (mslot2 == m_memberSlots.end())
        return false;
    return SameSubGroup(guid1, &*mslot2);
}

References _getMemberCSlot(), m_memberSlots, and SameSubGroup().

Referenced by Player::IsInSameGroupWith(), SameSubGroup(), and PetAI::UpdateAllies().

SameSubGroup() [3/3]

bool Group::SameSubGroup	(	Player const *	member1,
		Player const *	member2
	)		const

{
    if (!member1 || !member2)
        return false;
 
    if (member1->GetGroup() != this || member2->GetGroup() != this)
        return false;
    else
        return member1->GetSubGroup() == member2->GetSubGroup();
}

References Player::GetGroup(), and Player::GetSubGroup().

SendLootAllPassed()

void Group::SendLootAllPassed

(

Roll const &

roll

)

{
    WorldPacket data(SMSG_LOOT_ALL_PASSED, (8 + 4 + 4 + 4 + 4));
    data << roll.itemGUID;                                     // Guid of the item rolled
    data << uint32(roll.itemSlot);                             // Item loot slot
    data << uint32(roll.itemid);                               // The itemEntryId for the item that shall be rolled for
    data << uint32(roll.itemRandomPropId);                     // Item random property ID
    data << uint32(roll.itemRandomSuffix);                     // Item random suffix ID
 
    for (Roll::PlayerVote::const_iterator itr = roll.playerVote.begin(); itr != roll.playerVote.end(); ++itr)
    {
        Player* player = ObjectAccessor::FindConnectedPlayer(itr->first);
        if (!player)
            continue;
 
        if (itr->second != NOT_VALID)
            player->SendDirectMessage(&data);
    }
}

References ObjectAccessor::FindConnectedPlayer(), Roll::itemGUID, Roll::itemid, Roll::itemRandomPropId, Roll::itemRandomSuffix, Roll::itemSlot, NOT_VALID, Roll::playerVote, Player::SendDirectMessage(), and SMSG_LOOT_ALL_PASSED.

Referenced by CountTheRoll().

SendLooter()

void Group::SendLooter	(	Creature *	creature,
		Player *	pLooter
	)

{
    ASSERT(creature);
 
    WorldPacket data(SMSG_LOOT_LIST, (8 + 8));
    data << creature->GetGUID();
 
    if (GetLootMethod() == MASTER_LOOT && creature->loot.hasOverThresholdItem())
        data << GetMasterLooterGuid().WriteAsPacked();
    else
        data << uint8(0);
 
    if (groupLooter)
        data << groupLooter->GetPackGUID();
    else
        data << uint8(0);
 
    BroadcastPacket(&data, false);
}

References ASSERT, BroadcastPacket(), Object::GetGUID(), GetLootMethod(), GetMasterLooterGuid(), Object::GetPackGUID(), Loot::hasOverThresholdItem(), Creature::loot, MASTER_LOOT, SMSG_LOOT_LIST, and ObjectGuid::WriteAsPacked().

Referenced by Unit::Kill().

SendLootRoll()

void Group::SendLootRoll	(	ObjectGuid	SourceGuid,
		ObjectGuid	TargetGuid,
		uint8	RollNumber,
		uint8	RollType,
		Roll const &	r,
		bool	autoPass = false
	)

{
    WorldPacket data(SMSG_LOOT_ROLL, (8 + 4 + 8 + 4 + 4 + 4 + 1 + 1 + 1));
    data << sourceGuid;                                     // guid of the item rolled
    data << uint32(roll.itemSlot);                          // slot
    data << targetGuid;
    data << uint32(roll.itemid);                            // the itemEntryId for the item that shall be rolled for
    data << uint32(roll.itemRandomSuffix);                  // randomSuffix
    data << uint32(roll.itemRandomPropId);                  // Item random property ID
    data << uint8(rollNumber);                              // 0: "Need for: [item name]" > 127: "you passed on: [item name]"      Roll number
    data << uint8(rollType);                                // 0: "Need for: [item name]" 0: "You have selected need for [item name] 1: need roll 2: greed roll
    data << uint8(autoPass);                                // 1: "You automatically passed on: %s because you cannot loot that item."
 
    for (Roll::PlayerVote::const_iterator itr = roll.playerVote.begin(); itr != roll.playerVote.end(); ++itr)
    {
        Player* p = ObjectAccessor::FindConnectedPlayer(itr->first);
        if (!p)
            continue;
 
        if (itr->second != NOT_VALID)
            p->SendDirectMessage(&data);
    }
}

References ObjectAccessor::FindConnectedPlayer(), Roll::itemid, Roll::itemRandomPropId, Roll::itemRandomSuffix, Roll::itemSlot, NOT_VALID, Roll::playerVote, Player::SendDirectMessage(), and SMSG_LOOT_ROLL.

Referenced by CountRollVote(), CountTheRoll(), EndRoll(), GroupLoot(), and NeedBeforeGreed().

SendLootRollWon()

void Group::SendLootRollWon	(	ObjectGuid	SourceGuid,
		ObjectGuid	TargetGuid,
		uint8	RollNumber,
		uint8	RollType,
		Roll const &	r
	)

{
    WorldPacket data(SMSG_LOOT_ROLL_WON, (8 + 4 + 4 + 4 + 4 + 8 + 1 + 1));
    data << sourceGuid;                                     // guid of the item rolled
    data << uint32(roll.itemSlot);                          // slot
    data << uint32(roll.itemid);                            // the itemEntryId for the item that shall be rolled for
    data << uint32(roll.itemRandomSuffix);                  // randomSuffix
    data << uint32(roll.itemRandomPropId);                  // Item random property
    data << targetGuid;                                     // guid of the player who won.
    data << uint8(rollNumber);                              // rollnumber realted to SMSG_LOOT_ROLL
    data << uint8(rollType);                                // rollType related to SMSG_LOOT_ROLL
 
    for (Roll::PlayerVote::const_iterator itr = roll.playerVote.begin(); itr != roll.playerVote.end(); ++itr)
    {
        Player* p = ObjectAccessor::FindConnectedPlayer(itr->first);
        if (!p)
            continue;
 
        if (itr->second != NOT_VALID)
            p->SendDirectMessage(&data);
    }
}

References ObjectAccessor::FindConnectedPlayer(), Roll::itemid, Roll::itemRandomPropId, Roll::itemRandomSuffix, Roll::itemSlot, NOT_VALID, Roll::playerVote, Player::SendDirectMessage(), and SMSG_LOOT_ROLL_WON.

Referenced by CountTheRoll().

SendLootStartRoll()

void Group::SendLootStartRoll	(	uint32	CountDown,
		uint32	mapid,
		Roll const &	r
	)

{
    WorldPacket data(SMSG_LOOT_START_ROLL, (8 + 4 + 4 + 4 + 4 + 4 + 4 + 1));
    data << r.itemGUID;                                     // guid of rolled item
    data << uint32(mapid);                                  // 3.3.3 mapid
    data << uint32(r.itemSlot);                             // itemslot
    data << uint32(r.itemid);                               // the itemEntryId for the item that shall be rolled for
    data << uint32(r.itemRandomSuffix);                     // randomSuffix
    data << uint32(r.itemRandomPropId);                     // item random property ID
    data << uint32(r.itemCount);                            // items in stack
    data << uint32(CountDown);                              // the countdown time to choose "need" or "greed"
    data << uint8(r.rollVoteMask);                          // roll type mask
 
    for (Roll::PlayerVote::const_iterator itr = r.playerVote.begin(); itr != r.playerVote.end(); ++itr)
    {
        Player* p = ObjectAccessor::FindConnectedPlayer(itr->first);
        if (!p)
            continue;
 
        if (itr->second == NOT_EMITED_YET)
            p->SendDirectMessage(&data);
    }
}

References ObjectAccessor::FindConnectedPlayer(), Roll::itemCount, Roll::itemGUID, Roll::itemid, Roll::itemRandomPropId, Roll::itemRandomSuffix, Roll::itemSlot, NOT_EMITED_YET, Roll::playerVote, Roll::rollVoteMask, Player::SendDirectMessage(), and SMSG_LOOT_START_ROLL.

Referenced by GroupLoot().

SendLootStartRollToPlayer()

void Group::SendLootStartRollToPlayer	(	uint32	countDown,
		uint32	mapId,
		Player *	p,
		bool	canNeed,
		Roll const &	r
	)

{
    if (!p)
        return;
 
    WorldPacket data(SMSG_LOOT_START_ROLL, (8 + 4 + 4 + 4 + 4 + 4 + 4 + 1));
    data << r.itemGUID;                                     // guid of rolled item
    data << uint32(mapId);                                  // 3.3.3 mapid
    data << uint32(r.itemSlot);                             // itemslot
    data << uint32(r.itemid);                               // the itemEntryId for the item that shall be rolled for
    data << uint32(r.itemRandomSuffix);                     // randomSuffix
    data << uint32(r.itemRandomPropId);                     // item random property ID
    data << uint32(r.itemCount);                            // items in stack
    data << uint32(countDown);                              // the countdown time to choose "need" or "greed"
    uint8 voteMask = r.rollVoteMask;
    if (!canNeed)
        voteMask &= ~ROLL_FLAG_TYPE_NEED;
    data << uint8(voteMask);                                // roll type mask
 
    p->SendDirectMessage(&data);
}

References Roll::itemCount, Roll::itemGUID, Roll::itemid, Roll::itemRandomPropId, Roll::itemRandomSuffix, Roll::itemSlot, Roll::rollVoteMask, Player::SendDirectMessage(), and SMSG_LOOT_START_ROLL.

Referenced by NeedBeforeGreed(), and SendPendingRollsToPlayer().

SendPendingRollsToPlayer()

void Group::SendPendingRollsToPlayer	(	Player *	player,
		Map *	map
	)

{
    for (Roll* roll : RollId)
    {
        auto itr = roll->playerVote.find(player->GetGUID());
        if (itr == roll->playerVote.end())
            continue;
 
        if (itr->second != NOT_EMITED_YET)
            continue;
 
        Loot* loot = roll->getLoot();
        if (!loot)
            continue;
 
        // Get remaining time from the loot source object
        uint32 remainingTime = 60000;
        WorldObject* lootedObject = nullptr;
        if (GameObject* go = loot->sourceGameObject)
        {
            remainingTime = go->m_groupLootTimer;
            lootedObject = go;
        }
        else if (!loot->sourceWorldObjectGUID.IsEmpty())
        {
            if (Creature* creature = map->GetCreature(loot->sourceWorldObjectGUID))
            {
                remainingTime = creature->m_groupLootTimer;
                lootedObject = creature;
            }
        }
 
        bool canNeed = true;
        if (GetLootMethod() == NEED_BEFORE_GREED)
        {
            ItemTemplate const* proto = sObjectMgr->GetItemTemplate(roll->itemid);
            if (proto && lootedObject)
                canNeed = (player->CanRollForItemInLFG(proto, lootedObject) == EQUIP_ERR_OK);
        }
 
        SendLootStartRollToPlayer(remainingTime, map->GetId(), player, canNeed, *roll);
    }
}

References Player::CanRollForItemInLFG(), EQUIP_ERR_OK, Map::GetCreature(), Object::GetGUID(), Map::GetId(), GetLootMethod(), ObjectGuid::IsEmpty(), NEED_BEFORE_GREED, NOT_EMITED_YET, RollId, SendLootStartRollToPlayer(), sObjectMgr, Loot::sourceGameObject, and Loot::sourceWorldObjectGUID.

SendTargetIconList()

void Group::SendTargetIconList

(

WorldSession *

session

)

{
    if (!session)
        return;
 
    WorldPacket data(MSG_RAID_TARGET_UPDATE, (1 + TARGETICONCOUNT * 9));
    data << uint8(1);                                       // list targets
 
    for (uint8 i = 0; i < TARGETICONCOUNT; ++i)
    {
        if (!m_targetIcons[i])
            continue;
 
        data << uint8(i);
        data << m_targetIcons[i];
    }
 
    session->SendPacket(&data);
}

References m_targetIcons, MSG_RAID_TARGET_UPDATE, WorldSession::SendPacket(), and TARGETICONCOUNT.

Referenced by WorldSession::HandleRaidTargetUpdateOpcode().

SendUpdate()

void Group::SendUpdate

(

)

{
    if (sToCloud9Sidecar->ClusterModeEnabled() && !this->isBFGroup() && !this->isBGGroup())
    {
        // Group service responsible for sending these updates.
        return;
    }
 
    for (member_witerator witr = m_memberSlots.begin(); witr != m_memberSlots.end(); ++witr)
        SendUpdateToPlayer(witr->guid, &(*witr));
}

References m_memberSlots, SendUpdateToPlayer(), and sToCloud9Sidecar.

Referenced by AddMember(), Battleground::AddOrSetPlayerToCorrectBgGroup(), ChangeMembersGroup(), ConvertToLFG(), ConvertToRaid(), WorldSession::HandleGroupAssistantLeaderOpcode(), group_commandscript::HandleGroupLeaderCommand(), WorldSession::HandleGroupSetLeaderOpcode(), WorldSession::HandleLootMethodOpcode(), WorldSession::HandlePartyAssignmentOpcode(), WorldSession::LogoutPlayer(), lfg::LFGMgr::MakeNewGroup(), RemoveMember(), SetGroupMemberFlag(), SetLfgRoles(), and UpdateLooterGuid().

SendUpdateToPlayer()

void Group::SendUpdateToPlayer	(	ObjectGuid	playerGUID,
		MemberSlot *	slot = nullptr
	)

{
    Player* player = ObjectAccessor::FindConnectedPlayer(playerGUID);
 
    if (!player || player->GetGroup() != this)
        return;
 
    // if MemberSlot wasn't provided
    if (!slot)
    {
        member_witerator witr = _getMemberWSlot(playerGUID);
 
        if (witr == m_memberSlots.end()) // if there is no MemberSlot for such a player
            return;
 
        slot = &(*witr);
    }
 
    WorldPacket data(SMSG_GROUP_LIST, (1 + 1 + 1 + 1 + 1 + 4 + 8 + 4 + 4 + (GetMembersCount() - 1) * (13 + 8 + 1 + 1 + 1 + 1) + 8 + 1 + 8 + 1 + 1 + 1 + 1));
    data << uint8(m_groupType);                         // group type (flags in 3.3)
    data << uint8(slot->group);
    data << uint8(slot->flags);
    data << uint8(slot->roles);
    if (isLFGGroup())
    {
        data << uint8(sLFGMgr->GetState(m_guid) == lfg::LFG_STATE_FINISHED_DUNGEON ? 2 : 0); // FIXME - Dungeon save status? 2 = done
        data << uint32(sLFGMgr->GetDungeon(m_guid));
    }
 
    data << m_guid;
    data << uint32(m_counter++);                        // 3.3, value increases every time this packet gets sent
    data << uint32(GetMembersCount() - 1);
    for (member_citerator citr = m_memberSlots.begin(); citr != m_memberSlots.end(); ++citr)
    {
        if (slot->guid == citr->guid)
            continue;
 
        Player* member = ObjectAccessor::FindConnectedPlayer(citr->guid);
 
        uint8 onlineState = (member && !member->GetSession()->PlayerLogout()) ? MEMBER_STATUS_ONLINE : MEMBER_STATUS_OFFLINE;
        onlineState = onlineState | ((isBGGroup() || isBFGroup()) ? MEMBER_STATUS_PVP : 0);
 
        data << citr->name;
        data << citr->guid;                             // guid
        data << uint8(onlineState);                     // online-state
        data << uint8(citr->group);                     // groupid
        data << uint8(citr->flags);                     // See enum GroupMemberFlags
        data << uint8(citr->roles);                     // Lfg Roles
    }
 
    data << m_leaderGuid;                               // leader guid
 
    if (GetMembersCount() - 1)
    {
        data << uint8(m_lootMethod);                    // loot method
 
        if (m_lootMethod == MASTER_LOOT)
            data << m_masterLooterGuid;                 // master looter guid
        else
            data << uint64(0);                          // looter guid
 
        data << uint8(m_lootThreshold);                 // loot threshold
        data << uint8(m_dungeonDifficulty);             // Dungeon Difficulty
        data << uint8(m_raidDifficulty);                // Raid Difficulty
        data << uint8(m_raidDifficulty >= RAID_DIFFICULTY_10MAN_HEROIC);    // 3.3 Dynamic Raid Difficulty - 0 normal/1 heroic
    }
 
    player->SendDirectMessage(&data);
}

References _getMemberWSlot(), ObjectAccessor::FindConnectedPlayer(), Group::MemberSlot::flags, Player::GetGroup(), GetMembersCount(), Player::GetSession(), Group::MemberSlot::group, Group::MemberSlot::guid, isBFGroup(), isBGGroup(), isLFGGroup(), lfg::LFG_STATE_FINISHED_DUNGEON, m_counter, m_dungeonDifficulty, m_groupType, m_guid, m_leaderGuid, m_lootMethod, m_lootThreshold, m_masterLooterGuid, m_memberSlots, m_raidDifficulty, MASTER_LOOT, MEMBER_STATUS_OFFLINE, MEMBER_STATUS_ONLINE, MEMBER_STATUS_PVP, WorldSession::PlayerLogout(), RAID_DIFFICULTY_10MAN_HEROIC, Group::MemberSlot::roles, Player::SendDirectMessage(), sLFGMgr, and SMSG_GROUP_LIST.

Referenced by SendUpdate().

SetBattlefieldGroup()

void Group::SetBattlefieldGroup

(

Battlefield *

bf

)

{
    m_bfGroup = bg;
}

References m_bfGroup.

Referenced by Battlefield::AddOrSetPlayerToCorrectBfGroup().

SetBattlegroundGroup()

void Group::SetBattlegroundGroup

(

Battleground *

bg

)

{
    m_bgGroup = bg;
}

References m_bgGroup.

Referenced by Battleground::SetBgRaid().

SetDifficultyChangePrevention()

void Group::SetDifficultyChangePrevention

(

DifficultyPreventionChangeType

type

)

{
    _difficultyChangePreventionTime = GameTime::GetGameTime().count() + MINUTE;
    _difficultyChangePreventionType = type;
}

References _difficultyChangePreventionTime, _difficultyChangePreventionType, GameTime::GetGameTime(), and MINUTE.

Referenced by WorldSession::HandleSetRaidDifficultyOpcode(), and InstanceMap::PermBindAllPlayers().

SetDungeonDifficulty()

void Group::SetDungeonDifficulty

(

Difficulty

difficulty

)

{
    m_dungeonDifficulty = difficulty;
    if (!sToCloud9Sidecar->ClusterModeEnabled() && !isBGGroup() && !isBFGroup())
    {
        CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_GROUP_DIFFICULTY);
 
        stmt->SetData(0, uint8(m_dungeonDifficulty));
        stmt->SetData(1, GetGUID().GetCounter());
 
        CharacterDatabase.Execute(stmt);
    }
 
    for (GroupReference* itr = GetFirstMember(); itr != nullptr; itr = itr->next())
    {
        Player* player = itr->GetSource();
        player->SetDungeonDifficulty(difficulty);
        player->SendDungeonDifficulty(true);
    }
}

References CHAR_UPD_GROUP_DIFFICULTY, CharacterDatabase, GetFirstMember(), GetGUID(), isBFGroup(), isBGGroup(), m_dungeonDifficulty, GroupReference::next(), Player::SendDungeonDifficulty(), PreparedStatementBase::SetData(), Player::SetDungeonDifficulty(), and sToCloud9Sidecar.

Referenced by WorldSession::HandleSetDungeonDifficultyOpcode(), and lfg::LFGMgr::MakeNewGroup().

SetGroupMemberFlag()

void Group::SetGroupMemberFlag	(	ObjectGuid	guid,
		bool	apply,
		GroupMemberFlags	flag
	)

{
    // Assistants, main assistants and main tanks are only available in raid groups
    if (!isRaidGroup())
        return;
 
    // Check if player is really in the raid
    member_witerator slot = _getMemberWSlot(guid);
    if (slot == m_memberSlots.end())
        return;
 
    // Do flag specific actions, e.g ensure uniqueness
    switch (flag)
    {
        case MEMBER_FLAG_MAINASSIST:
            RemoveUniqueGroupMemberFlag(MEMBER_FLAG_MAINASSIST);         // Remove main assist flag from current if any.
            break;
        case MEMBER_FLAG_MAINTANK:
            RemoveUniqueGroupMemberFlag(MEMBER_FLAG_MAINTANK);           // Remove main tank flag from current if any.
            break;
        case MEMBER_FLAG_ASSISTANT:
            break;
        default:
            return;                                                      // This should never happen
    }
 
    // Switch the actual flag
    ToggleGroupMemberFlag(slot, flag, apply);
 
    // Preserve the new setting in the db
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_GROUP_MEMBER_FLAG);
 
    stmt->SetData(0, slot->flags);
    stmt->SetData(1, guid.GetCounter());
 
    CharacterDatabase.Execute(stmt);
 
    // Broadcast the changes to the group
    SendUpdate();
}

References _getMemberWSlot(), CHAR_UPD_GROUP_MEMBER_FLAG, CharacterDatabase, ObjectGuid::GetCounter(), isRaidGroup(), m_memberSlots, MEMBER_FLAG_ASSISTANT, MEMBER_FLAG_MAINASSIST, MEMBER_FLAG_MAINTANK, RemoveUniqueGroupMemberFlag(), SendUpdate(), PreparedStatementBase::SetData(), and ToggleGroupMemberFlag().

Referenced by WorldSession::HandleGroupAssistantLeaderOpcode(), and WorldSession::HandlePartyAssignmentOpcode().

SetLfgRoles()

void Group::SetLfgRoles	(	ObjectGuid	guid,
		const uint8	roles
	)

{
    member_witerator slot = _getMemberWSlot(guid);
    if (slot == m_memberSlots.end())
        return;
 
    slot->roles = roles;
    SendUpdate();
}

References _getMemberWSlot(), m_memberSlots, and SendUpdate().

Referenced by lfg::LFGMgr::MakeNewGroup().

SetLooterGuid()

void Group::SetLooterGuid

(

ObjectGuid

guid

)

{
    m_looterGuid = guid;
}

References m_looterGuid.

Referenced by UpdateLooterGuid().

SetLootMethod()

void Group::SetLootMethod

(

LootMethod

method

)

{
    m_lootMethod = method;
}

References m_lootMethod.

Referenced by WorldSession::HandleLootMethodOpcode().

SetLootThreshold()

void Group::SetLootThreshold

(

ItemQualities

threshold

)

{
    m_lootThreshold = threshold;
}

References m_lootThreshold.

Referenced by WorldSession::HandleLootMethodOpcode().

SetMasterLooterGuid()

void Group::SetMasterLooterGuid

(

ObjectGuid

guid

)

{
    m_masterLooterGuid = guid;
}

References m_masterLooterGuid.

Referenced by WorldSession::HandleLootMethodOpcode().

SetRaidDifficulty()

void Group::SetRaidDifficulty

(

Difficulty

difficulty

)

{
    m_raidDifficulty = difficulty;
    if (!sToCloud9Sidecar->ClusterModeEnabled() && !isBGGroup() && !isBFGroup())
    {
        CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_GROUP_RAID_DIFFICULTY);
 
        stmt->SetData(0, uint8(m_raidDifficulty));
        stmt->SetData(1, GetGUID().GetCounter());
 
        CharacterDatabase.Execute(stmt);
    }
 
    for (GroupReference* itr = GetFirstMember(); itr != nullptr; itr = itr->next())
    {
        Player* player = itr->GetSource();
        player->SetRaidDifficulty(difficulty);
        player->SendRaidDifficulty(true);
    }
}

References CHAR_UPD_GROUP_RAID_DIFFICULTY, CharacterDatabase, GetFirstMember(), GetGUID(), isBFGroup(), isBGGroup(), m_raidDifficulty, GroupReference::next(), Player::SendRaidDifficulty(), PreparedStatementBase::SetData(), Player::SetRaidDifficulty(), and sToCloud9Sidecar.

Referenced by WorldSession::HandleSetRaidDifficultyOpcode().

SetTargetIcon()

void Group::SetTargetIcon	(	uint8	id,
		ObjectGuid	whoGuid,
		ObjectGuid	targetGuid
	)

{
    if (id >= TARGETICONCOUNT)
        return;
 
    // clean other icons
    if (targetGuid)
        for (int i = 0; i < TARGETICONCOUNT; ++i)
            if (m_targetIcons[i] == targetGuid)
                SetTargetIcon(i, ObjectGuid::Empty, ObjectGuid::Empty);
 
    m_targetIcons[id] = targetGuid;
 
    WorldPacket data(MSG_RAID_TARGET_UPDATE, (1 + 8 + 1 + 8));
    data << uint8(0);                                       // set targets
    data << whoGuid;
    data << uint8(id);
    data << targetGuid;
    BroadcastPacket(&data, true);
}

References BroadcastPacket(), ObjectGuid::Empty, m_targetIcons, MSG_RAID_TARGET_UPDATE, SetTargetIcon(), and TARGETICONCOUNT.

Referenced by WorldSession::HandleRaidTargetUpdateOpcode(), and SetTargetIcon().

SubGroupCounterDecrease()

void Group::SubGroupCounterDecrease ( uint8  subgroup )

protected

{
    if (m_subGroupsCounts)
        --m_subGroupsCounts[subgroup];
}

References m_subGroupsCounts.

Referenced by ChangeMembersGroup(), and RemoveMember().

SubGroupCounterIncrease()

void Group::SubGroupCounterIncrease ( uint8  subgroup )

protected

{
    if (m_subGroupsCounts)
        ++m_subGroupsCounts[subgroup];
}

References m_subGroupsCounts.

Referenced by AddMember(), AddMemberWithGuid(), ChangeMembersGroup(), and LoadMemberFromDB().

ToggleGroupMemberFlag()

void Group::ToggleGroupMemberFlag ( member_witerator  slot, uint8  flag, bool  apply  )

protected

{
    if (apply)
        slot->flags |= flag;
    else
        slot->flags &= ~flag;
}

Referenced by ChangeLeader(), and SetGroupMemberFlag().

UpdateLooterGuid()

void Group::UpdateLooterGuid	(	WorldObject *	pLootedObject,
		bool	ifneed = false
	)

{
    // round robin style looting applies for all low
    // quality items in each loot method except free for all
    if (GetLootMethod() == FREE_FOR_ALL)
        return;
 
    ObjectGuid oldLooterGUID = GetLooterGuid();
    member_citerator guid_itr = _getMemberCSlot(oldLooterGUID);
    if (guid_itr != m_memberSlots.end())
    {
        if (ifneed)
        {
            // not update if only update if need and ok
            Player* looter = ObjectAccessor::FindPlayer(guid_itr->guid);
            if (looter && looter->IsAtLootRewardDistance(pLootedObject))
                return;
        }
        ++guid_itr;
    }
 
    // search next after current
    Player* pNewLooter = nullptr;
    for (member_citerator itr = guid_itr; itr != m_memberSlots.end(); ++itr)
    {
        if (Player* player = ObjectAccessor::FindPlayer(itr->guid))
            if (player->IsAtLootRewardDistance(pLootedObject))
            {
                pNewLooter = player;
                break;
            }
    }
 
    if (!pNewLooter)
    {
        // search from start
        for (member_citerator itr = m_memberSlots.begin(); itr != guid_itr; ++itr)
        {
            if (Player* player = ObjectAccessor::FindPlayer(itr->guid))
                if (player->IsAtLootRewardDistance(pLootedObject))
                {
                    pNewLooter = player;
                    break;
                }
        }
    }
 
    if (pNewLooter)
    {
        if (oldLooterGUID != pNewLooter->GetGUID())
        {
            SetLooterGuid(pNewLooter->GetGUID());
            SendUpdate();
        }
    }
    else
    {
        SetLooterGuid(ObjectGuid::Empty);
        SendUpdate();
    }
}

References _getMemberCSlot(), ObjectGuid::Empty, ObjectAccessor::FindPlayer(), FREE_FOR_ALL, Object::GetGUID(), GetLooterGuid(), GetLootMethod(), Player::IsAtLootRewardDistance(), m_memberSlots, SendUpdate(), and SetLooterGuid().

Referenced by Unit::Kill(), and Player::SendLoot().

UpdatePlayerOutOfRange()

void Group::UpdatePlayerOutOfRange

(

Player *

player

)

{
    if (!player || !player->IsInWorld())
        return;
 
    WorldPacket data;
    player->GetSession()->BuildPartyMemberStatsChangedPacket(player, &data);
 
    for (GroupReference* itr = GetFirstMember(); itr != nullptr; itr = itr->next())
    {
        Player* member = itr->GetSource();
        if (member && (!member->IsInMap(player) || !member->IsWithinDist(player, member->GetSightRange(player), false)))
            member->SendDirectMessage(&data);
    }
}

References WorldSession::BuildPartyMemberStatsChangedPacket(), GetFirstMember(), Player::GetSession(), Player::GetSightRange(), WorldObject::IsInMap(), Object::IsInWorld(), WorldObject::IsWithinDist(), GroupReference::next(), and Player::SendDirectMessage().

Referenced by AddMember().

Friends And Related Symbol Documentation

ToCloud9GroupHooks

friend class ToCloud9GroupHooks

friend

Member Data Documentation

_difficultyChangePreventionTime

uint32 Group::_difficultyChangePreventionTime

protected

Referenced by GetDifficultyChangePreventionTime(), and SetDifficultyChangePrevention().

_difficultyChangePreventionType

DifficultyPreventionChangeType Group::_difficultyChangePreventionType

protected

Referenced by GetDifficultyChangePreventionReason(), and SetDifficultyChangePrevention().

CustomData

DataMap Group::CustomData

m_bfGroup

Battlefield* Group::m_bfGroup

protected

Referenced by isBFGroup(), and SetBattlefieldGroup().

m_bgGroup

Battleground* Group::m_bgGroup

protected

Referenced by isBGGroup(), SetBattlegroundGroup(), and ~Group().

m_counter

uint32 Group::m_counter

protected

Referenced by ForcedDisband(), RemoveMember(), and SendUpdateToPlayer().

m_dungeonDifficulty

Difficulty Group::m_dungeonDifficulty

protected

Referenced by Create(), GetDifficulty(), GetDungeonDifficulty(), LoadGroupFromDB(), ToCloud9GroupHooks::OnGroupCreated(), SendUpdateToPlayer(), and SetDungeonDifficulty().

m_groupType

GroupType Group::m_groupType

protected

Referenced by ConvertToLFG(), ConvertToRaid(), Create(), GetGroupType(), isLFGGroup(), isRaidGroup(), LoadGroupFromDB(), ToCloud9GroupHooks::OnGroupCreated(), and SendUpdateToPlayer().

m_guid

ObjectGuid Group::m_guid

protected

Referenced by Create(), ForcedDisband(), GetGUID(), LoadGroupFromDB(), ToCloud9GroupHooks::OnGroupCreated(), RemoveMember(), and SendUpdateToPlayer().

m_invitees

InvitesList Group::m_invitees

protected

Referenced by AddInvite(), GetInvited(), GetInvited(), GetInviteeCount(), RemoveAllInvites(), and RemoveInvite().

m_leaderGuid

ObjectGuid Group::m_leaderGuid

protected

Referenced by AddLeaderInvite(), ChangeLeader(), Create(), GetLeader(), GetLeaderGUID(), LoadGroupFromDB(), ToCloud9GroupHooks::OnGroupCreated(), RemoveMember(), and SendUpdateToPlayer().

m_leaderName

std::string Group::m_leaderName

protected

Referenced by AddLeaderInvite(), ChangeLeader(), Create(), GetLeaderName(), LoadGroupFromDB(), and ToCloud9GroupHooks::OnGroupCreated().

m_lfgGroupFlags

uint8 Group::m_lfgGroupFlags

protected

Referenced by AddLfgBuffFlag(), AddLfgHeroicFlag(), AddLfgRandomInstanceFlag(), IsLfgHeroic(), IsLfgRandomInstance(), and IsLfgWithBuff().

m_looterGuid

ObjectGuid Group::m_looterGuid

protected

Referenced by Create(), GetLooterGuid(), LoadGroupFromDB(), ToCloud9GroupHooks::OnGroupCreated(), and SetLooterGuid().

m_lootMethod

LootMethod Group::m_lootMethod

protected

Referenced by ConvertToLFG(), Create(), GetLootMethod(), LoadGroupFromDB(), ToCloud9GroupHooks::OnGroupCreated(), SendUpdateToPlayer(), and SetLootMethod().

m_lootThreshold

ItemQualities Group::m_lootThreshold

protected

Referenced by Create(), GetLootThreshold(), GroupLoot(), LoadGroupFromDB(), NeedBeforeGreed(), ToCloud9GroupHooks::OnGroupCreated(), SendUpdateToPlayer(), and SetLootThreshold().

m_masterLooterGuid

ObjectGuid Group::m_masterLooterGuid

protected

Referenced by Create(), GetMasterLooterGuid(), LoadGroupFromDB(), ToCloud9GroupHooks::OnGroupCreated(), SendUpdateToPlayer(), and SetMasterLooterGuid().

m_maxEnchantingLevel

uint32 Group::m_maxEnchantingLevel

protected

Referenced by AddMember(), GroupLoot(), NeedBeforeGreed(), and ResetMaxEnchantingLevel().

m_memberMgr

GroupRefMgr Group::m_memberMgr

protected

Referenced by GetFirstMember(), GetFirstMember(), LinkMember(), and RemoveMember().

m_memberSlots

MemberSlotList Group::m_memberSlots

protected

Referenced by _getMemberCSlot(), _getMemberWSlot(), _initRaidSubGroupsCounter(), AddMember(), AddMemberWithGuid(), BroadcastGroupUpdate(), ChangeLeader(), ChangeMembersGroup(), CheckLevelForRaid(), ConvertToRaid(), ForcedDisband(), GetMemberGroup(), GetMemberGUID(), GetMembersCount(), GetMemberSlots(), IsAssistant(), IsFull(), IsMember(), LoadMemberFromDB(), OfflineReadyCheck(), RemoveMember(), RemoveUniqueGroupMemberFlag(), ResetMaxEnchantingLevel(), SameSubGroup(), SameSubGroup(), SendUpdate(), SendUpdateToPlayer(), SetGroupMemberFlag(), SetLfgRoles(), and UpdateLooterGuid().

m_raidDifficulty

Difficulty Group::m_raidDifficulty

protected

Referenced by Create(), GetDifficulty(), GetRaidDifficulty(), LoadGroupFromDB(), ToCloud9GroupHooks::OnGroupCreated(), SendUpdateToPlayer(), and SetRaidDifficulty().

m_subGroupsCounts

uint8* Group::m_subGroupsCounts

protected

Referenced by _initRaidSubGroupsCounter(), AddMember(), AddMemberWithGuid(), HasFreeSlotSubGroup(), SubGroupCounterDecrease(), SubGroupCounterIncrease(), and ~Group().

m_targetIcons

ObjectGuid Group::m_targetIcons[TARGETICONCOUNT]

protected

Referenced by AddMember(), Create(), GetTargetIcon(), LoadGroupFromDB(), SendTargetIconList(), and SetTargetIcon().

RollId

Rolls Group::RollId

protected

Referenced by CountRollVote(), CountTheRoll(), EndRoll(), ForcedDisband(), GetRoll(), GetRolls(), GroupLoot(), isRollLootActive(), NeedBeforeGreed(), RemovePlayerFromRolls(), SendPendingRollsToPlayer(), and ~Group().

---

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

• azerothcore-wotlk/src/server/game/Groups/Group.h
• azerothcore-wotlk/src/server/game/Groups/Group.cpp