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

bool	RemoveMember (ObjectGuid guid, const RemoveMethod &method=GROUP_REMOVEMETHOD_DEFAULT, ObjectGuid kicker=ObjectGuid::Empty, const char *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

const char *	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 (const std::string &name)

bool	IsAssistant (ObjectGuid guid) const

Player *	GetInvited (ObjectGuid guid) const

Player *	GetInvited (const std::string &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	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)

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, const Roll &r)

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

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

void	SendLootRollWon (ObjectGuid SourceGuid, ObjectGuid TargetGuid, uint8 RollNumber, uint8 RollType, const Roll &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, Map *allowedMap)

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

void	EndRoll (Loot loot, Map allowedMap)

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)

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(), 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(), Player::IsGameMaster(), Player::m_InstanceValid, and sMapStore.

Referenced by Disband(), 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(), and LoadGroupFromDB().

◆ 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

310{ m_lfgGroupFlags |= GROUP_LFG_FLAG_APPLY_RANDOM_BUFF; }

GROUP_LFG_FLAG_APPLY_RANDOM_BUFF

@ GROUP_LFG_FLAG_APPLY_RANDOM_BUFF

Definition: Group.h:126

Group::m_lfgGroupFlags

uint8 m_lfgGroupFlags

Definition: Group.h:356

References GROUP_LFG_FLAG_APPLY_RANDOM_BUFF, and m_lfgGroupFlags.

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

◆ AddLfgHeroicFlag()

void Group::AddLfgHeroicFlag ( )

inline

312{ m_lfgGroupFlags |= GROUP_LFG_FLAG_IS_HEROIC; }

GROUP_LFG_FLAG_IS_HEROIC

@ GROUP_LFG_FLAG_IS_HEROIC

Definition: Group.h:128

References GROUP_LFG_FLAG_IS_HEROIC, and m_lfgGroupFlags.

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

◆ AddLfgRandomInstanceFlag()

void Group::AddLfgRandomInstanceFlag ( )

inline

311{ m_lfgGroupFlags |= GROUP_LFG_FLAG_IS_RANDOM_INSTANCE; }

GROUP_LFG_FLAG_IS_RANDOM_INSTANCE

@ GROUP_LFG_FLAG_IS_RANDOM_INSTANCE

Definition: Group.h:127

References GROUP_LFG_FLAG_IS_RANDOM_INSTANCE, and m_lfgGroupFlags.

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

◆ AddMember()

bool Group::AddMember ( Player * player )

{
    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     = 0;
    m_memberSlots.push_back(member);
 
    if (!isBGGroup() && !isBFGroup())
    {
        sCharacterCache->UpdateCharacterGroup(player->GetGUID(), GetGUID());
    }
 
    SubGroupCounterIncrease(subGroup);
 
    player->SetGroupInvite(nullptr);
    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(), 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::SetGroupInvite(), Player::SetGroupUpdateFlag(), Player::SetOriginalGroup(), Player::SetRaidDifficulty(), SKILL_ENCHANTING, sScriptMgr, SubGroupCounterIncrease(), TARGETICONCOUNT, UF_FLAG_PARTY_MEMBER, Player::UpdateForQuestWorldObjects(), and UpdatePlayerOutOfRange().

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

◆ 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->GetSession()->SendPacket(packet);
    }
}

References GetFirstMember(), Player::GetGroup(), Object::GetGUID(), Player::GetSession(), GroupReference::next(), and WorldSession::SendPacket().

Referenced by ChangeLeader(), WorldSession::HandleMessagechatOpcode(), WorldSession::HandleMinimapPingOpcode(), 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->GetSession()->SendPacket(packet);
    }
}

References GetFirstMember(), Object::GetGUID(), Player::GetSession(), IsAssistant(), IsLeader(), GroupReference::next(), and WorldSession::SendPacket().

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())
            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() == 609 && !member->IsGameMaster() && !member->HasSpell(50977))
            return ERR_GROUP_JOIN_BATTLEGROUND_FAIL;
 
        if (!member->GetBGAccessByLevel(bgTemplate->GetBgTypeID()))
        {
            return ERR_BATTLEGROUND_JOIN_TIMED_OUT;
        }
    }
 
    // 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::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, PvPDifficultyEntry::mapId, BattlemasterListEntry::maxGroupSize, GroupReference::next(), 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);
    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, m_leaderGuid); // This hook should be executed at the end - Not used anywhere in the original core
}

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 (!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(), and sLFGMgr.

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, nullptr);
        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 RemoveMember().

◆ CountTheRoll()

void Group::CountTheRoll	(	Rolls::iterator	roll,
		Map *	allowedMap
	)

{
    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 || (allowedMap != nullptr && player->FindMap() != allowedMap))
                {
                    --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(ObjectGuid::Empty, 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->OnGroupRollRewardItem(player, _item, _item->GetCount(), NEED, roll);
                        player->UpdateLootAchievements(item, roll->getLoot());
                    }
                    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) // pussywizard: if (roll->totalNeed == 0 && ...), not else if, because numbers can be modified above if player is on a different map
    {
        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 || (allowedMap != nullptr && player->FindMap() != allowedMap))
                {
                    --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(ObjectGuid::Empty, 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->OnGroupRollRewardItem(player, _item, _item->GetCount(), GREED, roll);
                            player->UpdateLootAchievements(item, roll->getLoot());
                        }
                        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) // pussywizard: if, not else, because numbers can be modified above if player is on a different map
    {
        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)
    {
        const GameObjectTemplate* 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(), WorldObject::FindMap(), ObjectAccessor::FindPlayer(), GAMEOBJECT_TYPE_CHEST, LootItem::GetAllowedLooters(), Item::GetCount(), Object::GetGUID(), Roll::getLoot(), Loot::GetMaxSlotInLootFor(), GO_JUST_DEACTIVATED, GREED, LootItem::is_blocked, LootItem::is_looted, Loot::isLooted(), Reference< TO, FROM >::isValid(), 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(), sObjectMgr, sScriptMgr, Player::StoreNewItem(), Roll::totalGreed, Roll::totalNeed, GameObjectTemplate::type, Loot::unlootedCount, Player::UpdateAchievementCriteria(), Player::UpdateLootAchievements(), and urand().

Referenced by CountRollVote(), and EndRoll().

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

{
    sScriptMgr->OnGroupDisband(this);
 
    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->GetSession()->SendPacket(&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->GetSession()->SendPacket(&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, ObjectAccessor::FindConnectedPlayer(), Player::GetGroup(), GetGUID(), WorldObject::GetInstanceId(), Player::GetOriginalGroup(), Player::GetSession(), WorldPacket::Initialize(), INSTANCE_RESET_GROUP_LEAVE, isBFGroup(), isBGGroup(), isRaidGroup(), m_counter, m_guid, m_memberSlots, RemoveAllInvites(), Player::RemoveFromBattlegroundOrBattlefieldRaid(), Player::ResetInstances(), RollId, sCharacterCache, WorldSession::SendPacket(), PreparedStatementBase::SetData(), Player::SetGroup(), Player::SetOriginalGroup(), sGroupMgr, sInstanceSaveMgr, SMSG_GROUP_DESTROYED, SMSG_GROUP_LIST, sScriptMgr, and Player::UpdateForQuestWorldObjects().

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().

◆ EndRoll()

void Group::EndRoll	(	Loot *	loot,
		Map *	allowedMap
	)

{
    for (Rolls::iterator itr = RollId.begin(); itr != RollId.end();)
    {
        if ((*itr)->getLoot() == pLoot)
        {
            CountTheRoll(itr, allowedMap);           //i don't have to edit player votes, who didn't vote ... he will pass
            itr = RollId.begin();
        }
        else
            ++itr;
    }
}

References CountTheRoll(), and RollId.

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

◆ 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

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

243{ return m_memberMgr.getFirst(); }

Group::m_memberMgr

GroupRefMgr m_memberMgr

Definition: Group.h:337

GroupRefMgr::getFirst

GroupReference * getFirst()

Definition: GroupRefMgr.h:30

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(), misc_commandscript::HandleGroupSummonCommand(), lfg_commandscript::HandleLfgGroupInfoCommand(), WorldSession::HandleLfgPartyLockInfoRequestOpcode(), WorldSession::HandleLootMoneyOpcode(), WorldSession::HandleSetDungeonDifficultyOpcode(), WorldSession::HandleSetRaidDifficultyOpcode(), tele_commandscript::HandleTeleGroupCommand(), lfg::LFGMgr::JoinLfg(), lfg::LFGMgr::MakeNewGroup(), MasterLoot(), NeedBeforeGreed(), lfg::LFGPlayerScript::OnMapChanged(), SetDungeonDifficulty(), SetRaidDifficulty(), PetAI::UpdateAllies(), and UpdatePlayerOutOfRange().

◆ GetFirstMember() [2/2]

GroupReference const * Group::GetFirstMember ( ) const

inline

244{ 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(), Battlefield::AddOrSetPlayerToCorrectBfGroup(), npc_coren_direbrew::CanBeSeen(), go_loosely_turned_soil::go_loosely_turned_soilAI::CanBeSeen(), Player::CanUninviteFromGroup(), ChangeLeader(), ConvertToLFG(), ConvertToRaid(), ArenaTeam::DelMember(), Disband(), 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(), lfg::LFGGroupScript::OnInviteMember(), lfg::LFGPlayerScript::OnLogin(), lfg::LFGPlayerScript::OnLogout(), 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 ( const std::string & 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.

◆ GetInvited() [2/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().

◆ GetInviteeCount()

uint32 Group::GetInviteeCount ( ) const

inline

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

◆ GetLeaderName()

const char * Group::GetLeaderName ( ) const

{
    return m_leaderName.c_str();
}

References m_leaderName.

Referenced by ChatLogScript::OnChat(), 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 WorldSession::HandleLootMasterGiveOpcode(), Player::isAllowedToLoot(), Unit::Kill(), Player::SendLoot(), SendLooter(), 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 LootItem::AllowedForPlayer(), 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 ( const std::string & 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

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

242{ 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().

◆ 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);
 
            //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;
                if (member->IsAtLootRewardDistance(pLootedObject))
                {
                    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);
 
        //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;
 
            if (member->IsAtLootRewardDistance(pLootedObject))
            {
                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(), ObjectGuid::GetCounter(), GetFirstMember(), GetGUID(), Object::GetGUID(), WorldLocation::GetMapId(), Player::GetPassOnGroupLoot(), Player::GetSession(), Player::IsAtLootRewardDistance(), 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(), Battlefield::AddOrSetPlayerToCorrectBfGroup(), Battleground::AddOrSetPlayerToCorrectBgGroup(), ChangeLeader(), ChangeMembersGroup(), ConvertToLFG(), ConvertToRaid(), Create(), Disband(), misc_commandscript::HandleSkirmishCommand(), lfg::LFGMgr::JoinLfg(), LoadMemberFromDB(), RemoveMember(), ResetInstances(), SendUpdateToPlayer(), SetDungeonDifficulty(), and SetRaidDifficulty().

◆ isBGGroup()

bool Group::isBGGroup ( ) const

◆ 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().

◆ 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::OnLogout(), lfg::LFGGroupScript::OnRemoveMember(), MapMgr::PlayerCannotEnter(), RemoveMember(), ResetInstances(), SendUpdateToPlayer(), and lfg::LFGMgr::TeleportPlayer().

◆ IsLfgHeroic()

bool Group::IsLfgHeroic ( ) const

inline

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

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

313{ 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::OnMapChanged().

◆ IsMember()

bool Group::IsMember ( ObjectGuid guid ) const

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

References _getMemberCSlot(), and m_memberSlots.

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

◆ isRaidGroup()

bool Group::isRaidGroup ( ) const

◆ 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, 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;
    for (GroupReference* itr = GetFirstMember(); itr != nullptr; itr = itr->next())
    {
        Player* looter = itr->GetSource();
        if (!looter->IsInWorld())
        {
            continue;
        }
 
        if (looter->IsAtLootRewardDistance(pLootedObject))
        {
            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->GetSession()->SendPacket(&data);
    }
}

References GetFirstMember(), 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);
 
            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;
                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);
 
        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(), ObjectGuid::GetCounter(), GetFirstMember(), GetGUID(), Object::GetGUID(), WorldLocation::GetMapId(), Player::GetPassOnGroupLoot(), Player::GetSession(), ItemTemplate::HasFlag2(), Player::IsAtGroupRewardDistance(), 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 (InvitesList::iterator itr = m_invitees.begin(); itr != m_invitees.end(); ++itr)
        if (*itr)
            (*itr)->SetGroupInvite(nullptr);
 
    m_invitees.clear();
}

References m_invitees.

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

◆ RemoveInvite()

void Group::RemoveInvite ( Player * player )

{
    if (player)
    {
        if (!m_invitees.empty())
            m_invitees.erase(player);
        player->SetGroupInvite(nullptr);
    }
}

References m_invitees, and Player::SetGroupInvite().

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

◆ RemoveMember()

bool Group::RemoveMember	(	ObjectGuid	guid,
		const RemoveMethod &	method = `GROUP_REMOVEMETHOD_DEFAULT`,
		ObjectGuid	kicker = `ObjectGuid::Empty`,
		const char *	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)
    if (GetMembersCount() > ((isBGGroup() || isLFGGroup() || isBFGroup()) ? 1u : 2u))
    {
        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();
            }
 
            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
        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);
 
            // Xinef: itr can be erased inside
            // Xinef: player is removed from all vote lists so it will not pass above playerVote == playerVote.end statement during second iteration
            if (CountRollVote(guid, roll->itemGUID, MAX_ROLL_TYPE))
                it = RollId.begin();
            else
                ++it;
        }
 
        // 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
    {
        sScriptMgr->OnGroupRemoveMember(this, guid, method, kicker, reason);
        Disband();
        return false;
    }
}

References _getMemberWSlot(), _homebindIfInstance(), BroadcastGroupUpdate(), ChangeLeader(), CHAR_DEL_GROUP_MEMBER, CharacterDatabase, CountRollVote(), Disband(), DISENCHANT, ObjectAccessor::FindConnectedPlayer(), ObjectGuid::GetCounter(), GetGUID(), GetLeaderGUID(), WorldLocation::GetMapId(), GetMembersCount(), Player::GetOriginalGroup(), Player::GetSession(), LinkedListHead::getSize(), Player::GetSkillValue(), GREED, GROUP_REMOVEMETHOD_KICK, GROUP_REMOVEMETHOD_KICK_LFG, WorldPacket::Initialize(), INSTANCE_RESET_GROUP_LEAVE, Unit::IsAlive(), isBFGroup(), isBGGroup(), isLFGGroup(), Roll::itemGUID, lfg::LFG_STATE_NONE, m_counter, m_guid, m_leaderGuid, m_memberMgr, m_memberSlots, MAX_ROLL_TYPE, NEED, NOT_VALID, PASS, Roll::playerVote, Player::RemoveFromBattlegroundOrBattlefieldRaid(), Player::ResetInstances(), ResetMaxEnchantingLevel(), RollId, sCharacterCache, WorldSession::SendPacket(), SendUpdate(), PreparedStatementBase::SetData(), Player::SetGroup(), Player::SetOriginalGroup(), SKILL_ENCHANTING, sLFGMgr, SMSG_GROUP_LIST, SMSG_GROUP_UNINVITE, sScriptMgr, SubGroupCounterDecrease(), Roll::totalGreed, Roll::totalNeed, Roll::totalPass, Roll::totalPlayersRolling, and Player::UpdateForQuestWorldObjects().

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

◆ 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(0, 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(0, 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, 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->GetSession()->SendPacket(&data);
    }
}

References ObjectAccessor::FindConnectedPlayer(), Player::GetSession(), Roll::itemGUID, Roll::itemid, Roll::itemRandomPropId, Roll::itemRandomSuffix, Roll::itemSlot, NOT_VALID, Roll::playerVote, WorldSession::SendPacket(), 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,
		const Roll &	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->GetSession()->SendPacket(&data);
    }
}

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

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

◆ SendLootRollWon()

void Group::SendLootRollWon	(	ObjectGuid	SourceGuid,
		ObjectGuid	TargetGuid,
		uint8	RollNumber,
		uint8	RollType,
		const Roll &	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->GetSession()->SendPacket(&data);
    }
}

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

Referenced by CountTheRoll().

◆ SendLootStartRoll()

void Group::SendLootStartRoll	(	uint32	CountDown,
		uint32	mapid,
		const Roll &	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->GetSession()->SendPacket(&data);
    }
}

References ObjectAccessor::FindConnectedPlayer(), Player::GetSession(), Roll::itemCount, Roll::itemGUID, Roll::itemid, Roll::itemRandomPropId, Roll::itemRandomSuffix, Roll::itemSlot, NOT_EMITED_YET, Roll::playerVote, Roll::rollVoteMask, WorldSession::SendPacket(), 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->GetSession()->SendPacket(&data);
}

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

Referenced by NeedBeforeGreed().

◆ 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 ( )

{
    for (member_witerator witr = m_memberSlots.begin(); witr != m_memberSlots.end(); ++witr)
        SendUpdateToPlayer(witr->guid, &(*witr));
}

References m_memberSlots, and SendUpdateToPlayer().

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->GetSession()->SendPacket(&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, WorldSession::SendPacket(), 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 (!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(), and Player::SetDungeonDifficulty().

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 (!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(), and Player::SetRaidDifficulty().

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(), 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->GetSession()->SendPacket(&data);
    }
}

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

Referenced by AddMember().

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 Disband(), RemoveMember(), and SendUpdateToPlayer().

◆ m_dungeonDifficulty

Difficulty Group::m_dungeonDifficulty

protected

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

◆ m_groupType

GroupType Group::m_groupType

protected

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

◆ m_guid

ObjectGuid Group::m_guid

protected

Referenced by Create(), Disband(), GetGUID(), LoadGroupFromDB(), RemoveMember(), and SendUpdateToPlayer().

◆ m_invitees

InvitesList Group::m_invitees

protected

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

◆ m_leaderGuid

ObjectGuid Group::m_leaderGuid

protected

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

◆ m_leaderName

std::string Group::m_leaderName

protected

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

◆ 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(), and SetLooterGuid().

◆ m_lootMethod

LootMethod Group::m_lootMethod

protected

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

◆ m_lootThreshold

ItemQualities Group::m_lootThreshold

protected

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

◆ m_masterLooterGuid

ObjectGuid Group::m_masterLooterGuid

protected

Referenced by Create(), GetMasterLooterGuid(), LoadGroupFromDB(), 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(), LinkMember(), and RemoveMember().

◆ m_memberSlots

◆ m_raidDifficulty

Difficulty Group::m_raidDifficulty

protected

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

◆ m_subGroupsCounts

uint8* Group::m_subGroupsCounts

protected

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

◆ m_targetIcons

ObjectGuid Group::m_targetIcons[TARGETICONCOUNT]

protected

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

◆ RollId

Rolls Group::RollId

protected

Referenced by CountRollVote(), CountTheRoll(), Disband(), EndRoll(), GetRoll(), GroupLoot(), isRollLootActive(), NeedBeforeGreed(), RemoveMember(), and ~Group().

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

Classes

Public Types

Public Member Functions

Public Attributes

Protected Types

Protected Member Functions

Protected Attributes

Detailed Description

Member Typedef Documentation

◆ InvitesList

◆ member_citerator

◆ member_witerator

◆ MemberSlotList

◆ Rolls

Constructor & Destructor Documentation

◆ Group()

◆ ~Group()

Member Function Documentation

◆ _cancelHomebindIfInstance()

◆ _getMemberCSlot()

◆ _getMemberWSlot()

◆ _homebindIfInstance()

◆ _initRaidSubGroupsCounter()

◆ AddInvite()

◆ AddLeaderInvite()

◆ AddLfgBuffFlag()

◆ AddLfgHeroicFlag()

◆ AddLfgRandomInstanceFlag()

◆ AddMember()

◆ BroadcastGroupUpdate()

◆ BroadcastPacket()

◆ BroadcastReadyCheck()

◆ CanJoinBattlegroundQueue()

◆ ChangeLeader()

◆ ChangeMembersGroup()

◆ CheckLevelForRaid()

◆ ConvertToLFG()

◆ ConvertToRaid()

◆ CountRollVote()

◆ CountTheRoll()

◆ Create()

◆ Disband()

◆ DoForAllMembers()

◆ EndRoll()

◆ GetDifficulty()

◆ GetDifficultyChangePreventionReason()

◆ GetDifficultyChangePreventionTime()

◆ GetDungeonDifficulty()

◆ GetFirstMember() [1/2]

◆ GetFirstMember() [2/2]

◆ GetGroupType()

◆ GetGUID()

◆ GetInvited() [1/2]

◆ GetInvited() [2/2]

◆ GetInviteeCount()

◆ GetLeader()

◆ GetLeaderGUID()

◆ GetLeaderName()

◆ GetLooterGuid()

◆ GetLootMethod()

◆ GetLootThreshold()

◆ GetMasterLooterGuid()

◆ GetMemberGroup()

◆ GetMemberGUID()

◆ GetMembersCount()

◆ GetMemberSlots()

◆ GetRaidDifficulty()

◆ GetRoll()

◆ GroupLoot()

◆ HasFreeSlotSubGroup()

◆ InInstance()

◆ IsAssistant()

◆ isBFGroup()

◆ isBGGroup()

◆ IsCreated()

◆ IsFull()

◆ IsLeader()

◆ isLFGGroup()

◆ IsLfgHeroic()

◆ IsLfgRandomInstance()