#include "LFGMgr.h"

Public Member Functions
void	Update (uint32 diff, uint8 task)

void	FinishDungeon (ObjectGuid gguid, uint32 dungeonId, const Map *currMap)
	Finish the dungeon for the given group. All check are performed using internal lfg data.

void	LoadRewards ()
	Loads rewards for random dungeons.

void	LoadLFGDungeons (bool reload=false)
	Loads dungeons from dbc and adds teleport coords.

LfgDungeonSet	FilterCooldownDungeons (LfgDungeonSet const &dungeons, LfgRolesMap const &players)
	Filters out recently completed dungeons from the proposal set for the given players.

void	ClearDungeonCooldowns ()
	Clears all dungeon cooldowns for all players.

bool	selectedRandomLfgDungeon (ObjectGuid guid)
	Check if given guid applied for random dungeon.

bool	inLfgDungeonMap (ObjectGuid guid, uint32 map, Difficulty difficulty)
	Check if given guid applied for given map and difficulty. Used to know.

LfgDungeonSet const &	GetSelectedDungeons (ObjectGuid guid)
	Get selected dungeons.

LfgState	GetState (ObjectGuid guid)
	Get current lfg state.

uint32	GetDungeon (ObjectGuid guid, bool asId=true)
	Get current dungeon.

uint32	GetDungeonMapId (ObjectGuid guid)
	Get the map id of the current dungeon.

uint8	GetKicksLeft (ObjectGuid gguid)
	Get kicks left in current group.

void	_LoadFromDB (Field *fields, ObjectGuid guid)
	Load Lfg group info from DB.

void	SetupGroupMember (ObjectGuid guid, ObjectGuid gguid)
	Initializes player data after loading group data from DB.

uint32	GetLFGDungeonEntry (uint32 id)
	Return Lfg dungeon entry for given dungeon id.

uint8	GetRoles (ObjectGuid guid)
	Get current player roles.

std::string const &	GetComment (ObjectGuid gguid)
	Get current player comment (used for LFR)

uint32	GetOptions ()
	Gets current lfg options.

void	SetOptions (uint32 options)
	Sets new lfg options.

bool	isOptionEnabled (uint32 option)
	Checks if given lfg option is enabled.

void	Clean ()
	Clears queue - Only for internal testing.

ObjectGuid	GetLeader (ObjectGuid guid)
	Get leader of the group (using internal data)

void	InitializeLockedDungeons (Player player, Group const group=nullptr)
	Initializes locked dungeons for given player (called at login or level change)

void	SetTeam (ObjectGuid guid, TeamId teamId)
	Sets player team.

void	SetGroup (ObjectGuid guid, ObjectGuid group)
	Sets player group.

ObjectGuid	GetGroup (ObjectGuid guid)
	Gets player group.

void	SetLeader (ObjectGuid gguid, ObjectGuid leader)
	Sets the leader of the group.

void	RemoveGroupData (ObjectGuid guid)
	Removes saved group data.

uint8	RemovePlayerFromGroup (ObjectGuid gguid, ObjectGuid guid)
	Removes a player from a group.

void	AddPlayerToGroup (ObjectGuid gguid, ObjectGuid guid)
	Adds player to group.

void	AddPlayerQueuedForRandomDungeonToGroup (ObjectGuid gguid, ObjectGuid guid)
	Store player that selected random queue to group.

bool	IsPlayerQueuedForRandomDungeon (ObjectGuid guid)

void	SetRandomPlayersCount (ObjectGuid guid, uint8 count)
	Xinef: Set Random Players Count.

uint8	GetRandomPlayersCount (ObjectGuid guid)
	Xinef: Get Random Players Count.

LfgLockMap const &	GetLockedDungeons (ObjectGuid guid)
	Get locked dungeons.

LfgUpdateData	GetLfgStatus (ObjectGuid guid)
	Returns current lfg status.

bool	IsSeasonActive (uint32 dungeonId)
	Checks if Seasonal dungeon is active.

bool	IsDungeonDisabled (uint32 mapId, Difficulty difficulty) const
	Checks if given dungeon map is disabled.

LfgReward const *	GetRandomDungeonReward (uint32 dungeon, uint8 level)
	Gets the random dungeon reward corresponding to given dungeon and player level.

LfgDungeonSet	GetRandomAndSeasonalDungeons (uint8 level, uint8 expansion)
	Returns all random and seasonal dungeons for given level and expansion.

void	TeleportPlayer (Player player, bool out, WorldLocation const teleportLocation=nullptr)
	Teleport a player to/from selected dungeon.

void	InitBoot (ObjectGuid gguid, ObjectGuid kicker, ObjectGuid victim, std::string const &reason)
	Inits new proposal to boot a player.

void	UpdateBoot (ObjectGuid guid, bool accept)
	Updates player boot proposal with new player answer.

void	UpdateProposal (uint32 proposalId, ObjectGuid guid, bool accept)
	Updates proposal to join dungeon with player answer.

void	UpdateRoleCheck (ObjectGuid gguid, ObjectGuid guid=ObjectGuid::Empty, uint8 roles=PLAYER_ROLE_NONE)
	Updates the role check with player answer.

void	SetRoles (ObjectGuid guid, uint8 roles)
	Sets player lfg roles.

void	SetComment (ObjectGuid guid, std::string const &comment)
	Sets player lfr comment.

void	JoinLfg (Player *player, uint8 roles, LfgDungeonSet &dungeons, std::string const &comment)
	Join Lfg with selected roles, dungeons and comment.

void	LeaveLfg (ObjectGuid guid)
	Leaves lfg.

void	LeaveAllLfgQueues (ObjectGuid guid, bool allowgroup, ObjectGuid groupguid=ObjectGuid::Empty)
	pussywizard: cleans all queues' data

void	JoinRaidBrowser (Player *player, uint8 roles, LfgDungeonSet &dungeons, std::string comment)
	pussywizard: Raid Browser

void	LeaveRaidBrowser (ObjectGuid guid)

void	LfrSearchAdd (Player *p, uint32 dungeonId)

void	LfrSearchRemove (Player *p)

void	SendRaidBrowserCachedList (Player *player, uint32 dungeonId)

void	UpdateRaidBrowser (uint32 diff)

void	LfrSetComment (Player *p, std::string comment)

void	SendRaidBrowserJoinedPacket (Player *p, LfgDungeonSet &dungeons, std::string comment)

void	RBPacketAppendGroup (const RBInternalInfo &info, ByteBuffer &buffer)

void	RBPacketAppendPlayer (const RBInternalInfo &info, ByteBuffer &buffer)

void	RBPacketBuildDifference (WorldPacket &differencePacket, uint32 dungeonId, uint32 deletedCounter, ByteBuffer &buffer_deleted, uint32 groupCounter, ByteBuffer &buffer_groups, uint32 playerCounter, ByteBuffer &buffer_players)

void	RBPacketBuildFull (WorldPacket &fullPacket, uint32 dungeonId, RBInternalInfoMap &infoMap)

LfgState	GetOldState (ObjectGuid guid)
	Get last lfg state (NONE, DUNGEON or FINISHED_DUNGEON)

bool	IsLfgGroup (ObjectGuid guid)
	Check if given group guid is lfg.

uint8	GetPlayerCount (ObjectGuid guid)
	Gets the player count of given group.

uint32	AddProposal (LfgProposal &proposal)
	Add a new Proposal.

bool	AllQueued (Lfg5Guids const &check)
	Checks if all players are queued.

void	ToggleTesting ()

bool	IsTesting () const
	For 1 player queue testing.

void	SetDungeon (ObjectGuid guid, uint32 dungeon)

Static Public Member Functions
static LFGMgr *	instance ()

static uint8	CheckGroupRoles (LfgRolesMap &groles)
	Checks if given roles match, modifies given roles map with new roles.

static bool	HasIgnore (ObjectGuid guid1, ObjectGuid guid2)
	Checks if given players are ignoring each other.

static void	SendLfgQueueStatus (ObjectGuid guid, LfgQueueStatusData const &data)
	Sends queue status to player.

Private Types
typedef std::unordered_map< ObjectGuid, RBEntryInfo >	RBEntryInfoMap

typedef std::unordered_map< uint32, RBEntryInfoMap >	RBStoreMap

typedef std::unordered_map< ObjectGuid, uint32 >	RBSearchersMap

typedef std::unordered_map< uint32, WorldPacket >	RBCacheMap

typedef std::unordered_map< ObjectGuid, RBInternalInfo >	RBInternalInfoMap

typedef std::unordered_map< uint32, RBInternalInfoMap >	RBInternalInfoMapMap

typedef std::set< uint32 >	RBUsedDungeonsSet

typedef std::unordered_map< uint32, TimePoint >	LfgDungeonCooldownMap

typedef std::unordered_map< ObjectGuid, LfgDungeonCooldownMap >	LfgDungeonCooldownContainer

Private Member Functions
	LFGMgr ()

	~LFGMgr ()

TeamId	GetTeam (ObjectGuid guid)

void	RestoreState (ObjectGuid guid, char const *debugMsg)

void	ClearState (ObjectGuid guid, char const *debugMsg)

void	SetSelectedDungeons (ObjectGuid guid, LfgDungeonSet const &dungeons)

void	SetLockedDungeons (ObjectGuid guid, LfgLockMap const &lock)

void	DecreaseKicksLeft (ObjectGuid guid)

void	SetState (ObjectGuid guid, LfgState state)

void	SetCanOverrideRBState (ObjectGuid guid, bool val)

void	GetCompatibleDungeons (LfgDungeonSet &dungeons, LfgGuidSet const &players, LfgLockPartyMap &lockMap, uint32 randomDungeonId=0)

void	_SaveToDB (ObjectGuid guid)

LFGDungeonData const *	GetLFGDungeon (uint32 id)

void	RemoveProposal (LfgProposalContainer::iterator itProposal, LfgUpdateType type)

void	MakeNewGroup (LfgProposal const &proposal)

LFGQueue &	GetQueue (ObjectGuid guid)

LfgDungeonSet const &	GetDungeonsByRandom (uint32 randomdungeon)

LfgType	GetDungeonType (uint32 dungeon)

void	SendLfgBootProposalUpdate (ObjectGuid guid, LfgPlayerBoot const &boot)

void	SendLfgJoinResult (ObjectGuid guid, LfgJoinResultData const &data)

void	SendLfgRoleChosen (ObjectGuid guid, ObjectGuid pguid, uint8 roles)

void	SendLfgRoleCheckUpdate (ObjectGuid guid, LfgRoleCheck const &roleCheck)

void	SendLfgUpdateParty (ObjectGuid guid, LfgUpdateData const &data)

void	SendLfgUpdatePlayer (ObjectGuid guid, LfgUpdateData const &data)

void	SendLfgUpdateProposal (ObjectGuid guid, LfgProposal const &proposal)

LfgGuidSet const &	GetPlayers (ObjectGuid guid)

void	AddDungeonCooldown (ObjectGuid guid, uint32 dungeonId)

void	CleanupDungeonCooldowns ()

Seconds	GetDungeonCooldownDuration () const

Private Attributes
RBStoreMap	RaidBrowserStore [2]

RBSearchersMap	RBSearchersStore [2]

RBCacheMap	RBCacheStore [2]

RBInternalInfoMapMap	RBInternalInfoStorePrev [2]

RBInternalInfoMapMap	RBInternalInfoStoreCurr [2]

RBUsedDungeonsSet	RBUsedDungeonsStore [2]

uint32	m_lfgProposalId
	used as internal counter for proposals

uint32	m_options
	Stores config options.

uint32	lastProposalId
	pussywizard, store it here because of splitting LFGMgr update into tasks

uint32	m_raidBrowserUpdateTimer [2]
	pussywizard

uint32	m_raidBrowserLastUpdatedDungeonId [2]
	pussywizard: for 2 factions

LfgQueueContainer	QueuesStore
	Queues.

LfgCachedDungeonContainer	CachedDungeonMapStore
	Stores all dungeons by groupType.

LfgRewardContainer	RewardMapStore
	Stores rewards for random dungeons.

LFGDungeonContainer	LfgDungeonStore

LfgRoleCheckContainer	RoleChecksStore
	Current Role checks.

LfgProposalContainer	ProposalsStore
	Current Proposals.

LfgPlayerBootContainer	BootsStore
	Current player kicks.

LfgPlayerDataContainer	PlayersStore
	Player data.

LfgGroupDataContainer	GroupsStore
	Group data.

bool	m_Testing

LfgDungeonCooldownContainer	DungeonCooldownStore
	Stores dungeon cooldowns per player.

Detailed Description

Member Typedef Documentation

◆ LfgDungeonCooldownContainer

typedef std::unordered_map<ObjectGuid , LfgDungeonCooldownMap> lfg::LFGMgr::LfgDungeonCooldownContainer

private

◆ LfgDungeonCooldownMap

typedef std::unordered_map<uint32 , TimePoint > lfg::LFGMgr::LfgDungeonCooldownMap

private

◆ RBCacheMap

typedef std::unordered_map<uint32 , WorldPacket> lfg::LFGMgr::RBCacheMap

private

◆ RBEntryInfoMap

typedef std::unordered_map<ObjectGuid , RBEntryInfo> lfg::LFGMgr::RBEntryInfoMap

private

◆ RBInternalInfoMap

typedef std::unordered_map<ObjectGuid , RBInternalInfo> lfg::LFGMgr::RBInternalInfoMap

private

◆ RBInternalInfoMapMap

typedef std::unordered_map<uint32 , RBInternalInfoMap> lfg::LFGMgr::RBInternalInfoMapMap

private

◆ RBSearchersMap

typedef std::unordered_map<ObjectGuid , uint32 > lfg::LFGMgr::RBSearchersMap

private

◆ RBStoreMap

typedef std::unordered_map<uint32 , RBEntryInfoMap> lfg::LFGMgr::RBStoreMap

private

◆ RBUsedDungeonsSet

typedef std::set<uint32 > lfg::LFGMgr::RBUsedDungeonsSet

private

Constructor & Destructor Documentation

◆ LFGMgr()

lfg::LFGMgr::LFGMgr ( )

private

                  : m_lfgProposalId(1), m_options(sWorld->getIntConfig(CONFIG_LFG_OPTIONSMASK)), m_Testing(sWorld->getBoolConfig(CONFIG_DEBUG_LFG))
    {
        for (uint8 team = 0; team < 2; ++team)
        {
            m_raidBrowserUpdateTimer[team] = 10000;
            m_raidBrowserLastUpdatedDungeonId[team] = 0;
        }
    }

References m_raidBrowserLastUpdatedDungeonId, and m_raidBrowserUpdateTimer.

◆ ~LFGMgr()

lfg::LFGMgr::~LFGMgr ( )

private

    {
        for (LfgRewardContainer::iterator itr = RewardMapStore.begin(); itr != RewardMapStore.end(); ++itr)
            delete itr->second;
    }

References RewardMapStore.

Member Function Documentation

◆ _LoadFromDB()

void lfg::LFGMgr::_LoadFromDB	(	Field *	fields,
		ObjectGuid	guid
	)

Load Lfg group info from DB.

    {
        if (!fields)
            return;
 
        if (!guid.IsGroup())
            return;
 
        SetLeader(guid, ObjectGuid::Create<HighGuid::Player>(fields[0].Get<uint32>()));
 
        uint32 dungeon = fields[17].Get<uint32>();
        uint8 state = fields[18].Get<uint8>();
 
        if (!dungeon || !state)
            return;
 
        SetDungeon(guid, dungeon);
 
        switch (state)
        {
            case LFG_STATE_DUNGEON:
            case LFG_STATE_FINISHED_DUNGEON:
                SetState(guid, (LfgState)state);
                break;
            default:
                break;
        }
    }

References Field::Get(), ObjectGuid::IsGroup(), lfg::LFG_STATE_DUNGEON, lfg::LFG_STATE_FINISHED_DUNGEON, SetDungeon(), SetLeader(), and SetState().

◆ _SaveToDB()

void lfg::LFGMgr::_SaveToDB ( ObjectGuid guid )

private

    {
        if (!guid.IsGroup())
            return;
 
        CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_REP_LFG_DATA);
        stmt->SetData(0, guid.GetCounter());
        stmt->SetData(1, GetDungeon(guid));
        stmt->SetData(2, GetState(guid));
        CharacterDatabase.Execute(stmt);
    }

References CHAR_REP_LFG_DATA, CharacterDatabase, ObjectGuid::GetCounter(), GetDungeon(), GetState(), ObjectGuid::IsGroup(), and PreparedStatementBase::SetData().

Referenced by FinishDungeon(), and MakeNewGroup().

◆ AddDungeonCooldown()

void lfg::LFGMgr::AddDungeonCooldown	(	ObjectGuid	guid,
		uint32	dungeonId
	)

private

    {
        if (!sWorld->getIntConfig(CONFIG_LFG_DUNGEON_SELECTION_COOLDOWN))
            return;
 
        DungeonCooldownStore[guid][dungeonId] = GameTime::Now();
    }

References CONFIG_LFG_DUNGEON_SELECTION_COOLDOWN, DungeonCooldownStore, GameTime::Now(), and sWorld.

Referenced by FinishDungeon().

◆ AddPlayerQueuedForRandomDungeonToGroup()

void lfg::LFGMgr::AddPlayerQueuedForRandomDungeonToGroup	(	ObjectGuid	gguid,
		ObjectGuid	guid
	)

Store player that selected random queue to group.

    {
        const LfgDungeonSet& dungeons = GetSelectedDungeons(guid);
        if (dungeons.empty())
            return;
 
        uint32 dungeonId = *dungeons.begin();
        LFGDungeonData const* dungeon = GetLFGDungeon(dungeonId);
        if (dungeon && (dungeon->type == LFG_TYPE_RANDOM))
            GroupsStore[gguid].AddRandomQueuedPlayer(guid);
    }

References GetLFGDungeon(), GetSelectedDungeons(), GroupsStore, lfg::LFG_TYPE_RANDOM, and lfg::LFGDungeonData::type.

◆ AddPlayerToGroup()

void lfg::LFGMgr::AddPlayerToGroup	(	ObjectGuid	gguid,
		ObjectGuid	guid
	)

Adds player to group.

    {
        GroupsStore[gguid].AddPlayer(guid);
    }

References GroupsStore.

Referenced by SetupGroupMember().

◆ AddProposal()

uint32 lfg::LFGMgr::AddProposal ( LfgProposal & proposal )

Add a new Proposal.

    {
        proposal.id = ++m_lfgProposalId;
        ProposalsStore[m_lfgProposalId] = proposal;
        return m_lfgProposalId;
    }

References lfg::LfgProposal::id, m_lfgProposalId, and ProposalsStore.

◆ AllQueued()

bool lfg::LFGMgr::AllQueued ( Lfg5Guids const & check )

Checks if all players are queued.

    {
        bool ok = true;
 
        if (check.empty())
            return false;
 
        for (uint8 i = 0; i < 5 && check.guids[i]; ++i)
        {
            ObjectGuid guid = check.guids[i];
            if (GetState(guid) != LFG_STATE_QUEUED)
            {
                LFGQueue& queue = GetQueue(guid);
                queue.RemoveFromQueue(guid);
                ok = false;
            }
        }
 
        return ok;
    }

References lfg::Lfg5Guids::empty(), GetQueue(), GetState(), lfg::Lfg5Guids::guids, lfg::LFG_STATE_QUEUED, and lfg::LFGQueue::RemoveFromQueue().

◆ CheckGroupRoles()

uint8 lfg::LFGMgr::CheckGroupRoles ( LfgRolesMap & groles )

static

Checks if given roles match, modifies given roles map with new roles.

    {
        if (groles.empty())
            return 0;
 
        uint8 damage = 0;
        uint8 tank = 0;
        uint8 healer = 0;
 
        for (LfgRolesMap::iterator it = groles.begin(); it != groles.end(); ++it)
        {
            uint8 const role = it->second & ~PLAYER_ROLE_LEADER;
            if (role == PLAYER_ROLE_NONE)
                return 0;
 
            if (role & PLAYER_ROLE_DAMAGE)
            {
                if (role != PLAYER_ROLE_DAMAGE)
                {
                    it->second -= PLAYER_ROLE_DAMAGE;
                    if (uint8 x = CheckGroupRoles(groles))
                        return x;
                    it->second += PLAYER_ROLE_DAMAGE;
                }
                else if (damage == LFG_DPS_NEEDED)
                    return 0;
                else
                    damage++;
            }
 
            if (role & PLAYER_ROLE_HEALER)
            {
                if (role != PLAYER_ROLE_HEALER)
                {
                    it->second -= PLAYER_ROLE_HEALER;
                    if (uint8 x = CheckGroupRoles(groles))
                        return x;
                    it->second += PLAYER_ROLE_HEALER;
                }
                else if (healer == LFG_HEALERS_NEEDED)
                    return 0;
                else
                    healer++;
            }
 
            if (role & PLAYER_ROLE_TANK)
            {
                if (role != PLAYER_ROLE_TANK)
                {
                    it->second -= PLAYER_ROLE_TANK;
                    if (uint8 x = CheckGroupRoles(groles))
                        return x;
                    it->second += PLAYER_ROLE_TANK;
                }
                else if (tank == LFG_TANKS_NEEDED)
                    return 0;
                else
                    tank++;
            }
        }
        if ((tank + healer + damage) == uint8(groles.size()))
            return (8 * tank + 4 * healer + damage);
        return 0;
    }

References CheckGroupRoles(), lfg::LFG_DPS_NEEDED, lfg::LFG_HEALERS_NEEDED, lfg::LFG_TANKS_NEEDED, lfg::PLAYER_ROLE_DAMAGE, lfg::PLAYER_ROLE_HEALER, lfg::PLAYER_ROLE_NONE, and lfg::PLAYER_ROLE_TANK.

Referenced by lfg::LFGQueue::CheckCompatibility(), CheckGroupRoles(), and UpdateRoleCheck().

◆ Clean()

void lfg::LFGMgr::Clean ( )

Clears queue - Only for internal testing.

    {
        QueuesStore.clear();
    }

References QueuesStore.

◆ CleanupDungeonCooldowns()

void lfg::LFGMgr::CleanupDungeonCooldowns ( )

private

    {
        if (!sWorld->getIntConfig(CONFIG_LFG_DUNGEON_SELECTION_COOLDOWN))
            return;
 
        Seconds cooldownDuration = GetDungeonCooldownDuration();
 
        for (auto itPlayer = DungeonCooldownStore.begin(); itPlayer != DungeonCooldownStore.end(); )
        {
            for (auto itDungeon = itPlayer->second.begin(); itDungeon != itPlayer->second.end(); )
            {
                if (GameTime::HasElapsed(itDungeon->second, cooldownDuration))
                    itDungeon = itPlayer->second.erase(itDungeon);
                else
                    ++itDungeon;
            }
 
            if (itPlayer->second.empty())
                itPlayer = DungeonCooldownStore.erase(itPlayer);
            else
                ++itPlayer;
        }
    }

References CONFIG_LFG_DUNGEON_SELECTION_COOLDOWN, DungeonCooldownStore, GetDungeonCooldownDuration(), GameTime::HasElapsed(), and sWorld.

Referenced by Update().

◆ ClearDungeonCooldowns()

void lfg::LFGMgr::ClearDungeonCooldowns ( )

Clears all dungeon cooldowns for all players.

    {
        DungeonCooldownStore.clear();
    }

References DungeonCooldownStore.

◆ ClearState()

void lfg::LFGMgr::ClearState	(	ObjectGuid	guid,
		char const *	debugMsg
	)

private

◆ DecreaseKicksLeft()

void lfg::LFGMgr::DecreaseKicksLeft ( ObjectGuid guid )

private

    {
        LOG_DEBUG("lfg", "LFGMgr::DecreaseKicksLeft: [{}]", guid.ToString());
        GroupsStore[guid].DecreaseKicksLeft();
    }

References GroupsStore, LOG_DEBUG, and ObjectGuid::ToString().

Referenced by UpdateBoot().

◆ FilterCooldownDungeons()

LfgDungeonSet lfg::LFGMgr::FilterCooldownDungeons	(	LfgDungeonSet const &	dungeons,
		LfgRolesMap const &	players
	)

Filters out recently completed dungeons from the proposal set for the given players.

    {
        if (!sWorld->getIntConfig(CONFIG_LFG_DUNGEON_SELECTION_COOLDOWN))
            return dungeons;
 
        Seconds cooldownDuration = GetDungeonCooldownDuration();
 
        LfgDungeonSet filtered;
        for (uint32 dungeonId : dungeons)
        {
            bool onCooldown = false;
            for (auto const& playerPair : players)
            {
                auto itPlayer = DungeonCooldownStore.find(playerPair.first);
                if (itPlayer != DungeonCooldownStore.end())
                {
                    auto itDungeon = itPlayer->second.find(dungeonId);
                    if (itDungeon != itPlayer->second.end() && !GameTime::HasElapsed(itDungeon->second, cooldownDuration))
                    {
                        onCooldown = true;
                        break;
                    }
                }
            }
 
            if (!onCooldown)
                filtered.insert(dungeonId);
        }
 
        // If all dungeons are on cooldown, return original set to avoid blocking the queue
        if (filtered.empty())
        {
            LOG_DEBUG("lfg", "LFGMgr::FilterCooldownDungeons: All {} dungeons on cooldown for group, bypassing cooldown filter", dungeons.size());
            return dungeons;
        }
 
        return filtered;
    }

References CONFIG_LFG_DUNGEON_SELECTION_COOLDOWN, DungeonCooldownStore, GetDungeonCooldownDuration(), GameTime::HasElapsed(), LOG_DEBUG, and sWorld.

◆ FinishDungeon()

void lfg::LFGMgr::FinishDungeon	(	ObjectGuid	gguid,
		uint32	dungeonId,
		const Map *	currMap
	)

Finish the dungeon for the given group. All check are performed using internal lfg data.

Finish a dungeon and give reward, if any.

Parameters

[in]	guid	Group guid
[in]	dungeonId	Dungeonid

    {
        uint32 gDungeonId = GetDungeon(gguid);
        if (gDungeonId != dungeonId)
        {
            LOG_DEBUG("lfg", "LFGMgr::FinishDungeon: [{}] Finished dungeon {} but group queued for {}. Ignoring", gguid.ToString(), dungeonId, gDungeonId);
            return;
        }
 
        if (GetState(gguid) == LFG_STATE_FINISHED_DUNGEON) // Shouldn't happen. Do not reward multiple times
        {
            LOG_DEBUG("lfg", "LFGMgr::FinishDungeon: [{}] Already rewarded group. Ignoring", gguid.ToString());
            return;
        }
 
        SetState(gguid, LFG_STATE_FINISHED_DUNGEON);
        _SaveToDB(gguid); // pussywizard
 
        const LfgGuidSet& players = GetPlayers(gguid);
        for (LfgGuidSet::const_iterator it = players.begin(); it != players.end(); ++it)
        {
            ObjectGuid guid = (*it);
            if (GetState(guid) == LFG_STATE_FINISHED_DUNGEON)
            {
                LOG_DEBUG("lfg", "LFGMgr::FinishDungeon: [{}] Already rewarded player. Ignoring", guid.ToString());
                continue;
            }
 
            uint32 rDungeonId = 0;
            const LfgDungeonSet& dungeons = GetSelectedDungeons(guid);
            if (!dungeons.empty())
                rDungeonId = (*dungeons.begin());
 
            SetState(guid, LFG_STATE_FINISHED_DUNGEON);
 
            // Give rewards only if its a random dungeon
            LFGDungeonData const* dungeon = GetLFGDungeon(rDungeonId);
 
            if (!dungeon || (dungeon->type != LFG_TYPE_RANDOM && !dungeon->seasonal))
            {
                LOG_DEBUG("lfg", "LFGMgr::FinishDungeon: [{}] dungeon {} is not random or seasonal", guid.ToString(), rDungeonId);
                continue;
            }
 
            // Record dungeon cooldown for this player (the actual dungeon completed, not the random entry)
            AddDungeonCooldown(guid, dungeonId);
 
            Player* player = ObjectAccessor::FindPlayer(guid);
            if (!player || player->FindMap() != currMap) // pussywizard: currMap - multithreading crash if on other map (map id check is not enough, binding system is not reliable)
            {
                LOG_DEBUG("lfg", "LFGMgr::FinishDungeon: [{}] not found in world", guid.ToString());
                continue;
            }
 
            LFGDungeonData const* dungeonDone = GetLFGDungeon(dungeonId);
            uint32 mapId = dungeonDone ? uint32(dungeonDone->map) : 0;
 
            if (player->GetMapId() != mapId)
            {
                LOG_DEBUG("lfg", "LFGMgr::FinishDungeon: [{}] is in map {} and should be in {} to get reward", guid.ToString(), player->GetMapId(), mapId);
                continue;
            }
 
            // Remove Dungeon Finder Cooldown if still exists
            if (player->HasAura(LFG_SPELL_DUNGEON_COOLDOWN))
            {
                player->RemoveAurasDueToSpell(LFG_SPELL_DUNGEON_COOLDOWN);
            }
 
            // Xinef: Update achievements, set correct amount of randomly grouped players
            if (dungeon->difficulty == DUNGEON_DIFFICULTY_HEROIC)
                if (uint8 count = GetRandomPlayersCount(player->GetGUID()))
                    player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_USE_LFD_TO_GROUP_WITH_PLAYERS, count);
 
            LfgReward const* reward = GetRandomDungeonReward(rDungeonId, player->GetLevel());
            if (!reward)
                continue;
 
            bool done = false;
            Quest const* quest = sObjectMgr->GetQuestTemplate(reward->firstQuest);
            if (!quest)
                continue;
 
            // if we can take the quest, means that we haven't done this kind of "run", IE: First Heroic Random of Day.
            if (player->CanRewardQuest(quest, false))
                player->RewardQuest(quest, 0, nullptr, false, true);
            else
            {
                done = true;
                quest = sObjectMgr->GetQuestTemplate(reward->otherQuest);
                if (!quest)
                    continue;
                // we give reward without informing client (retail does this)
                player->RewardQuest(quest, 0, nullptr, false, true);
            }
 
            // Give rewards
            LOG_DEBUG("lfg", "LFGMgr::FinishDungeon: [{}] done dungeon {}, {} previously done.", player->GetGUID().ToString(), GetDungeon(gguid), done ? " " : " not");
            LfgPlayerRewardData data = LfgPlayerRewardData(dungeon->Entry(), GetDungeon(gguid, false), done, quest);
            player->GetSession()->SendLfgPlayerReward(data);
        }
    }

References _SaveToDB(), ACHIEVEMENT_CRITERIA_TYPE_USE_LFD_TO_GROUP_WITH_PLAYERS, AddDungeonCooldown(), Player::CanRewardQuest(), lfg::LFGDungeonData::difficulty, DUNGEON_DIFFICULTY_HEROIC, lfg::LFGDungeonData::Entry(), WorldObject::FindMap(), ObjectAccessor::FindPlayer(), lfg::LfgReward::firstQuest, GetDungeon(), Object::GetGUID(), Unit::GetLevel(), GetLFGDungeon(), WorldLocation::GetMapId(), GetPlayers(), GetRandomDungeonReward(), GetRandomPlayersCount(), GetSelectedDungeons(), Player::GetSession(), GetState(), Unit::HasAura(), lfg::LFG_SPELL_DUNGEON_COOLDOWN, lfg::LFG_STATE_FINISHED_DUNGEON, lfg::LFG_TYPE_RANDOM, LOG_DEBUG, lfg::LFGDungeonData::map, lfg::LfgReward::otherQuest, Unit::RemoveAurasDueToSpell(), Player::RewardQuest(), lfg::LFGDungeonData::seasonal, WorldSession::SendLfgPlayerReward(), SetState(), sObjectMgr, ObjectGuid::ToString(), lfg::LFGDungeonData::type, and Player::UpdateAchievementCriteria().

◆ GetComment()

const std::string & lfg::LFGMgr::GetComment ( ObjectGuid gguid )

Get current player comment (used for LFR)

    {
        LOG_DEBUG("lfg", "LFGMgr::GetComment: [{}] = {}", guid.ToString(), PlayersStore[guid].GetComment());
        return PlayersStore[guid].GetComment();
    }

References LOG_DEBUG, PlayersStore, and ObjectGuid::ToString().

Referenced by RemoveProposal(), Update(), and UpdateRoleCheck().

◆ GetCompatibleDungeons()

void lfg::LFGMgr::GetCompatibleDungeons	(	LfgDungeonSet &	dungeons,
		LfgGuidSet const &	players,
		LfgLockPartyMap &	lockMap,
		uint32	randomDungeonId = `0`
	)

private

Given a list of dungeons remove the dungeons players have restrictions.

Parameters

[in,out]	dungeons	Dungeons to check restrictions
[in]	players	Set of players to check their dungeon restrictions
[out]	lockMap	Map of players Lock status info of given dungeons (Empty if dungeons is not empty)
[in]	randomDungeonId	Random dungeon ID (0 for non-random selections), used to filter disabled maps

    {
        lockMap.clear();
        for (LfgGuidSet::const_iterator it = players.begin(); it != players.end() && !dungeons.empty(); ++it)
        {
            ObjectGuid guid = (*it);
            LfgLockMap const& cachedLockMap = GetLockedDungeons(guid);
            for (LfgLockMap::const_iterator it2 = cachedLockMap.begin(); it2 != cachedLockMap.end() && !dungeons.empty(); ++it2)
            {
                uint32 dungeonId = (it2->first & 0x00FFFFFF); // Compare dungeon ids
 
                LFGDungeonData const* dungeon = GetLFGDungeon(dungeonId);
 
                uint8 difficultyFlag = (randomDungeonId == RANDOM_DUNGEON_NORMAL_TBC || randomDungeonId == RANDOM_DUNGEON_NORMAL_WOTLK) ? 0 : 1;
 
                if (dungeon && !IsDungeonDisabled(dungeon->map, (Difficulty)difficultyFlag) && it2->second == LFG_LOCKSTATUS_RAID_LOCKED && randomDungeonId && sWorld->getBoolConfig(CONFIG_LFG_ALLOW_COMPLETED))
                    continue;
 
                LfgDungeonSet::iterator itDungeon = dungeons.find(dungeonId);
                if (itDungeon != dungeons.end())
                {
                    dungeons.erase(itDungeon);
                    lockMap[guid][dungeonId] = it2->second;
                }
            }
        }
        if (!dungeons.empty())
            lockMap.clear();
    }

References CONFIG_LFG_ALLOW_COMPLETED, GetLFGDungeon(), GetLockedDungeons(), IsDungeonDisabled(), lfg::LFG_LOCKSTATUS_RAID_LOCKED, lfg::LFGDungeonData::map, lfg::RANDOM_DUNGEON_NORMAL_TBC, lfg::RANDOM_DUNGEON_NORMAL_WOTLK, and sWorld.

Referenced by JoinLfg().

◆ GetDungeon()

uint32 lfg::LFGMgr::GetDungeon	(	ObjectGuid	guid,
		bool	asId = `true`
	)

Get current dungeon.

    {
        uint32 dungeon = GroupsStore[guid].GetDungeon(asId);
        LOG_DEBUG("lfg", "LFGMgr::GetDungeon: [{}] asId: {} = {}", guid.ToString(), asId, dungeon);
        return dungeon;
    }

References GroupsStore, LOG_DEBUG, and ObjectGuid::ToString().

Referenced by _SaveToDB(), FinishDungeon(), inLfgDungeonMap(), JoinLfg(), LeaveLfg(), SetupGroupMember(), and TeleportPlayer().

◆ GetDungeonCooldownDuration()

Seconds lfg::LFGMgr::GetDungeonCooldownDuration ( ) const

private

    {
        return Seconds(sWorld->getIntConfig(CONFIG_LFG_DUNGEON_SELECTION_COOLDOWN) * MINUTE);
    }

References CONFIG_LFG_DUNGEON_SELECTION_COOLDOWN, MINUTE, and sWorld.

Referenced by CleanupDungeonCooldowns(), and FilterCooldownDungeons().

◆ GetDungeonMapId()

uint32 lfg::LFGMgr::GetDungeonMapId ( ObjectGuid guid )

Get the map id of the current dungeon.

    {
        uint32 dungeonId = GroupsStore[guid].GetDungeon(true);
        uint32 mapId = 0;
        if (dungeonId)
            if (LFGDungeonData const* dungeon = GetLFGDungeon(dungeonId))
                mapId = dungeon->map;
 
        LOG_DEBUG("lfg", "LFGMgr::GetDungeonMapId: [{}] = {} (DungeonId = {})", guid.ToString(), mapId, dungeonId);
        return mapId;
    }

References GetLFGDungeon(), GroupsStore, LOG_DEBUG, and ObjectGuid::ToString().

◆ GetDungeonsByRandom()

LfgDungeonSet const & lfg::LFGMgr::GetDungeonsByRandom ( uint32 randomdungeon )

private

Get the dungeon list that can be done given a random dungeon entry.

Parameters

[in] randomdungeon Random dungeon id (if value = 0 will return all dungeons)

Returns: Set of dungeons that can be done.

    {
        LFGDungeonData const* dungeon = GetLFGDungeon(randomdungeon);
        uint32 group = dungeon ? dungeon->group : 0;
        return CachedDungeonMapStore[group];
    }

References CachedDungeonMapStore, GetLFGDungeon(), and lfg::LFGDungeonData::group.

Referenced by InitializeLockedDungeons(), and JoinLfg().

◆ GetDungeonType()

LfgType lfg::LFGMgr::GetDungeonType ( uint32 dungeonId )

private

Given a Dungeon id returns the dungeon Type

Parameters

[in] dungeon dungeon id

Returns: Dungeon type

    {
        LFGDungeonData const* dungeon = GetLFGDungeon(dungeonId);
        if (!dungeon)
            return LFG_TYPE_NONE;
 
        return LfgType(dungeon->type);
    }

References GetLFGDungeon(), lfg::LFG_TYPE_NONE, and lfg::LFGDungeonData::type.

Referenced by JoinLfg().

◆ GetGroup()

ObjectGuid lfg::LFGMgr::GetGroup ( ObjectGuid guid )

Gets player group.

    {
        return PlayersStore[guid].GetGroup();
    }

References PlayersStore.

Referenced by inLfgDungeonMap(), IsPlayerQueuedForRandomDungeon(), LeaveAllLfgQueues(), LeaveLfg(), MakeNewGroup(), Update(), and UpdateBoot().

◆ GetKicksLeft()

uint8 lfg::LFGMgr::GetKicksLeft ( ObjectGuid gguid )

Get kicks left in current group.

    {
        uint8 kicks = GroupsStore[guid].GetKicksLeft();
        LOG_DEBUG("lfg", "LFGMgr::GetKicksLeft: [{}] = {}", guid.ToString(), kicks);
        return kicks;
    }

References GroupsStore, LOG_DEBUG, and ObjectGuid::ToString().

◆ GetLeader()

ObjectGuid lfg::LFGMgr::GetLeader ( ObjectGuid guid )

Get leader of the group (using internal data)

    {
        return GroupsStore[guid].GetLeader();
    }

References GroupsStore.

Referenced by GetQueue(), and LeaveLfg().

◆ GetLFGDungeon()

LFGDungeonData const * lfg::LFGMgr::GetLFGDungeon ( uint32 id )

private

    {
        LFGDungeonContainer::const_iterator itr = LfgDungeonStore.find(id);
        if (itr != LfgDungeonStore.end())
            return &(itr->second);
 
        return nullptr;
    }

References LfgDungeonStore.

Referenced by AddPlayerQueuedForRandomDungeonToGroup(), FinishDungeon(), GetCompatibleDungeons(), GetDungeonMapId(), GetDungeonsByRandom(), GetDungeonType(), GetLFGDungeonEntry(), InitializeLockedDungeons(), inLfgDungeonMap(), JoinRaidBrowser(), MakeNewGroup(), selectedRandomLfgDungeon(), TeleportPlayer(), and UpdateRaidBrowser().

◆ GetLFGDungeonEntry()

uint32 lfg::LFGMgr::GetLFGDungeonEntry ( uint32 id )

Return Lfg dungeon entry for given dungeon id.

    {
        if (id)
            if (LFGDungeonData const* dungeon = GetLFGDungeon(id))
                return dungeon->Entry();
 
        return 0;
    }

References GetLFGDungeon().

Referenced by LoadRewards().

◆ GetLfgStatus()

LfgUpdateData lfg::LFGMgr::GetLfgStatus ( ObjectGuid guid )

Returns current lfg status.

    {
        LfgPlayerData& playerData = PlayersStore[guid];
        return LfgUpdateData(LFG_UPDATETYPE_UPDATE_STATUS, playerData.GetState(), playerData.GetSelectedDungeons());
    }

References lfg::LfgPlayerData::GetSelectedDungeons(), lfg::LfgPlayerData::GetState(), lfg::LFG_UPDATETYPE_UPDATE_STATUS, and PlayersStore.

◆ GetLockedDungeons()

LfgLockMap const & lfg::LFGMgr::GetLockedDungeons ( ObjectGuid guid )

Get locked dungeons.

    {
        LOG_DEBUG("lfg", "LFGMgr::GetLockedDungeons: [{}]", guid.ToString());
        return PlayersStore[guid].GetLockedDungeons();
    }

References LOG_DEBUG, PlayersStore, and ObjectGuid::ToString().

Referenced by GetCompatibleDungeons().

◆ GetOldState()

LfgState lfg::LFGMgr::GetOldState ( ObjectGuid guid )

Get last lfg state (NONE, DUNGEON or FINISHED_DUNGEON)

    {
        LfgState state;
        if (guid.IsGroup())
            state = GroupsStore[guid].GetOldState();
        else
            state = PlayersStore[guid].GetOldState();
 
        LOG_DEBUG("lfg", "LFGMgr::GetOldState: [{}] = {}", guid.ToString(), state);
        return state;
    }

References GroupsStore, ObjectGuid::IsGroup(), LOG_DEBUG, PlayersStore, and ObjectGuid::ToString().

◆ GetOptions()

uint32 lfg::LFGMgr::GetOptions ( )

Gets current lfg options.

    {
        return m_options;
    }

References m_options.

◆ GetPlayerCount()

uint8 lfg::LFGMgr::GetPlayerCount ( ObjectGuid guid )

Gets the player count of given group.

    {
        return GroupsStore[guid].GetPlayerCount();
    }

References GroupsStore.

◆ GetPlayers()

LfgGuidSet const & lfg::LFGMgr::GetPlayers ( ObjectGuid guid )

private

    {
        return GroupsStore[guid].GetPlayers();
    }

References GroupsStore.

Referenced by FinishDungeon(), GetQueue(), InitBoot(), LeaveAllLfgQueues(), and LeaveLfg().

◆ GetQueue()

LFGQueue & lfg::LFGMgr::GetQueue ( ObjectGuid guid )

private

    {
        uint8 queueId = 0;
        if (guid.IsGroup())
        {
            LfgGuidSet const& players = GetPlayers(guid);
            ObjectGuid pguid = players.empty() ? ObjectGuid::Empty : (*players.begin());
            if (pguid)
                queueId = GetTeam(pguid);
            else
                queueId = GetTeam(GetLeader(guid));
        }
        else
            queueId = GetTeam(guid);
        return QueuesStore[queueId];
    }

References ObjectGuid::Empty, GetLeader(), GetPlayers(), GetTeam(), ObjectGuid::IsGroup(), and QueuesStore.

Referenced by AllQueued(), JoinLfg(), LeaveLfg(), RemoveProposal(), UpdateProposal(), and UpdateRoleCheck().

◆ GetRandomAndSeasonalDungeons()

LfgDungeonSet lfg::LFGMgr::GetRandomAndSeasonalDungeons	(	uint8	level,
		uint8	expansion
	)

Returns all random and seasonal dungeons for given level and expansion.

    {
        LfgDungeonSet randomDungeons;
        for (lfg::LFGDungeonContainer::const_iterator itr = LfgDungeonStore.begin(); itr != LfgDungeonStore.end(); ++itr)
        {
            lfg::LFGDungeonData const& dungeon = itr->second;
            if ((dungeon.type == lfg::LFG_TYPE_RANDOM || (dungeon.seasonal && sLFGMgr->IsSeasonActive(dungeon.id)))
                    && dungeon.expansion <= expansion && dungeon.minlevel <= level && level <= dungeon.maxlevel)
                randomDungeons.insert(dungeon.Entry());
        }
        return randomDungeons;
    }

References lfg::LFGDungeonData::Entry(), lfg::LFGDungeonData::expansion, lfg::LFGDungeonData::id, lfg::LFG_TYPE_RANDOM, LfgDungeonStore, lfg::LFGDungeonData::maxlevel, lfg::LFGDungeonData::minlevel, lfg::LFGDungeonData::seasonal, sLFGMgr, and lfg::LFGDungeonData::type.

◆ GetRandomDungeonReward()

LfgReward const * lfg::LFGMgr::GetRandomDungeonReward	(	uint32	dungeon,
		uint8	level
	)

Gets the random dungeon reward corresponding to given dungeon and player level.

Get the reward of a given random dungeon at a certain level

Parameters

[in]	dungeon	dungeon id
[in]	level	Player level

Returns: Reward

    {
        LfgReward const* rew = nullptr;
        LfgRewardContainerBounds bounds = RewardMapStore.equal_range(dungeon & 0x00FFFFFF);
        for (LfgRewardContainer::const_iterator itr = bounds.first; itr != bounds.second; ++itr)
        {
            rew = itr->second;
            // ordered properly at loading
            if (itr->second->maxLevel >= level)
                break;
        }
 
        return rew;
    }

References RewardMapStore.

Referenced by FinishDungeon().

◆ GetRandomPlayersCount()

uint8 lfg::LFGMgr::GetRandomPlayersCount ( ObjectGuid guid )

Xinef: Get Random Players Count.

    {
        return PlayersStore[guid].GetRandomPlayersCount();
    }

References PlayersStore.

Referenced by FinishDungeon().

◆ GetRoles()

uint8 lfg::LFGMgr::GetRoles ( ObjectGuid guid )

Get current player roles.

    {
        uint8 roles = PlayersStore[guid].GetRoles();
        LOG_DEBUG("lfg", "LFGMgr::GetRoles: [{}] = {}", guid.ToString(), roles);
        return roles;
    }

References LOG_DEBUG, PlayersStore, and ObjectGuid::ToString().

Referenced by UpdateProposal().

◆ GetSelectedDungeons()

LfgDungeonSet const & lfg::LFGMgr::GetSelectedDungeons ( ObjectGuid guid )

Get selected dungeons.

    {
        LOG_DEBUG("lfg", "LFGMgr::GetSelectedDungeons: [{}]", guid.ToString());
        return PlayersStore[guid].GetSelectedDungeons();
    }

References LOG_DEBUG, PlayersStore, and ObjectGuid::ToString().

Referenced by AddPlayerQueuedForRandomDungeonToGroup(), FinishDungeon(), RemoveProposal(), selectedRandomLfgDungeon(), Update(), and UpdateProposal().

◆ GetState()

LfgState lfg::LFGMgr::GetState ( ObjectGuid guid )

Get current lfg state.

    {
        LfgState state;
        if (guid.IsGroup())
            state = GroupsStore[guid].GetState();
        else
            state = PlayersStore[guid].GetState();
 
        LOG_DEBUG("lfg", "LFGMgr::GetState: [{}] = {}", guid.ToString(), state);
        return state;
    }

References GroupsStore, ObjectGuid::IsGroup(), LOG_DEBUG, PlayersStore, and ObjectGuid::ToString().

Referenced by _SaveToDB(), AllQueued(), FinishDungeon(), JoinLfg(), LeaveAllLfgQueues(), LeaveLfg(), RemoveGroupData(), selectedRandomLfgDungeon(), and SetupGroupMember().

◆ GetTeam()

TeamId lfg::LFGMgr::GetTeam ( ObjectGuid guid )

private

    {
        return PlayersStore[guid].GetTeam();
    }

References PlayersStore.

Referenced by GetQueue().

◆ HasIgnore()

bool lfg::LFGMgr::HasIgnore	(	ObjectGuid	guid1,
		ObjectGuid	guid2
	)

static

Checks if given players are ignoring each other.

    {
        Player* plr1 = ObjectAccessor::FindConnectedPlayer(guid1);
        Player* plr2 = ObjectAccessor::FindConnectedPlayer(guid2);
        return plr1 && plr2 && (plr1->GetSocial()->HasIgnore(guid2) || plr2->GetSocial()->HasIgnore(guid1));
    }

References ObjectAccessor::FindConnectedPlayer(), Player::GetSocial(), and PlayerSocial::HasIgnore().

◆ InitBoot()

void lfg::LFGMgr::InitBoot	(	ObjectGuid	gguid,
		ObjectGuid	kicker,
		ObjectGuid	victim,
		std::string const &	reason
	)

Inits new proposal to boot a player.

Initialize a boot kick vote

Parameters

[in]	gguid	Group the vote kicks belongs to
[in]	kicker	Kicker guid
[in]	victim	Victim guid
[in]	reason	Kick reason

    {
        SetState(gguid, LFG_STATE_BOOT);
 
        LfgPlayerBoot& boot = BootsStore[gguid];
        boot.inProgress = true;
        boot.cancelTime = time_t(GameTime::GetGameTime().count()) + LFG_TIME_BOOT;
        boot.reason = reason;
        boot.victim = victim;
 
        LfgGuidSet const& players = GetPlayers(gguid);
 
        // Set votes
        for (LfgGuidSet::const_iterator itr = players.begin(); itr != players.end(); ++itr)
        {
            ObjectGuid guid = (*itr);
            SetState(guid, LFG_STATE_BOOT);
            boot.votes[guid] = LFG_ANSWER_PENDING;
        }
 
        boot.votes[victim] = LFG_ANSWER_DENY;                  // Victim auto vote NO
        boot.votes[kicker] = LFG_ANSWER_AGREE;                 // Kicker auto vote YES
 
        // Notify players
        for (LfgGuidSet::const_iterator it = players.begin(); it != players.end(); ++it)
            SendLfgBootProposalUpdate(*it, boot);
    }

References BootsStore, lfg::LfgPlayerBoot::cancelTime, GameTime::GetGameTime(), GetPlayers(), lfg::LfgPlayerBoot::inProgress, lfg::LFG_ANSWER_AGREE, lfg::LFG_ANSWER_DENY, lfg::LFG_ANSWER_PENDING, lfg::LFG_STATE_BOOT, lfg::LFG_TIME_BOOT, lfg::LfgPlayerBoot::reason, SendLfgBootProposalUpdate(), SetState(), lfg::LfgPlayerBoot::victim, and lfg::LfgPlayerBoot::votes.

◆ InitializeLockedDungeons()

void lfg::LFGMgr::InitializeLockedDungeons	(	Player *	player,
		Group const *	group = `nullptr`
	)

Initializes locked dungeons for given player (called at login or level change)

Generate the dungeon lock map for a given player

Parameters

[in] player Player we need to initialize the lock status map

    {
        ObjectGuid guid = player->GetGUID();
 
        uint8 level = player->GetLevel();
        uint8 expansion = player->GetSession()->Expansion();
        LfgDungeonSet const& dungeons = GetDungeonsByRandom(0);
        LfgLockMap lock;
 
        bool onlySeasonalBosses = m_options == LFG_OPTION_ENABLE_SEASONAL_BOSSES;
 
        float avgItemLevel = player->GetAverageItemLevelForDF();
 
        for (LfgDungeonSet::const_iterator it = dungeons.begin(); it != dungeons.end(); ++it)
        {
            LFGDungeonData const* dungeon = GetLFGDungeon(*it);
            if (!dungeon) // should never happen - We provide a list from sLFGDungeonStore
                continue;
            MapEntry const* mapEntry = sMapStore.LookupEntry(dungeon->map);
            DungeonProgressionRequirements const* ar = sObjectMgr->GetAccessRequirement(dungeon->map, Difficulty(dungeon->difficulty));
 
            uint32 lockData = 0;
 
            if (!player->GetSession()->HasPermission(rbac::RBAC_PERM_JOIN_DUNGEON_FINDER))
                lockData = LFG_LOCKSTATUS_RAID_LOCKED;
            else if (dungeon->expansion > expansion || (onlySeasonalBosses && !dungeon->seasonal))
                lockData = LFG_LOCKSTATUS_INSUFFICIENT_EXPANSION;
            else if (IsDungeonDisabled(dungeon->map, dungeon->difficulty))
                lockData = LFG_LOCKSTATUS_RAID_LOCKED;
            else if (dungeon->difficulty > DUNGEON_DIFFICULTY_NORMAL && (!mapEntry || !mapEntry->IsRaid()) && sInstanceSaveMgr->PlayerIsPermBoundToInstance(player->GetGUID(), dungeon->map, Difficulty(dungeon->difficulty)))
                lockData = LFG_LOCKSTATUS_RAID_LOCKED;
            else if ((dungeon->minlevel > level && !sWorld->getBoolConfig(CONFIG_DUNGEON_ACCESS_REQUIREMENTS_LFG_DBC_LEVEL_OVERRIDE)) || (sWorld->getBoolConfig(CONFIG_DUNGEON_ACCESS_REQUIREMENTS_LFG_DBC_LEVEL_OVERRIDE) && ar && ar->levelMin > 0 && ar->levelMin > level))
                lockData = LFG_LOCKSTATUS_TOO_LOW_LEVEL;
            else if ((dungeon->maxlevel < level && !sWorld->getBoolConfig(CONFIG_DUNGEON_ACCESS_REQUIREMENTS_LFG_DBC_LEVEL_OVERRIDE)) || (sWorld->getBoolConfig(CONFIG_DUNGEON_ACCESS_REQUIREMENTS_LFG_DBC_LEVEL_OVERRIDE) && ar && ar->levelMax > 0 && ar->levelMax < level))
                lockData = LFG_LOCKSTATUS_TOO_HIGH_LEVEL;
            else if (dungeon->seasonal && !IsSeasonActive(dungeon->id))
                lockData = LFG_LOCKSTATUS_NOT_IN_SEASON;
            else if (player->IsClass(CLASS_DEATH_KNIGHT) && !player->IsGameMaster() &&!(player->IsQuestRewarded(13188) || player->IsQuestRewarded(13189)))
                lockData = LFG_LOCKSTATUS_QUEST_NOT_COMPLETED;
            else if (ar)
            {
                // Check required items
                for (const ProgressionRequirement* itemRequirement : ar->items)
                {
                    if (!itemRequirement->checkLeaderOnly || !group || group->GetLeaderGUID() == player->GetGUID())
                    {
                        if (itemRequirement->faction == TEAM_NEUTRAL || itemRequirement->faction == player->GetTeamId(true))
                        {
                            if (!player->HasItemCount(itemRequirement->id, 1))
                            {
                                lockData = LFG_LOCKSTATUS_MISSING_ITEM;
                                break;
                            }
                        }
                    }
                }
 
                //Check for quests
                for (const ProgressionRequirement* questRequirement : ar->quests)
                {
                    if (!questRequirement->checkLeaderOnly || !group || group->GetLeaderGUID() == player->GetGUID())
                    {
                        if (questRequirement->faction == TEAM_NEUTRAL || questRequirement->faction == player->GetTeamId(true))
                        {
                            if (!player->GetQuestRewardStatus(questRequirement->id))
                            {
                                lockData = LFG_LOCKSTATUS_QUEST_NOT_COMPLETED;
                                break;
                            }
                        }
                    }
                }
 
                //Check for ilvl
                if (ar->reqItemLevel && (float)ar->reqItemLevel > avgItemLevel)
                {
                    lockData = LFG_LOCKSTATUS_TOO_LOW_GEAR_SCORE;
                }
 
                //Check if player has the required achievements
                for (const ProgressionRequirement* achievementRequirement : ar->achievements)
                {
                    if (!achievementRequirement->checkLeaderOnly || !group || group->GetLeaderGUID() == player->GetGUID())
                    {
                        if (achievementRequirement->faction == TEAM_NEUTRAL || achievementRequirement->faction == player->GetTeamId(true))
                        {
                            if (!player->HasAchieved(achievementRequirement->id))
                            {
                                lockData = LFG_LOCKSTATUS_MISSING_ACHIEVEMENT;
                                break;
                            }
                        }
                    }
                }
            }
 
            sScriptMgr->OnInitializeLockedDungeons(player, level, lockData, dungeon);
 
            /* TODO VoA closed if WG is not under team control (LFG_LOCKSTATUS_RAID_LOCKED)
                lockData = LFG_LOCKSTATUS_TOO_LOW_GEAR_SCORE;
                lockData = LFG_LOCKSTATUS_TOO_HIGH_GEAR_SCORE;
                lockData = LFG_LOCKSTATUS_ATTUNEMENT_TOO_LOW_LEVEL;
                lockData = LFG_LOCKSTATUS_ATTUNEMENT_TOO_HIGH_LEVEL;
            */
 
            if (lockData)
                lock[dungeon->Entry()] = lockData;
        }
 
        sScriptMgr->OnAfterInitializeLockedDungeons(player);
 
        SetLockedDungeons(guid, lock);
    }

Referenced by LoadLFGDungeons().

◆ inLfgDungeonMap()

bool lfg::LFGMgr::inLfgDungeonMap	(	ObjectGuid	guid,
		uint32	map,
		Difficulty	difficulty
	)

Check if given guid applied for given map and difficulty. Used to know.

    {
        if (!guid.IsGroup())
            guid = GetGroup(guid);
 
        if (uint32 dungeonId = GetDungeon(guid, true))
            if (LFGDungeonData const* dungeon = GetLFGDungeon(dungeonId))
                if (uint32(dungeon->map) == map && dungeon->difficulty == difficulty)
                    return true;
 
        return false;
    }

References GetDungeon(), GetGroup(), GetLFGDungeon(), and ObjectGuid::IsGroup().

◆ instance()

LFGMgr * lfg::LFGMgr::instance ( )

static

    {
        static LFGMgr instance;
        return &instance;
    }

References instance().

Referenced by instance().

◆ IsDungeonDisabled()

bool lfg::LFGMgr::IsDungeonDisabled	(	uint32	mapId,
		Difficulty	difficulty
	)		const

Checks if given dungeon map is disabled.

    {
        return sDisableMgr->IsDisabledFor(DISABLE_TYPE_MAP, mapId, nullptr, difficulty) ||
            sDisableMgr->IsDisabledFor(DISABLE_TYPE_LFG_MAP, mapId, nullptr);
    }

References DISABLE_TYPE_LFG_MAP, DISABLE_TYPE_MAP, and sDisableMgr.

Referenced by GetCompatibleDungeons(), and InitializeLockedDungeons().

◆ IsLfgGroup()

bool lfg::LFGMgr::IsLfgGroup ( ObjectGuid guid )

Check if given group guid is lfg.

    {
        return guid && guid.IsGroup() && GroupsStore[guid].IsLfgGroup();
    }

References GroupsStore, and ObjectGuid::IsGroup().

◆ isOptionEnabled()

bool lfg::LFGMgr::isOptionEnabled ( uint32 option )

Checks if given lfg option is enabled.

    {
        return m_options & option;
    }

References m_options.

Referenced by Update().

◆ IsPlayerQueuedForRandomDungeon()

bool lfg::LFGMgr::IsPlayerQueuedForRandomDungeon ( ObjectGuid guid )

    {
        auto gguid = GetGroup(guid);
        if (!gguid)
            return false;
 
        return GroupsStore[gguid].IsRandomQueuedPlayer(guid);
    }

References GetGroup(), and GroupsStore.

◆ IsSeasonActive()

bool lfg::LFGMgr::IsSeasonActive ( uint32 dungeonId )

Checks if Seasonal dungeon is active.

    {
        switch (dungeonId)
        {
            case LFG_DUNGEON_HEADLESS_HORSEMAN:
                return IsHolidayActive(HOLIDAY_HALLOWS_END);
            case LFG_DUNGEON_FROST_LORD_AHUNE:
                return IsHolidayActive(HOLIDAY_FIRE_FESTIVAL);
            case LFG_DUNGEON_COREN_DIREBREW:
                return IsHolidayActive(HOLIDAY_BREWFEST);
            case LFG_DUNGEON_CROWN_CHEMICAL_CO:
                return IsHolidayActive(HOLIDAY_LOVE_IS_IN_THE_AIR);
        }
        return false;
    }

References HOLIDAY_BREWFEST, HOLIDAY_FIRE_FESTIVAL, HOLIDAY_HALLOWS_END, HOLIDAY_LOVE_IS_IN_THE_AIR, IsHolidayActive(), lfg::LFG_DUNGEON_COREN_DIREBREW, lfg::LFG_DUNGEON_CROWN_CHEMICAL_CO, lfg::LFG_DUNGEON_FROST_LORD_AHUNE, and lfg::LFG_DUNGEON_HEADLESS_HORSEMAN.

Referenced by InitializeLockedDungeons().

◆ IsTesting()

bool lfg::LFGMgr::IsTesting ( ) const

inline

For 1 player queue testing.

588{ return m_Testing; }

References m_Testing.

◆ JoinLfg()

void lfg::LFGMgr::JoinLfg	(	Player *	player,
		uint8	roles,
		LfgDungeonSet &	dungeons,
		std::string const &	comment
	)

Join Lfg with selected roles, dungeons and comment.

Adds the player/group to lfg queue. If player is in a group then it is the leader of the group tying to join the group. Join conditions are checked before adding to the new queue.

Parameters

[in]	player	Player trying to join (or leader of group trying to join)
[in]	roles	Player selected roles
[in]	dungeons	Dungeons the player/group is applying for
[in]	comment	Player selected comment

    {
        if (!player || dungeons.empty())
            return;
 
        Group* grp = player->GetGroup();
        ObjectGuid guid = player->GetGUID();
        ObjectGuid gguid = grp ? grp->GetGUID() : guid;
        LfgJoinResultData joinData;
        LfgGuidSet players;
        uint32 rDungeonId = 0;
        bool isContinue = grp && grp->isLFGGroup() && GetState(gguid) != LFG_STATE_FINISHED_DUNGEON;
 
        if (grp && (grp->isBGGroup() || grp->isBFGroup()))
            return;
 
        if (!sScriptMgr->OnPlayerCanJoinLfg(player, roles, dungeons, comment))
            return;
 
        // pussywizard: can't join LFG/LFR while using LFR
        if (GetState(player->GetGUID()) == LFG_STATE_RAIDBROWSER)
        {
            LfgDungeonSet tmp;
            SendRaidBrowserJoinedPacket(player, tmp, ""); // the df "eye" can disappear in various case, resend if needed
            return;
        }
 
        // Do not allow to change dungeon in the middle of a current dungeon
        if (isContinue)
        {
            dungeons.clear();
            dungeons.insert(GetDungeon(gguid));
        }
 
        LfgState state = GetState(gguid);
        switch (state)
        {
            case LFG_STATE_ROLECHECK: // if joining again during rolecheck (eg. many players clicked continue inside instance)
                if (gguid.IsGroup())
                    UpdateRoleCheck(gguid); // abort role check and remove from RoleChecksStore
                break;
            case LFG_STATE_QUEUED: // joining again while in a queue
                {
                    LFGQueue& queue = GetQueue(gguid);
                    queue.RemoveFromQueue(gguid);
                }
                break;
            case LFG_STATE_PROPOSAL: // if joining again during proposal
                joinData.result = LFG_JOIN_INTERNAL_ERROR;
                break;
            /*case LFG_STATE_FINISHED_DUNGEON:
                if (grp && grp->isLFGGroup())
                    joinData.result = LFG_JOIN_PARTY_NOT_MEET_REQS;
                break;
            */
            default:
                break;
        }
 
        // Check if all dungeons are valid
        bool isRaid = false;
        if (joinData.result == LFG_JOIN_OK)
        {
            bool isDungeon = false;
            for (LfgDungeonSet::const_iterator it = dungeons.begin(); it != dungeons.end() && joinData.result == LFG_JOIN_OK; ++it)
            {
                LfgType type = GetDungeonType(*it);
                switch (type)
                {
                    case LFG_TYPE_RANDOM:
                        if (dungeons.size() > 1)               // Only allow 1 random dungeon
                        {
                            joinData.result = LFG_JOIN_DUNGEON_INVALID;
                        }
                        else
                        {
                            rDungeonId = (*dungeons.begin());
                            sScriptMgr->OnPlayerQueueRandomDungeon(player, rDungeonId);
                        }
                        [[fallthrough]]; // On purpose (Random can only be dungeon or heroic dungeon)
                    case LFG_TYPE_HEROIC:
                    case LFG_TYPE_DUNGEON:
                        if (isRaid)
                        {
                            joinData.result = LFG_JOIN_MIXED_RAID_DUNGEON;
                        }
                        isDungeon = true;
                        break;
                    case LFG_TYPE_RAID:
                        if (isDungeon)
                        {
                            joinData.result = LFG_JOIN_MIXED_RAID_DUNGEON;
                        }
                        isRaid = true;
                        break;
                    default:
                        LOG_ERROR("lfg", "Wrong dungeon type {} for dungeon {}", type, *it);
                        joinData.result = LFG_JOIN_DUNGEON_INVALID;
                        break;
                }
            }
        }
 
        if (!isRaid && joinData.result == LFG_JOIN_OK)
        {
            // Check player or group member restrictions
            if (!player->GetSession()->HasPermission(rbac::RBAC_PERM_JOIN_DUNGEON_FINDER))
            {
                joinData.result = LFG_JOIN_NOT_MEET_REQS;
            }
            else if (player->InBattleground() || (player->InBattlegroundQueue() && !sWorld->getBoolConfig(CONFIG_ALLOW_JOIN_BG_AND_LFG)))
            {
                joinData.result = LFG_JOIN_USING_BG_SYSTEM;
            }
            else if (player->HasAura(LFG_SPELL_DUNGEON_DESERTER))
            {
                joinData.result = LFG_JOIN_DESERTER;
            }
            else if (dungeons.empty())
            {
                joinData.result = LFG_JOIN_NOT_MEET_REQS;
            }
            else if (grp)
            {
                if (grp->GetMembersCount() > MAXGROUPSIZE)
                    joinData.result = LFG_JOIN_TOO_MUCH_MEMBERS;
                else
                {
                    uint8 memberCount = 0;
                    for (GroupReference* itr = grp->GetFirstMember(); itr != nullptr && joinData.result == LFG_JOIN_OK; itr = itr->next())
                    {
                        if (Player* plrg = itr->GetSource())
                        {
                            if (!plrg->GetSession()->HasPermission(rbac::RBAC_PERM_JOIN_DUNGEON_FINDER))
                            {
                                joinData.result = LFG_JOIN_PARTY_NOT_MEET_REQS;
                            }
                            else if (plrg->HasAura(LFG_SPELL_DUNGEON_DESERTER))
                            {
                                joinData.result = LFG_JOIN_PARTY_DESERTER;
                            }
                            else if (plrg->InBattleground() || (plrg->InBattlegroundQueue() && !sWorld->getBoolConfig(CONFIG_ALLOW_JOIN_BG_AND_LFG)))
                            {
                                joinData.result = LFG_JOIN_USING_BG_SYSTEM;
                            }
 
                            ++memberCount;
                            players.insert(plrg->GetGUID());
                        }
                    }
 
                    if (joinData.result == LFG_JOIN_OK && memberCount != grp->GetMembersCount())
                        joinData.result = LFG_JOIN_DISCONNECTED;
                }
            }
            else
                players.insert(player->GetGUID());
 
            // Xinef: Check dungeon cooldown only for random dungeons
            // Xinef: Moreover check this only if dungeon is not started, afterwards its obvious that players will have the cooldown
            if (joinData.result == LFG_JOIN_OK && !isContinue && rDungeonId)
            {
                if (player->HasAura(LFG_SPELL_DUNGEON_COOLDOWN)) // xinef: added !isContinue
                    joinData.result = LFG_JOIN_RANDOM_COOLDOWN;
                else if (grp)
                {
                    for (GroupReference* itr = grp->GetFirstMember(); itr != nullptr && joinData.result == LFG_JOIN_OK; itr = itr->next())
                        if (Player* plrg = itr->GetSource())
                            if (plrg->HasAura(LFG_SPELL_DUNGEON_COOLDOWN)) // xinef: added !isContinue
                                joinData.result = LFG_JOIN_PARTY_RANDOM_COOLDOWN;
                }
            }
        }
 
        if (isRaid)
            players.insert(player->GetGUID());
 
        if (joinData.result == LFG_JOIN_OK)
        {
            // Expand random dungeons and check restrictions
            if (rDungeonId)
                dungeons = GetDungeonsByRandom(rDungeonId);
 
            // if we have lockmap then there are no compatible dungeons
            // xinef: dont check compatibile dungeons for already running group (bind problems)
            if (!isContinue)
            {
                GetCompatibleDungeons(dungeons, players, joinData.lockmap, rDungeonId);
                if (dungeons.empty())
                    joinData.result = grp ? LFG_JOIN_PARTY_NOT_MEET_REQS : LFG_JOIN_NOT_MEET_REQS;
            }
        }
 
        // pussywizard:
        if (isRaid && grp && (grp->isLFGGroup() || guid != grp->GetLeaderGUID()))
            return;
 
         // Do not allow to change dungeon in the middle of a current dungeon
        if (!isRaid && isContinue && grp->GetMembersCount() == 5)
        {
            dungeons.clear();
            dungeons.insert(GetDungeon(gguid));
            joinData.result = LFG_JOIN_PARTY_NOT_MEET_REQS;
        }
 
        // Can't join. Send result
        if (joinData.result != LFG_JOIN_OK)
        {
            LOG_DEBUG("lfg", "LFGMgr::Join: [{}] joining with {} members. result: {}", guid.ToString(), grp ? grp->GetMembersCount() : 1, joinData.result);
            if (!dungeons.empty())                             // Only should show lockmap when have no dungeons available
                joinData.lockmap.clear();
            player->GetSession()->SendLfgJoinResult(joinData);
            return;
        }
 
        SetComment(guid, comment);
 
        if (isRaid)
        {
            if (grp)
                roles = PLAYER_ROLE_LEADER;
            else
                roles &= (PLAYER_ROLE_TANK | PLAYER_ROLE_HEALER | PLAYER_ROLE_DAMAGE);
            if (!roles)
                return;
            JoinRaidBrowser(player, roles, dungeons, comment);
            SetState(guid, LFG_STATE_RAIDBROWSER);
            SendRaidBrowserJoinedPacket(player, dungeons, comment);
            return;
        }
 
        std::string debugNames = "";
        if (grp)                                               // Begin rolecheck
        {
            // Create new rolecheck
            LfgRoleCheck& roleCheck = RoleChecksStore[gguid];
            roleCheck.roles.clear(); // pussywizard: NEW rolecheck, not old one with trash data >_>
            roleCheck.cancelTime = time_t(GameTime::GetGameTime().count()) + LFG_TIME_ROLECHECK;
            roleCheck.state = LFG_ROLECHECK_INITIALITING;
            roleCheck.leader = guid;
            roleCheck.dungeons = dungeons;
            roleCheck.rDungeonId = rDungeonId;
 
            if (rDungeonId)
            {
                dungeons.clear();
                dungeons.insert(rDungeonId);
            }
 
            SetState(gguid, LFG_STATE_ROLECHECK);
            // Send update to player
            LfgUpdateData updateData = LfgUpdateData(LFG_UPDATETYPE_JOIN_QUEUE, dungeons, comment);
            for (GroupReference* itr = grp->GetFirstMember(); itr != nullptr; itr = itr->next())
            {
                if (Player* plrg = itr->GetSource())
                {
                    ObjectGuid pguid = plrg->GetGUID();
                    plrg->GetSession()->SendLfgUpdateParty(updateData);
                    SetState(pguid, LFG_STATE_ROLECHECK);
                    if (!isContinue)
                        SetSelectedDungeons(pguid, dungeons);
                    roleCheck.roles[pguid] = 0;
                    if (!debugNames.empty())
                        debugNames.append(", ");
                    debugNames.append(plrg->GetName());
                }
            }
            // Update leader role
            UpdateRoleCheck(gguid, guid, roles);
        }
        else                                                   // Add player to queue
        {
            LfgRolesMap rolesMap;
            rolesMap[guid] = roles;
            LFGQueue& queue = GetQueue(guid);
            queue.AddQueueData(guid, GameTime::GetGameTime().count(), dungeons, rolesMap);
 
            if (!isContinue)
            {
                if (rDungeonId)
                {
                    dungeons.clear();
                    dungeons.insert(rDungeonId);
                }
                SetSelectedDungeons(guid, dungeons);
            }
            // Send update to player
            player->GetSession()->SendLfgJoinResult(joinData);
            player->GetSession()->SendLfgUpdatePlayer(LfgUpdateData(LFG_UPDATETYPE_JOIN_QUEUE, dungeons, comment));
            SetState(guid, LFG_STATE_QUEUED);
            SetRoles(guid, roles);
            debugNames.append(player->GetName());
        }
 
        /*if (sLog->ShouldLog(LOG_FILTER_LFG, LOG_LEVEL_DEBUG))
        {
            std::ostringstream o;
            o << "LFGMgr::Join: [" << guid << "] joined (" << (grp ? "group" : "player") << ") Members: " << debugNames.c_str()
              << ". Dungeons (" << uint32(dungeons.size()) << "): " << ConcatenateDungeons(dungeons);
            LOG_DEBUG("lfg", "{}", o.str());
        }*/
    }

References lfg::LFGQueue::AddQueueData(), lfg::LfgRoleCheck::cancelTime, CONFIG_ALLOW_JOIN_BG_AND_LFG, lfg::LfgRoleCheck::dungeons, GetCompatibleDungeons(), GetDungeon(), GetDungeonsByRandom(), GetDungeonType(), Group::GetFirstMember(), GameTime::GetGameTime(), Player::GetGroup(), Group::GetGUID(), Object::GetGUID(), Group::GetLeaderGUID(), Group::GetMembersCount(), WorldObject::GetName(), GetQueue(), Player::GetSession(), GetState(), Unit::HasAura(), WorldSession::HasPermission(), Player::InBattleground(), Player::InBattlegroundQueue(), Group::isBFGroup(), Group::isBGGroup(), ObjectGuid::IsGroup(), Group::isLFGGroup(), JoinRaidBrowser(), lfg::LfgRoleCheck::leader, lfg::LFG_JOIN_DESERTER, lfg::LFG_JOIN_DISCONNECTED, lfg::LFG_JOIN_DUNGEON_INVALID, lfg::LFG_JOIN_INTERNAL_ERROR, lfg::LFG_JOIN_MIXED_RAID_DUNGEON, lfg::LFG_JOIN_NOT_MEET_REQS, lfg::LFG_JOIN_OK, lfg::LFG_JOIN_PARTY_DESERTER, lfg::LFG_JOIN_PARTY_NOT_MEET_REQS, lfg::LFG_JOIN_PARTY_RANDOM_COOLDOWN, lfg::LFG_JOIN_RANDOM_COOLDOWN, lfg::LFG_JOIN_TOO_MUCH_MEMBERS, lfg::LFG_JOIN_USING_BG_SYSTEM, lfg::LFG_ROLECHECK_INITIALITING, lfg::LFG_SPELL_DUNGEON_COOLDOWN, lfg::LFG_SPELL_DUNGEON_DESERTER, lfg::LFG_STATE_FINISHED_DUNGEON, lfg::LFG_STATE_PROPOSAL, lfg::LFG_STATE_QUEUED, lfg::LFG_STATE_RAIDBROWSER, lfg::LFG_STATE_ROLECHECK, lfg::LFG_TIME_ROLECHECK, lfg::LFG_TYPE_DUNGEON, lfg::LFG_TYPE_HEROIC, lfg::LFG_TYPE_RAID, lfg::LFG_TYPE_RANDOM, lfg::LFG_UPDATETYPE_JOIN_QUEUE, lfg::LfgJoinResultData::lockmap, LOG_DEBUG, LOG_ERROR, MAXGROUPSIZE, lfg::PLAYER_ROLE_DAMAGE, lfg::PLAYER_ROLE_HEALER, lfg::PLAYER_ROLE_LEADER, lfg::PLAYER_ROLE_TANK, rbac::RBAC_PERM_JOIN_DUNGEON_FINDER, lfg::LfgRoleCheck::rDungeonId, lfg::LFGQueue::RemoveFromQueue(), lfg::LfgJoinResultData::result, RoleChecksStore, lfg::LfgRoleCheck::roles, WorldSession::SendLfgJoinResult(), WorldSession::SendLfgUpdatePlayer(), SendRaidBrowserJoinedPacket(), SetComment(), SetRoles(), SetSelectedDungeons(), SetState(), sScriptMgr, lfg::LfgRoleCheck::state, sWorld, ObjectGuid::ToString(), and UpdateRoleCheck().

◆ JoinRaidBrowser()

void lfg::LFGMgr::JoinRaidBrowser	(	Player *	player,
		uint8	roles,
		LfgDungeonSet &	dungeons,
		std::string	comment
	)

pussywizard: Raid Browser

    {
        // pussywizard: client limit for comment length is 64 @ 3.3.5a
        if (comment.size() > 64)
            comment = comment.substr(0, 64);
 
        RBEntryInfo entry(roles, comment);
        for (LfgDungeonSet::const_iterator itr = dungeons.begin(); itr != dungeons.end(); ++itr)
            if (GetLFGDungeon(*itr)) // ensure dungeon data exists for such dungeon id
            {
                RaidBrowserStore[player->GetTeamId()][*itr][player->GetGUID()] = entry;
                RBUsedDungeonsStore[player->GetTeamId()].insert(*itr);
            }
    }

References Object::GetGUID(), GetLFGDungeon(), Player::GetTeamId(), RaidBrowserStore, and RBUsedDungeonsStore.

Referenced by JoinLfg().

◆ LeaveAllLfgQueues()

void lfg::LFGMgr::LeaveAllLfgQueues	(	ObjectGuid	guid,
		bool	allowgroup,
		ObjectGuid	groupguid = `ObjectGuid::Empty`
	)

pussywizard: cleans all queues' data

    {
        ObjectGuid pguid, gguid;
        if (guid.IsGroup())
            gguid = guid;
        else if (groupguid && groupguid.IsGroup())
        {
            pguid = guid;
            gguid = groupguid;
        }
        else
        {
            pguid = guid;
            gguid = GetGroup(guid);
        }
        if (!allowgroup)
            gguid.Clear();
 
        if (pguid)
            for (lfg::LfgQueueContainer::iterator itr = QueuesStore.begin(); itr != QueuesStore.end(); ++itr)
                itr->second.RemoveFromQueue(pguid);
        if (gguid)
            for (lfg::LfgQueueContainer::iterator itr = QueuesStore.begin(); itr != QueuesStore.end(); ++itr)
                itr->second.RemoveFromQueue(gguid);
 
        if (pguid && !gguid)
        {
            if (GetState(pguid) == LFG_STATE_QUEUED)
            {
                SendLfgUpdatePlayer(pguid, LfgUpdateData(LFG_UPDATETYPE_REMOVED_FROM_QUEUE));
                SetState(pguid, LFG_STATE_NONE);
            }
        }
        if (gguid)
        {
            if (GetState(gguid) == LFG_STATE_QUEUED)
            {
                SetState(gguid, LFG_STATE_NONE);
                const LfgGuidSet& players = GetPlayers(gguid);
                for (LfgGuidSet::const_iterator it = players.begin(); it != players.end(); ++it)
                {
                    SetState(*it, LFG_STATE_NONE);
                    SendLfgUpdateParty(*it, LfgUpdateData(LFG_UPDATETYPE_REMOVED_FROM_QUEUE));
                }
            }
        }
    }

References ObjectGuid::Clear(), GetGroup(), GetPlayers(), GetState(), ObjectGuid::IsGroup(), lfg::LFG_STATE_NONE, lfg::LFG_STATE_QUEUED, lfg::LFG_UPDATETYPE_REMOVED_FROM_QUEUE, QueuesStore, SendLfgUpdateParty(), SendLfgUpdatePlayer(), and SetState().

◆ LeaveLfg()

void lfg::LFGMgr::LeaveLfg ( ObjectGuid guid )

Leaves lfg.

Leaves Dungeon System. Player/Group is removed from queue, rolechecks, proposals or votekicks. Player or group needs to be not nullptr and using Dungeon System

Parameters

[in] guid Player or group guid

    {
        LOG_DEBUG("lfg", "LFGMgr::Leave: [{}]", guid.ToString());
        ObjectGuid gguid = guid.IsGroup() ? guid : GetGroup(guid);
        LfgState state = GetState(guid);
        switch (state)
        {
            case LFG_STATE_QUEUED:
                if (gguid)
                {
                    LFGQueue& queue = GetQueue(gguid);
                    queue.RemoveFromQueue(gguid);
                    uint32 dungeonId = GetDungeon(gguid);
                    SetState(gguid, LFG_STATE_NONE);
                    const LfgGuidSet& players = GetPlayers(gguid);
                    for (LfgGuidSet::const_iterator it = players.begin(); it != players.end(); ++it)
                    {
                        SetState(*it, LFG_STATE_NONE);
                        SendLfgUpdateParty(*it, LfgUpdateData(LFG_UPDATETYPE_REMOVED_FROM_QUEUE));
                    }
                    if (Group* group = sGroupMgr->GetGroupByGUID(gguid.GetCounter()))
                    {
                        if (group->isLFGGroup())
                        {
                            SetDungeon(gguid, dungeonId);
                        }
                    }
                }
                else
                {
                    LFGQueue& queue = GetQueue(guid);
                    queue.RemoveFromQueue(guid);
                    SendLfgUpdatePlayer(guid, LfgUpdateData(LFG_UPDATETYPE_REMOVED_FROM_QUEUE));
                    SetState(guid, LFG_STATE_NONE);
                }
                break;
            case LFG_STATE_ROLECHECK:
                if (gguid)
                    UpdateRoleCheck(gguid);                    // No player to update role = LFG_ROLECHECK_ABORTED
                break;
            case LFG_STATE_PROPOSAL:
                {
                    // Remove from Proposals
                    LfgProposalContainer::iterator it = ProposalsStore.begin();
                    ObjectGuid pguid = gguid == guid ? GetLeader(gguid) : guid;
                    while (it != ProposalsStore.end())
                    {
                        LfgProposalPlayerContainer::iterator itPlayer = it->second.players.find(pguid);
                        if (itPlayer != it->second.players.end())
                        {
                            // Mark the player/leader of group who left as didn't accept the proposal
                            itPlayer->second.accept = LFG_ANSWER_DENY;
                            break;
                        }
                        ++it;
                    }
 
                    // Remove from queue - if proposal is found, RemoveProposal will call RemoveFromQueue
                    if (it != ProposalsStore.end())
                        RemoveProposal(it, LFG_UPDATETYPE_PROPOSAL_DECLINED);
                    break;
                }
            case LFG_STATE_NONE:
                break;
            case LFG_STATE_DUNGEON:
            case LFG_STATE_FINISHED_DUNGEON:
            case LFG_STATE_BOOT:
                if (guid != gguid) // Player
                    SetState(guid, LFG_STATE_NONE);
                break;
            case LFG_STATE_RAIDBROWSER:
                LeaveRaidBrowser(guid);
                SetCanOverrideRBState(guid, true);
                SetState(guid, LFG_STATE_NONE);
                SetCanOverrideRBState(guid, false);
                SendLfgUpdatePlayer(guid, LfgUpdateData(LFG_UPDATETYPE_LEAVE_RAIDBROWSER));
                SendLfgUpdateParty(guid, LfgUpdateData(LFG_UPDATETYPE_LEAVE_RAIDBROWSER));
                break;
        }
    }

References ObjectGuid::GetCounter(), GetDungeon(), GetGroup(), GetLeader(), GetPlayers(), GetQueue(), GetState(), ObjectGuid::IsGroup(), LeaveRaidBrowser(), lfg::LFG_ANSWER_DENY, lfg::LFG_STATE_BOOT, lfg::LFG_STATE_DUNGEON, lfg::LFG_STATE_FINISHED_DUNGEON, lfg::LFG_STATE_NONE, lfg::LFG_STATE_PROPOSAL, lfg::LFG_STATE_QUEUED, lfg::LFG_STATE_RAIDBROWSER, lfg::LFG_STATE_ROLECHECK, lfg::LFG_UPDATETYPE_LEAVE_RAIDBROWSER, lfg::LFG_UPDATETYPE_PROPOSAL_DECLINED, lfg::LFG_UPDATETYPE_REMOVED_FROM_QUEUE, LOG_DEBUG, ProposalsStore, lfg::LFGQueue::RemoveFromQueue(), RemoveProposal(), SendLfgUpdateParty(), SendLfgUpdatePlayer(), SetCanOverrideRBState(), SetDungeon(), SetState(), sGroupMgr, ObjectGuid::ToString(), and UpdateRoleCheck().

◆ LeaveRaidBrowser()

void lfg::LFGMgr::LeaveRaidBrowser ( ObjectGuid guid )

    {
        for (uint8 team = 0; team < 2; ++team)
            for (RBStoreMap::iterator itr = RaidBrowserStore[team].begin(); itr != RaidBrowserStore[team].end(); ++itr)
                itr->second.erase(guid);
    }

References RaidBrowserStore.

Referenced by LeaveLfg().

◆ LfrSearchAdd()

void lfg::LFGMgr::LfrSearchAdd	(	Player *	p,
		uint32	dungeonId
	)

    {
        RBSearchersStore[p->GetTeamId()][p->GetGUID()] = dungeonId;
    }

References Object::GetGUID(), Player::GetTeamId(), and RBSearchersStore.

◆ LfrSearchRemove()

void lfg::LFGMgr::LfrSearchRemove ( Player * p )

    {
        RBSearchersStore[p->GetTeamId()].erase(p->GetGUID());
    }

References Object::GetGUID(), Player::GetTeamId(), and RBSearchersStore.

◆ LfrSetComment()

void lfg::LFGMgr::LfrSetComment	(	Player *	p,
		std::string	comment
	)

    {
        // pussywizard: client limit for comment length is 64 @ 3.3.5a
        if (comment.size() > 64)
            comment = comment.substr(0, 64);
 
        uint8 teamId = p->GetTeamId();
        RBEntryInfoMap::iterator iter;
        for (RBStoreMap::iterator itr = RaidBrowserStore[teamId].begin(); itr != RaidBrowserStore[teamId].end(); ++itr)
            if ((iter = itr->second.find(p->GetGUID())) != itr->second.end())
                iter->second.comment = comment;
    }

References Object::GetGUID(), Player::GetTeamId(), and RaidBrowserStore.

◆ LoadLFGDungeons()

void lfg::LFGMgr::LoadLFGDungeons ( bool reload = false )

Loads dungeons from dbc and adds teleport coords.

    {
        uint32 oldMSTime = getMSTime();
 
        LfgDungeonStore.clear();
 
        // Initialize Dungeon map with data from dbcs
        for (uint32 i = 0; i < sLFGDungeonStore.GetNumRows(); ++i)
        {
            LFGDungeonEntry const* dungeon = sLFGDungeonStore.LookupEntry(i);
            if (!dungeon)
                continue;
 
            switch (dungeon->TypeID)
            {
                case LFG_TYPE_DUNGEON:
                case LFG_TYPE_HEROIC:
                case LFG_TYPE_RAID:
                case LFG_TYPE_RANDOM:
                    LfgDungeonStore[dungeon->ID] = LFGDungeonData(dungeon);
                    break;
            }
        }
 
        // Fill teleport locations from DB
        //                                                   0          1           2           3            4
        QueryResult result = WorldDatabase.Query("SELECT dungeonId, position_x, position_y, position_z, orientation FROM lfg_dungeon_template");
 
        if (!result)
        {
            LOG_ERROR("lfg", ">> Loaded 0 LFG Entrance Positions. DB Table `lfg_dungeon_template` Is Empty!");
            LOG_INFO("server.loading", " ");
            return;
        }
 
        uint32 count = 0;
 
        do
        {
            Field* fields = result->Fetch();
            uint32 dungeonId = fields[0].Get<uint32>();
            LFGDungeonContainer::iterator dungeonItr = LfgDungeonStore.find(dungeonId);
            if (dungeonItr == LfgDungeonStore.end())
            {
                LOG_ERROR("lfg", "table `lfg_dungeon_template` contains coordinates for wrong dungeon {}", dungeonId);
                continue;
            }
 
            LFGDungeonData& data = dungeonItr->second;
            data.x = fields[1].Get<float>();
            data.y = fields[2].Get<float>();
            data.z = fields[3].Get<float>();
            data.o = fields[4].Get<float>();
 
            ++count;
        } while (result->NextRow());
 
        LOG_INFO("server.loading", ">> Loaded {} LFG Entrance Positions in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
        LOG_INFO("server.loading", " ");
 
        // Fill all other teleport coords from areatriggers
        for (LFGDungeonContainer::iterator itr = LfgDungeonStore.begin(); itr != LfgDungeonStore.end(); ++itr)
        {
            LFGDungeonData& dungeon = itr->second;
 
            // No teleport coords in database, load from areatriggers
            if (dungeon.type != LFG_TYPE_RANDOM && dungeon.x == 0.0f && dungeon.y == 0.0f && dungeon.z == 0.0f)
            {
                AreaTriggerTeleport const* at = sObjectMgr->GetMapEntranceTrigger(dungeon.map);
                if (!at)
                {
                    LOG_ERROR("lfg", "LFGMgr::LoadLFGDungeons: Failed to load dungeon {}, cant find areatrigger for map {}", dungeon.name, dungeon.map);
                    continue;
                }
 
                dungeon.map = at->target_mapId;
                dungeon.x = at->target_X;
                dungeon.y = at->target_Y;
                dungeon.z = at->target_Z;
                dungeon.o = at->target_Orientation;
            }
 
            if (dungeon.type != LFG_TYPE_RANDOM)
                CachedDungeonMapStore[dungeon.group].insert(dungeon.id);
            CachedDungeonMapStore[0].insert(dungeon.id);
        }
 
        if (reload)
        {
            CachedDungeonMapStore.clear();
            // Recalculate locked dungeons
            for (LfgPlayerDataContainer::const_iterator it = PlayersStore.begin(); it != PlayersStore.end(); ++it)
                if (Player* player = ObjectAccessor::FindConnectedPlayer(it->first))
                    InitializeLockedDungeons(player, nullptr);
        }
    }

◆ LoadRewards()

void lfg::LFGMgr::LoadRewards ( )

Loads rewards for random dungeons.

Load rewards for completing dungeons.

    {
        uint32 oldMSTime = getMSTime();
 
        for (LfgRewardContainer::iterator itr = RewardMapStore.begin(); itr != RewardMapStore.end(); ++itr)
            delete itr->second;
        RewardMapStore.clear();
 
        // ORDER BY is very important for GetRandomDungeonReward!
        QueryResult result = WorldDatabase.Query("SELECT dungeonId, maxLevel, firstQuestId, otherQuestId FROM lfg_dungeon_rewards ORDER BY dungeonId, maxLevel ASC");
 
        if (!result)
        {
            LOG_ERROR("lfg", ">> Loaded 0 lfg dungeon rewards. DB table `lfg_dungeon_rewards` is empty!");
            return;
        }
 
        uint32 count = 0;
 
        Field* fields = nullptr;
        do
        {
            fields = result->Fetch();
            uint32 dungeonId = fields[0].Get<uint32>();
            uint32 maxLevel = fields[1].Get<uint8>();
            uint32 firstQuestId = fields[2].Get<uint32>();
            uint32 otherQuestId = fields[3].Get<uint32>();
 
            if (!GetLFGDungeonEntry(dungeonId))
            {
                LOG_ERROR("lfg", "Dungeon {} specified in table `lfg_dungeon_rewards` does not exist!", dungeonId);
                continue;
            }
 
            if (!maxLevel || maxLevel > sWorld->getIntConfig(CONFIG_MAX_PLAYER_LEVEL))
            {
                LOG_ERROR("lfg", "Level {} specified for dungeon {} in table `lfg_dungeon_rewards` can never be reached!", maxLevel, dungeonId);
                maxLevel = sWorld->getIntConfig(CONFIG_MAX_PLAYER_LEVEL);
            }
 
            if (!firstQuestId || !sObjectMgr->GetQuestTemplate(firstQuestId))
            {
                LOG_ERROR("lfg", "First quest {} specified for dungeon {} in table `lfg_dungeon_rewards` does not exist!", firstQuestId, dungeonId);
                continue;
            }
 
            if (otherQuestId && !sObjectMgr->GetQuestTemplate(otherQuestId))
            {
                LOG_ERROR("lfg", "Other quest {} specified for dungeon {} in table `lfg_dungeon_rewards` does not exist!", otherQuestId, dungeonId);
                otherQuestId = 0;
            }
 
            RewardMapStore.insert(LfgRewardContainer::value_type(dungeonId, new LfgReward(maxLevel, firstQuestId, otherQuestId)));
            ++count;
        } while (result->NextRow());
 
        LOG_INFO("server.loading", ">> Loaded {} LFG Dungeon Rewards in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
        LOG_INFO("server.loading", " ");
    }

References CONFIG_MAX_PLAYER_LEVEL, Field::Get(), GetLFGDungeonEntry(), getMSTime(), GetMSTimeDiffToNow(), LOG_ERROR, LOG_INFO, RewardMapStore, sObjectMgr, sWorld, and WorldDatabase.

◆ MakeNewGroup()

void lfg::LFGMgr::MakeNewGroup ( LfgProposal const & proposal )

private

Makes a new group given a proposal

Parameters

[in] proposal Proposal to get info from

    {
        LfgGuidList players;
        GuidUnorderedSet playersToTeleport;
 
        // Sort players by role, leader first, then tank, healer and dps
        std::vector<ObjectGuid> tanks, healers, dps;
 
        if (proposal.leader && proposal.players.contains(proposal.leader))
            players.push_back(proposal.leader);
 
        for (auto const& [guid, player] : proposal.players)
        {
            if (proposal.isNew || GetGroup(guid) != proposal.group)
                playersToTeleport.insert(guid);
 
            if (guid == proposal.leader)
                continue;
 
            if (player.role & lfg::PLAYER_ROLE_TANK)
                tanks.push_back(guid);
            else if (player.role & lfg::PLAYER_ROLE_HEALER)
                healers.push_back(guid);
            else
                dps.push_back(guid);
        }
 
        players.insert(players.end(), tanks.begin(), tanks.end());
        players.insert(players.end(), healers.begin(), healers.end());
        players.insert(players.end(), dps.begin(), dps.end());
 
        // Set the dungeon difficulty
        LFGDungeonData const* dungeon = GetLFGDungeon(proposal.dungeonId);
        ASSERT(dungeon);
 
        bool isPremadeGroup = false;
        Group* grp = proposal.group ? sGroupMgr->GetGroupByGUID(proposal.group.GetCounter()) : nullptr;
        if (!grp)
        {
            ObjectGuid groupGUID;
            for (ObjectGuid const& guid : players)
            {
                if (Player* player = ObjectAccessor::FindConnectedPlayer(guid))
                {
                    Group* group = player->GetGroup();
                    if (!group || (groupGUID && groupGUID != group->GetGUID()))
                    {
                        isPremadeGroup = false;
                        break;
                    }
 
                    groupGUID = group->GetGUID();
                    isPremadeGroup = true;
                }
            }
        }
 
        ObjectGuid oldGroupGUID;
        bool hasRandomLfgMember = proposal.group.IsEmpty();
        for (LfgGuidList::const_iterator it = players.begin(); it != players.end(); ++it)
        {
            ObjectGuid pguid = (*it);
            Player* player = ObjectAccessor::FindConnectedPlayer(pguid);
            if (!player)
                continue;
 
            Group* group = player->GetGroup();
            if (isPremadeGroup && !grp)
            {
                oldGroupGUID = group->GetGUID();
                grp = group;
                grp->ConvertToLFG(false);
                SetState(grp->GetGUID(), LFG_STATE_PROPOSAL);
            }
 
            if (auto const proposalPlayer = proposal.players.find(pguid); proposalPlayer != proposal.players.end())
            {
                if (!hasRandomLfgMember && (proposalPlayer->second.group.IsEmpty() || proposalPlayer->second.group != proposal.group))
                    hasRandomLfgMember = true;
            }
            else
                hasRandomLfgMember = true;
 
            // Xinef: Apply Random Buff
            if (grp && !grp->IsLfgWithBuff() && hasRandomLfgMember)
            {
                if (!group || group->GetGUID() != oldGroupGUID)
                    grp->AddLfgBuffFlag();
                else
                    oldGroupGUID = group->GetGUID();
            }
 
            // Xinef: Store amount of random players player grouped with
            if (group)
            {
                SetRandomPlayersCount(pguid, group->GetMembersCount() >= MAXGROUPSIZE ? 0 : MAXGROUPSIZE - group->GetMembersCount());
                oldGroupGUID = group->GetGUID();
                if (group != grp)
                    group->RemoveMember(player->GetGUID());
            }
            else
                SetRandomPlayersCount(pguid, MAXGROUPSIZE - 1);
 
            if (!grp)
            {
                grp = new Group();
                grp->ConvertToLFG();
                grp->Create(player);
                ObjectGuid gguid = grp->GetGUID();
                SetState(gguid, LFG_STATE_PROPOSAL);
                sGroupMgr->AddGroup(grp);
                grp->SetLfgRoles(pguid, proposal.players.find(pguid)->second.role);
            }
            else if (group != grp)
            {
                if (!grp->IsFull())
                    grp->AddMember(player, proposal.players.find(pguid)->second.role);
            }
            else
            {
                grp->SetLfgRoles(pguid, proposal.players.find(pguid)->second.role);
            }
        }
 
        // pussywizard: crashfix, group wasn't created when iterating players (no player found by guid), proposal is deleted by the calling function
        if (!grp)
            return;
 
        grp->SetDungeonDifficulty(Difficulty(dungeon->difficulty));
        ObjectGuid gguid = grp->GetGUID();
        SetDungeon(gguid, dungeon->Entry());
        SetState(gguid, LFG_STATE_DUNGEON);
 
        _SaveToDB(gguid);
 
        // Select a player inside to be teleported to
        WorldLocation const* teleportLocation = nullptr;
        bool leaderTeleportIncluded = false;
        for (GroupReference* itr = grp->GetFirstMember(); itr != nullptr; itr = itr->next())
        {
            if (Player* plr = itr->GetSource())
            {
                if (grp->IsLeader(plr->GetGUID()) && playersToTeleport.find(plr->GetGUID()) != playersToTeleport.end())
                {
                    leaderTeleportIncluded = true;
                }
 
                if (plr->GetMapId() == uint32(dungeon->map) && !proposal.isNew)
                {
                    teleportLocation = plr;
                    break;
                }
 
                // Remove from battleground queues
                for (uint8 i = 0; i < PLAYER_MAX_BATTLEGROUND_QUEUES; ++i)
                {
                    if (BattlegroundQueueTypeId bgQueueTypeId = plr->GetBattlegroundQueueTypeId(i))
                    {
                        if (bgQueueTypeId != BATTLEGROUND_QUEUE_NONE)
                        {
                            plr->RemoveBattlegroundQueueId(bgQueueTypeId);
                            sBattlegroundMgr->GetBattlegroundQueue(bgQueueTypeId).RemovePlayer(plr->GetGUID(), true);
                        }
                    }
                }
            }
        }
 
        bool randomDungeon = false;
        std::vector<Player*> playersTeleported;
        // Teleport Player
        for (GuidUnorderedSet::const_iterator it = playersToTeleport.begin(); it != playersToTeleport.end(); ++it)
        {
            if (Player* player = ObjectAccessor::FindPlayer(*it))
            {
                if (player->GetGroup() != grp) // pussywizard: could not add because group was full
                    continue;
 
                // Add the cooldown spell if queued for a random dungeon
                // xinef: add aura
                if ((randomDungeon || selectedRandomLfgDungeon(player->GetGUID())) && !player->HasAura(LFG_SPELL_DUNGEON_COOLDOWN))
                {
                    randomDungeon = true;
                    // if player is debugging, don't add dungeon cooldown
                    if (!m_Testing)
                    {
                        player->AddAura(LFG_SPELL_DUNGEON_COOLDOWN, player);
                    }
                }
 
                if (player->GetMapId() == uint32(dungeon->map))
                {
                    // check instance id with leader
                    if (!leaderTeleportIncluded)
                    {
                        if (InstancePlayerBind* ilb = sInstanceSaveMgr->PlayerGetBoundInstance(grp->GetLeaderGUID(), dungeon->map, player->GetDungeonDifficulty()))
                        {
                            if (player->GetInstanceId() == ilb->save->GetInstanceId())
                            {
                                // Do not teleport if in the same map and instance as leader
                                continue;
                            }
                        }
                    }
 
                    // Remove bind to that map
                    sInstanceSaveMgr->PlayerUnbindInstance(player->GetGUID(), dungeon->map, player->GetDungeonDifficulty(), true);
                }
                else
                {
                    // RDF removes all binds to that map
                    if (randomDungeon)
                        sInstanceSaveMgr->PlayerUnbindInstance(player->GetGUID(), dungeon->map, player->GetDungeonDifficulty(), true);
                }
 
                playersTeleported.push_back(player);
            }
        }
 
        for (Player* player : playersTeleported)
        {
            TeleportPlayer(player, false, teleportLocation);
        }
 
        if (randomDungeon)
            grp->AddLfgRandomInstanceFlag();
        if (Difficulty(dungeon->difficulty) == DUNGEON_DIFFICULTY_HEROIC)
            grp->AddLfgHeroicFlag();
 
        // Update group info
        grp->SendUpdate();
    }

References _SaveToDB(), Group::AddLfgBuffFlag(), Group::AddLfgHeroicFlag(), Group::AddLfgRandomInstanceFlag(), Group::AddMember(), ASSERT, BATTLEGROUND_QUEUE_NONE, Group::ConvertToLFG(), Group::Create(), lfg::LFGDungeonData::difficulty, DUNGEON_DIFFICULTY_HEROIC, lfg::LfgProposal::dungeonId, lfg::LFGDungeonData::Entry(), ObjectAccessor::FindConnectedPlayer(), ObjectAccessor::FindPlayer(), ObjectGuid::GetCounter(), Group::GetFirstMember(), Player::GetGroup(), GetGroup(), Group::GetGUID(), Object::GetGUID(), Group::GetLeaderGUID(), GetLFGDungeon(), Group::GetMembersCount(), lfg::LfgProposal::group, ObjectGuid::IsEmpty(), Group::IsFull(), Group::IsLeader(), Group::IsLfgWithBuff(), lfg::LfgProposal::isNew, lfg::LfgProposal::leader, lfg::LFG_SPELL_DUNGEON_COOLDOWN, lfg::LFG_STATE_DUNGEON, lfg::LFG_STATE_PROPOSAL, m_Testing, lfg::LFGDungeonData::map, MAXGROUPSIZE, PLAYER_MAX_BATTLEGROUND_QUEUES, lfg::PLAYER_ROLE_HEALER, lfg::PLAYER_ROLE_TANK, lfg::LfgProposal::players, Group::RemoveMember(), sBattlegroundMgr, selectedRandomLfgDungeon(), Group::SendUpdate(), SetDungeon(), Group::SetDungeonDifficulty(), Group::SetLfgRoles(), SetRandomPlayersCount(), SetState(), sGroupMgr, sInstanceSaveMgr, and TeleportPlayer().

Referenced by UpdateProposal().

◆ RBPacketAppendGroup()

void lfg::LFGMgr::RBPacketAppendGroup	(	const RBInternalInfo &	info,
		ByteBuffer &	buffer
	)

    {
        buffer << info.groupGuid;
        uint32 flags = LFG_UPDATE_FLAG_COMMENT | LFG_UPDATE_FLAG_ROLES | LFG_UPDATE_FLAG_BINDED;
        buffer << (uint32)flags;
        if (flags & LFG_UPDATE_FLAG_COMMENT)
            buffer << info.comment;
        if (flags & LFG_UPDATE_FLAG_ROLES)
            for (uint8 j = 0; j < 3; ++j)
                buffer << (uint8)0;
        if (!(flags & LFG_UPDATE_FLAG_BINDED))
            return;
        buffer << info.instanceGuid;
        buffer << (uint32)info.encounterMask;
    }

References lfg::RBInternalInfo::comment, lfg::RBInternalInfo::encounterMask, lfg::RBInternalInfo::groupGuid, lfg::RBInternalInfo::instanceGuid, lfg::LFG_UPDATE_FLAG_BINDED, lfg::LFG_UPDATE_FLAG_COMMENT, and lfg::LFG_UPDATE_FLAG_ROLES.

Referenced by RBPacketBuildFull(), and UpdateRaidBrowser().

◆ RBPacketAppendPlayer()

void lfg::LFGMgr::RBPacketAppendPlayer	(	const RBInternalInfo &	info,
		ByteBuffer &	buffer
	)

    {
        buffer << info.guid;
        uint32 flags = LFG_UPDATE_FLAG_CHARACTERINFO | LFG_UPDATE_FLAG_ROLES | LFG_UPDATE_FLAG_COMMENT | (info.groupGuid ? LFG_UPDATE_FLAG_GROUPGUID : LFG_UPDATE_FLAG_BINDED) | (info.isGroupLeader ? LFG_UPDATE_FLAG_GROUPLEADER : 0) | (!info.groupGuid || info.isGroupLeader ? LFG_UPDATE_FLAG_AREA : 0);
        buffer << (uint32)flags;
 
        if (flags & LFG_UPDATE_FLAG_CHARACTERINFO)
        {
            buffer << (uint8)info._level;
            buffer << (uint8)info._class;
            buffer << (uint8)info._race;
            buffer << (uint8)info._talents0;
            buffer << (uint8)info._talents1;
            buffer << (uint8)info._talents2;
            buffer << (uint32)info._armor;
            buffer << (uint32)info._spellDamage;
            buffer << (uint32)info._spellHeal;
            buffer << (uint32)info._critRatingMelee;
            buffer << (uint32)info._critRatingRanged;
            buffer << (uint32)info._critRatingSpell;
            buffer << (float)info._mp5;
            buffer << (float)info._mp5combat;
            buffer << (uint32)info._attackPower;
            buffer << (uint32)info._agility;
            buffer << (uint32)info._health;
            buffer << (uint32)info._mana;
            buffer << (uint32)info._online; // talentpoints, used as online/offline marker :D
            buffer << (float)info._avgItemLevel; // avgitemlevel
            buffer << (uint32)info._defenseSkill;
            buffer << (uint32)info._dodgeRating;
            buffer << (uint32)info._blockRating;
            buffer << (uint32)info._parryRating;
            buffer << (uint32)info._hasteRating;
            buffer << (uint32)info._expertiseRating;
        }
 
        if (flags & LFG_UPDATE_FLAG_COMMENT)
            buffer << (info.groupGuid ? std::string("") : info.comment);
        if (flags & LFG_UPDATE_FLAG_GROUPLEADER)
            buffer << (uint8)1; // isLFM
        if (flags & LFG_UPDATE_FLAG_GROUPGUID)
            buffer << info.groupGuid;
        if (flags & LFG_UPDATE_FLAG_ROLES)
            buffer << (uint8)(info.groupGuid ? (info.isGroupLeader ? PLAYER_ROLE_LEADER : 0) : info.roles);
        if (flags & LFG_UPDATE_FLAG_AREA)
            buffer << (uint32)info._area;
        if (flags & LFG_UPDATE_FLAG_STATUS)
            buffer << (uint8)0;
        if (!(flags & LFG_UPDATE_FLAG_BINDED))
            return;
        buffer << info.instanceGuid;
        buffer << (uint32)info.encounterMask;
    }

Referenced by RBPacketBuildFull(), and UpdateRaidBrowser().

◆ RBPacketBuildDifference()

void lfg::LFGMgr::RBPacketBuildDifference	(	WorldPacket &	differencePacket,
		uint32	dungeonId,
		uint32	deletedCounter,
		ByteBuffer &	buffer_deleted,
		uint32	groupCounter,
		ByteBuffer &	buffer_groups,
		uint32	playerCounter,
		ByteBuffer &	buffer_players
	)

    {
        differencePacket << (uint32)LFG_TYPE_RAID;
        differencePacket << (uint32)dungeonId;
        differencePacket << (uint8)1;
        differencePacket << (uint32)deletedCounter;
        differencePacket.append(buffer_deleted);
        differencePacket << (uint32)groupCounter;
        differencePacket << (uint32)0;
        differencePacket.append(buffer_groups);
        differencePacket << (uint32)playerCounter;
        differencePacket << (uint32)0;
        differencePacket.append(buffer_players);
    }

References ByteBuffer::append(), and lfg::LFG_TYPE_RAID.

Referenced by UpdateRaidBrowser().

◆ RBPacketBuildFull()

void lfg::LFGMgr::RBPacketBuildFull	(	WorldPacket &	fullPacket,
		uint32	dungeonId,
		RBInternalInfoMap &	infoMap
	)

    {
        fullPacket << (uint32)LFG_TYPE_RAID;
        fullPacket << (uint32)dungeonId;
        fullPacket << (uint8)0;
        uint32 groupCounter = 0, playerCounter = 0;
        ByteBuffer buffer_groups, buffer_players;
        for (RBInternalInfoMap::const_iterator itr = infoMap.begin(); itr != infoMap.end(); ++itr)
        {
            if (itr->second.isGroupLeader)
            {
                ++groupCounter;
                RBPacketAppendGroup(itr->second, buffer_groups);
            }
            ++playerCounter;
            RBPacketAppendPlayer(itr->second, buffer_players);
        }
        fullPacket << (uint32)groupCounter;
        fullPacket << (uint32)0;
        fullPacket.append(buffer_groups);
        fullPacket << (uint32)playerCounter;
        fullPacket << (uint32)0;
        fullPacket.append(buffer_players);
    }

References ByteBuffer::append(), lfg::LFG_TYPE_RAID, RBPacketAppendGroup(), and RBPacketAppendPlayer().

Referenced by UpdateRaidBrowser().

◆ RemoveGroupData()

void lfg::LFGMgr::RemoveGroupData ( ObjectGuid guid )

Removes saved group data.

    {
        LOG_DEBUG("lfg", "LFGMgr::RemoveGroupData: [{}]", guid.ToString());
        LfgGroupDataContainer::iterator it = GroupsStore.find(guid);
        if (it == GroupsStore.end())
            return;
 
        LfgState state = GetState(guid);
        // If group is being formed after proposal success do nothing more
        LfgGuidSet const& players = it->second.GetPlayers();
        for (auto iterator = players.begin(); iterator != players.end(); ++iterator)
        {
            ObjectGuid objectGuid = (*iterator);
            SetGroup(*iterator, ObjectGuid::Empty);
            if (state != LFG_STATE_PROPOSAL)
            {
                SetState(*iterator, LFG_STATE_NONE);
                SendLfgUpdateParty(objectGuid, LfgUpdateData(LFG_UPDATETYPE_REMOVED_FROM_QUEUE));
            }
        }
        GroupsStore.erase(it);
    }

References ObjectGuid::Empty, GetState(), GroupsStore, lfg::LFG_STATE_NONE, lfg::LFG_STATE_PROPOSAL, lfg::LFG_UPDATETYPE_REMOVED_FROM_QUEUE, LOG_DEBUG, SendLfgUpdateParty(), SetGroup(), SetState(), and ObjectGuid::ToString().

◆ RemovePlayerFromGroup()

uint8 lfg::LFGMgr::RemovePlayerFromGroup	(	ObjectGuid	gguid,
		ObjectGuid	guid
	)

Removes a player from a group.

    {
        return GroupsStore[gguid].RemovePlayer(guid);
    }

References GroupsStore.

◆ RemoveProposal()

void lfg::LFGMgr::RemoveProposal	(	LfgProposalContainer::iterator	itProposal,
		LfgUpdateType	type
	)

private

Remove a proposal from the pool, remove the group that didn't accept (if needed) and readd the other members to the queue

Parameters

[in]	itProposal	Iterator to the proposal to remove
[in]	type	Type of removal (LFG_UPDATETYPE_PROPOSAL_FAILED, LFG_UPDATETYPE_PROPOSAL_DECLINED)

    {
        LfgProposal& proposal = itProposal->second;
        proposal.state = LFG_PROPOSAL_FAILED;
 
        LOG_DEBUG("lfg", "LFGMgr::RemoveProposal: Proposal {}, state FAILED, UpdateType {}", itProposal->first, type);
        // Mark all people that didn't answered as no accept
        if (type == LFG_UPDATETYPE_PROPOSAL_FAILED)
            for (LfgProposalPlayerContainer::iterator it = proposal.players.begin(); it != proposal.players.end(); ++it)
                if (it->second.accept == LFG_ANSWER_PENDING)
                    it->second.accept = LFG_ANSWER_DENY;
 
        // pussywizard: add cooldown for not accepting (after 40 secs) or declining
        for (LfgProposalPlayerContainer::iterator it = proposal.players.begin(); it != proposal.players.end(); ++it)
            if (it->second.accept == LFG_ANSWER_DENY)
                if (Player* plr = ObjectAccessor::FindPlayer(it->first))
                    if (Aura* aura = plr->AddAura(LFG_SPELL_DUNGEON_COOLDOWN, plr))
                        aura->SetDuration(150 * IN_MILLISECONDS);
 
        // Mark players/groups to be removed
        LfgGuidSet toRemove;
        for (LfgProposalPlayerContainer::iterator it = proposal.players.begin(); it != proposal.players.end(); ++it)
        {
            if (it->second.accept == LFG_ANSWER_AGREE)
                continue;
 
            ObjectGuid guid = it->second.group ? it->second.group : it->first;
            // Player didn't accept or still pending when no secs left
            if (it->second.accept == LFG_ANSWER_DENY || type == LFG_UPDATETYPE_PROPOSAL_FAILED)
            {
                it->second.accept = LFG_ANSWER_DENY;
                toRemove.insert(guid);
            }
        }
 
        // Notify players
        for (LfgProposalPlayerContainer::const_iterator it = proposal.players.begin(); it != proposal.players.end(); ++it)
        {
            ObjectGuid guid = it->first;
            ObjectGuid gguid = it->second.group ? it->second.group : guid;
 
            SendLfgUpdateProposal(guid, proposal);
 
            if (toRemove.find(gguid) != toRemove.end())         // Didn't accept or in same group that someone that didn't accept
            {
                LfgUpdateData updateData;
                if (it->second.accept == LFG_ANSWER_DENY)
                {
                    updateData.updateType = type;
                    LOG_DEBUG("lfg", "LFGMgr::RemoveProposal: [{}] didn't accept. Removing from queue and compatible cache", guid.ToString());
                }
                else
                {
                    updateData.updateType = LFG_UPDATETYPE_REMOVED_FROM_QUEUE;
                    LOG_DEBUG("lfg", "LFGMgr::RemoveProposal: [{}] in same group that someone that didn't accept. Removing from queue and compatible cache", guid.ToString());
                }
 
                RestoreState(guid, "Proposal Fail (didn't accepted or in group with someone that didn't accept");
                if (gguid != guid)
                {
                    RestoreState(it->second.group, "Proposal Fail (someone in group didn't accepted)");
                    SendLfgUpdateParty(guid, updateData);
                }
                else
                    SendLfgUpdatePlayer(guid, updateData);
            }
            else
            {
                LOG_DEBUG("lfg", "LFGMgr::RemoveProposal: Readding [{}] to queue.", guid.ToString());
                SetState(guid, LFG_STATE_QUEUED);
                if (gguid != guid)
                {
                    SetState(gguid, LFG_STATE_QUEUED);
                    SendLfgUpdateParty(guid, LfgUpdateData(LFG_UPDATETYPE_ADDED_TO_QUEUE, GetSelectedDungeons(guid), GetComment(guid)));
                }
                else
                    SendLfgUpdatePlayer(guid, LfgUpdateData(LFG_UPDATETYPE_ADDED_TO_QUEUE, GetSelectedDungeons(guid), GetComment(guid)));
            }
        }
 
        LFGQueue& queue = GetQueue(proposal.players.begin()->first);
        // Remove players/groups from queue
        for (LfgGuidSet::const_iterator it = toRemove.begin(); it != toRemove.end(); ++it)
        {
            ObjectGuid guid = *it;
            queue.RemoveFromQueue(guid);
            proposal.queues.remove(guid);
        }
 
        // Readd to queue
        for (uint8 i = 0; i < 5 && proposal.queues.guids[i]; ++i)
        {
            // xinef: this will work as data is not deleted, only references to this data are cleared
            // xinef: when new proposal is created
            // xinef: successful proposal is also taken into account is similar manner
            queue.AddToQueue(proposal.queues.guids[i], true);
        }
 
        ProposalsStore.erase(itProposal);
    }

References lfg::LFGQueue::AddToQueue(), ObjectAccessor::FindPlayer(), GetComment(), GetQueue(), GetSelectedDungeons(), lfg::Lfg5Guids::guids, IN_MILLISECONDS, lfg::LFG_ANSWER_AGREE, lfg::LFG_ANSWER_DENY, lfg::LFG_ANSWER_PENDING, lfg::LFG_PROPOSAL_FAILED, lfg::LFG_SPELL_DUNGEON_COOLDOWN, lfg::LFG_STATE_QUEUED, lfg::LFG_UPDATETYPE_ADDED_TO_QUEUE, lfg::LFG_UPDATETYPE_PROPOSAL_FAILED, lfg::LFG_UPDATETYPE_REMOVED_FROM_QUEUE, LOG_DEBUG, lfg::LfgProposal::players, ProposalsStore, lfg::LfgProposal::queues, lfg::Lfg5Guids::remove(), lfg::LFGQueue::RemoveFromQueue(), RestoreState(), SendLfgUpdateParty(), SendLfgUpdatePlayer(), SendLfgUpdateProposal(), SetState(), lfg::LfgProposal::state, ObjectGuid::ToString(), and lfg::LfgUpdateData::updateType.

Referenced by LeaveLfg(), Update(), and UpdateProposal().

◆ RestoreState()

void lfg::LFGMgr::RestoreState	(	ObjectGuid	guid,
		char const *	debugMsg
	)

private

    {
        if (guid.IsGroup())
        {
            LfgGroupData& data = GroupsStore[guid];
            /*if (sLog->ShouldLog(LOG_FILTER_LFG, LOG_LEVEL_DEBUG))
            {
                std::string const& ps = GetStateString(data.GetState());
                std::string const& os = GetStateString(data.GetOldState());
                LOG_TRACE("lfg", "LFGMgr::RestoreState: Group: [{}] ({}) State: {}, oldState: {}",
                    guid.ToString(), debugMsg, ps, os);
            }*/
 
            data.RestoreState();
        }
        else
        {
            LfgPlayerData& data = PlayersStore[guid];
            /*if (sLog->ShouldLog(LOG_FILTER_LFG, LOG_LEVEL_DEBUG))
            {
                std::string const& ps = GetStateString(data.GetState());
                std::string const& os = GetStateString(data.GetOldState());
                LOG_TRACE("lfg", "LFGMgr::RestoreState: Player: [{}] ({}) State: {}, oldState: {}",
                    guid.ToString(), debugMsg, ps, os);
            }*/
            data.RestoreState();
        }
    }

References GroupsStore, ObjectGuid::IsGroup(), PlayersStore, lfg::LfgGroupData::RestoreState(), and lfg::LfgPlayerData::RestoreState().

Referenced by RemoveProposal(), Update(), and UpdateRoleCheck().

◆ selectedRandomLfgDungeon()

bool lfg::LFGMgr::selectedRandomLfgDungeon ( ObjectGuid guid )

Check if given guid applied for random dungeon.

    {
        if (GetState(guid) != LFG_STATE_NONE)
        {
            LfgDungeonSet const& dungeons = GetSelectedDungeons(guid);
            if (!dungeons.empty())
            {
                LFGDungeonData const* dungeon = GetLFGDungeon(*dungeons.begin());
                if (dungeon && (dungeon->type == LFG_TYPE_RANDOM || dungeon->seasonal))
                    return true;
            }
        }
 
        return false;
    }

References GetLFGDungeon(), GetSelectedDungeons(), GetState(), lfg::LFG_STATE_NONE, lfg::LFG_TYPE_RANDOM, lfg::LFGDungeonData::seasonal, and lfg::LFGDungeonData::type.

Referenced by MakeNewGroup().

◆ SendLfgBootProposalUpdate()

void lfg::LFGMgr::SendLfgBootProposalUpdate	(	ObjectGuid	guid,
		LfgPlayerBoot const &	boot
	)

private

    {
        if (Player* player = ObjectAccessor::FindConnectedPlayer(guid))
            player->GetSession()->SendLfgBootProposalUpdate(boot);
    }

References ObjectAccessor::FindConnectedPlayer().

Referenced by InitBoot(), Update(), and UpdateBoot().

◆ SendLfgJoinResult()

void lfg::LFGMgr::SendLfgJoinResult	(	ObjectGuid	guid,
		LfgJoinResultData const &	data
	)

private

    {
        if (Player* player = ObjectAccessor::FindConnectedPlayer(guid))
            player->GetSession()->SendLfgJoinResult(data);
    }

References ObjectAccessor::FindConnectedPlayer().

Referenced by Update(), and UpdateRoleCheck().

◆ SendLfgQueueStatus()

void lfg::LFGMgr::SendLfgQueueStatus	(	ObjectGuid	guid,
		LfgQueueStatusData const &	data
	)

static

Sends queue status to player.

    {
        if (Player* player = ObjectAccessor::FindConnectedPlayer(guid))
            player->GetSession()->SendLfgQueueStatus(data);
    }

References ObjectAccessor::FindConnectedPlayer().

Referenced by lfg::LFGQueue::UpdateQueueTimers().

◆ SendLfgRoleCheckUpdate()

void lfg::LFGMgr::SendLfgRoleCheckUpdate	(	ObjectGuid	guid,
		LfgRoleCheck const &	roleCheck
	)

private

    {
        if (Player* player = ObjectAccessor::FindConnectedPlayer(guid))
            player->GetSession()->SendLfgRoleCheckUpdate(roleCheck);
    }

References ObjectAccessor::FindConnectedPlayer().

Referenced by Update(), and UpdateRoleCheck().

◆ SendLfgRoleChosen()

void lfg::LFGMgr::SendLfgRoleChosen	(	ObjectGuid	guid,
		ObjectGuid	pguid,
		uint8	roles
	)

private

    {
        if (Player* player = ObjectAccessor::FindConnectedPlayer(guid))
            player->GetSession()->SendLfgRoleChosen(pguid, roles);
    }

References ObjectAccessor::FindConnectedPlayer(), Player::GetSession(), and WorldSession::SendLfgRoleChosen().

Referenced by UpdateRoleCheck().

◆ SendLfgUpdateParty()

void lfg::LFGMgr::SendLfgUpdateParty	(	ObjectGuid	guid,
		LfgUpdateData const &	data
	)

private

    {
        if (Player* player = ObjectAccessor::FindConnectedPlayer(guid))
            player->GetSession()->SendLfgUpdateParty(data);
    }

References ObjectAccessor::FindConnectedPlayer().

Referenced by LeaveAllLfgQueues(), LeaveLfg(), RemoveGroupData(), RemoveProposal(), Update(), UpdateProposal(), and UpdateRoleCheck().

◆ SendLfgUpdatePlayer()

void lfg::LFGMgr::SendLfgUpdatePlayer	(	ObjectGuid	guid,
		LfgUpdateData const &	data
	)

private

    {
        if (Player* player = ObjectAccessor::FindConnectedPlayer(guid))
            player->GetSession()->SendLfgUpdatePlayer(data);
    }

References ObjectAccessor::FindConnectedPlayer().

Referenced by LeaveAllLfgQueues(), LeaveLfg(), RemoveProposal(), Update(), and UpdateProposal().

◆ SendLfgUpdateProposal()

void lfg::LFGMgr::SendLfgUpdateProposal	(	ObjectGuid	guid,
		LfgProposal const &	proposal
	)

private

    {
        if (Player* player = ObjectAccessor::FindConnectedPlayer(guid))
            player->GetSession()->SendLfgUpdateProposal(proposal);
    }

References ObjectAccessor::FindConnectedPlayer().

Referenced by RemoveProposal(), Update(), and UpdateProposal().

◆ SendRaidBrowserCachedList()

void lfg::LFGMgr::SendRaidBrowserCachedList	(	Player *	player,
		uint32	dungeonId
	)

    {
        RBCacheMap::iterator itr = RBCacheStore[player->GetTeamId()].find(dungeonId);
        if (itr != RBCacheStore[player->GetTeamId()].end())
        {
            player->SendDirectMessage(&(itr->second));
            return;
        }
        // send empty packet if cache not found
        WorldPacket data(SMSG_UPDATE_LFG_LIST, 1000);
        data << (uint32)LFG_TYPE_RAID;
        data << (uint32)dungeonId;
        data << (uint8)0;
        data << (uint32)0;
        data << (uint32)0;
        data << (uint32)0;
        data << (uint32)0;
        player->SendDirectMessage(&data);
    }

References Player::GetTeamId(), lfg::LFG_TYPE_RAID, RBCacheStore, Player::SendDirectMessage(), and SMSG_UPDATE_LFG_LIST.

◆ SendRaidBrowserJoinedPacket()

void lfg::LFGMgr::SendRaidBrowserJoinedPacket	(	Player *	p,
		LfgDungeonSet &	dungeons,
		std::string	comment
	)

    {
        if (dungeons.empty())
        {
            RBEntryInfoMap::iterator iter;
            uint8 team = p->GetTeamId();
            bool setComment = true;
            for (RBStoreMap::iterator itr = RaidBrowserStore[team].begin(); itr != RaidBrowserStore[team].end(); ++itr)
                if ((iter = itr->second.find(p->GetGUID())) != itr->second.end())
                {
                    dungeons.insert(itr->first);
                    if (setComment)
                    {
                        comment = iter->second.comment;
                        setComment = false;
                    }
                }
        }
        LfgJoinResultData joinData;
        p->GetSession()->SendLfgJoinResult(joinData);
        LfgUpdateData updateData = LfgUpdateData(LFG_UPDATETYPE_JOIN_RAIDBROWSER, dungeons, comment);
        if (p->GetGroup())
            p->GetSession()->SendLfgUpdateParty(updateData);
        else
            p->GetSession()->SendLfgUpdatePlayer(updateData);
    }

References Player::GetGroup(), Object::GetGUID(), Player::GetSession(), Player::GetTeamId(), lfg::LFG_UPDATETYPE_JOIN_RAIDBROWSER, RaidBrowserStore, WorldSession::SendLfgJoinResult(), WorldSession::SendLfgUpdateParty(), and WorldSession::SendLfgUpdatePlayer().

Referenced by JoinLfg().

◆ SetCanOverrideRBState()

void lfg::LFGMgr::SetCanOverrideRBState	(	ObjectGuid	guid,
		bool	val
	)

private

    {
        PlayersStore[guid].SetCanOverrideRBState(val);
    }

References PlayersStore.

Referenced by LeaveLfg().

◆ SetComment()

void lfg::LFGMgr::SetComment	(	ObjectGuid	guid,
		std::string const &	comment
	)

Sets player lfr comment.

    {
        LOG_DEBUG("lfg", "LFGMgr::SetComment: [{}] comment: {}", guid.ToString(), comment);
        PlayersStore[guid].SetComment(comment);
    }

References LOG_DEBUG, PlayersStore, and ObjectGuid::ToString().

Referenced by JoinLfg().

◆ SetDungeon()

void lfg::LFGMgr::SetDungeon	(	ObjectGuid	guid,
		uint32	dungeon
	)

    {
        LOG_DEBUG("lfg", "LFGMgr::SetDungeon: [{}] dungeon {}", guid.ToString(), dungeon);
        GroupsStore[guid].SetDungeon(dungeon);
    }

References GroupsStore, LOG_DEBUG, and ObjectGuid::ToString().

Referenced by _LoadFromDB(), LeaveLfg(), and MakeNewGroup().

◆ SetGroup()

void lfg::LFGMgr::SetGroup	(	ObjectGuid	guid,
		ObjectGuid	group
	)

Sets player group.

    {
        PlayersStore[guid].SetGroup(group);
    }

References PlayersStore.

Referenced by RemoveGroupData(), and SetupGroupMember().

◆ SetLeader()

void lfg::LFGMgr::SetLeader	(	ObjectGuid	gguid,
		ObjectGuid	leader
	)

Sets the leader of the group.

    {
        GroupsStore[gguid].SetLeader(leader);
    }

References GroupsStore.

Referenced by _LoadFromDB().

◆ SetLockedDungeons()

void lfg::LFGMgr::SetLockedDungeons	(	ObjectGuid	guid,
		LfgLockMap const &	lock
	)

private

    {
        LOG_DEBUG("lfg", "LFGMgr::SetLockedDungeons: [{}]", guid.ToString());
        PlayersStore[guid].SetLockedDungeons(lock);
    }

References LOG_DEBUG, PlayersStore, and ObjectGuid::ToString().

Referenced by InitializeLockedDungeons().

◆ SetOptions()

void lfg::LFGMgr::SetOptions ( uint32 options )

Sets new lfg options.

    {
        m_options = options;
    }

References m_options.

◆ SetRandomPlayersCount()

void lfg::LFGMgr::SetRandomPlayersCount	(	ObjectGuid	guid,
		uint8	count
	)

Xinef: Set Random Players Count.

    {
        PlayersStore[guid].SetRandomPlayersCount(count);
    }

References PlayersStore.

Referenced by MakeNewGroup().

◆ SetRoles()

void lfg::LFGMgr::SetRoles	(	ObjectGuid	guid,
		uint8	roles
	)

Sets player lfg roles.

    {
        LOG_DEBUG("lfg", "LFGMgr::SetRoles: [{}] roles: {}", guid.ToString(), roles);
        PlayersStore[guid].SetRoles(roles);
    }

References LOG_DEBUG, PlayersStore, and ObjectGuid::ToString().

Referenced by JoinLfg(), and UpdateRoleCheck().

◆ SetSelectedDungeons()

void lfg::LFGMgr::SetSelectedDungeons	(	ObjectGuid	guid,
		LfgDungeonSet const &	dungeons
	)

private

    {
        LOG_DEBUG("lfg", "LFGMgr::SetLockedDungeons: [{}]", guid.ToString());
        PlayersStore[guid].SetSelectedDungeons(dungeons);
    }

References LOG_DEBUG, PlayersStore, and ObjectGuid::ToString().

Referenced by JoinLfg(), and SetupGroupMember().

◆ SetState()

void lfg::LFGMgr::SetState	(	ObjectGuid	guid,
		LfgState	state
	)

private

    {
        if (guid.IsGroup())
        {
            LfgGroupData& data = GroupsStore[guid];
            std::string ns = GetStateString(state);
            std::string ps = GetStateString(data.GetState());
            std::string os = GetStateString(data.GetOldState());
            LOG_DEBUG("lfg", "LFGMgr::SetState: Group: [{}] newState: {}, previous: {}, oldState: {}", guid.ToString(), ns, ps, os);
            data.SetState(state);
        }
        else
        {
            LfgPlayerData& data = PlayersStore[guid];
            std::string ns = GetStateString(state);
            std::string ps = GetStateString(data.GetState());
            std::string os = GetStateString(data.GetOldState());
            LOG_DEBUG("lfg", "LFGMgr::SetState: Player: [{}] newState: {}, previous: {}, oldState: {}", guid.ToString(), ns, ps, os);
            data.SetState(state);
        }
    }

References lfg::LfgGroupData::GetOldState(), lfg::LfgPlayerData::GetOldState(), lfg::LfgGroupData::GetState(), lfg::LfgPlayerData::GetState(), lfg::GetStateString(), GroupsStore, ObjectGuid::IsGroup(), LOG_DEBUG, PlayersStore, lfg::LfgGroupData::SetState(), lfg::LfgPlayerData::SetState(), and ObjectGuid::ToString().

Referenced by _LoadFromDB(), FinishDungeon(), InitBoot(), JoinLfg(), LeaveAllLfgQueues(), LeaveLfg(), MakeNewGroup(), RemoveGroupData(), RemoveProposal(), SetupGroupMember(), Update(), UpdateBoot(), UpdateProposal(), and UpdateRoleCheck().

◆ SetTeam()

void lfg::LFGMgr::SetTeam	(	ObjectGuid	guid,
		TeamId	teamId
	)

Sets player team.

    {
        if (sWorld->getBoolConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_GROUP))
            teamId = TEAM_ALLIANCE; // @Not Sure About That TeamId is supposed to be uint8 Team = 0(@TrinityCore)
 
        PlayersStore[guid].SetTeam(teamId);
    }

References CONFIG_ALLOW_TWO_SIDE_INTERACTION_GROUP, PlayersStore, sWorld, and TEAM_ALLIANCE.

◆ SetupGroupMember()

void lfg::LFGMgr::SetupGroupMember	(	ObjectGuid	guid,
		ObjectGuid	gguid
	)

Initializes player data after loading group data from DB.

    {
        LfgDungeonSet dungeons;
        dungeons.insert(GetDungeon(gguid));
        SetSelectedDungeons(guid, dungeons);
        SetState(guid, GetState(gguid));
        SetGroup(guid, gguid);
        AddPlayerToGroup(gguid, guid);
    }

References AddPlayerToGroup(), GetDungeon(), GetState(), SetGroup(), SetSelectedDungeons(), and SetState().

◆ TeleportPlayer()

void lfg::LFGMgr::TeleportPlayer	(	Player *	player,
		bool	out,
		WorldLocation const *	teleportLocation = `nullptr`
	)

Teleport a player to/from selected dungeon.

Teleports the player in or out the dungeon

Parameters

[in]	player	Player to teleport
[in]	out	Teleport out (true) or in (false)
[in]	fromOpcode	Function called from opcode handlers? (Default false)

    {
        LFGDungeonData const* dungeon = nullptr;
        Group* group = player->GetGroup();
 
        if (group && group->isLFGGroup())
            dungeon = GetLFGDungeon(GetDungeon(group->GetGUID()));
 
        if (!dungeon)
        {
            player->GetSession()->SendLfgTeleportError(uint8(LFG_TELEPORTERROR_INVALID_LOCATION));
            return;
        }
 
        LfgTeleportError error = LFG_TELEPORTERROR_OK;
 
        if (!player->IsAlive())
        {
            error = LFG_TELEPORTERROR_PLAYER_DEAD;
        }
        else if (player->IsFalling() || player->HasUnitState(UNIT_STATE_JUMPING))
        {
            error = LFG_TELEPORTERROR_FALLING;
        }
        else if (player->IsMirrorTimerActive(FATIGUE_TIMER))
        {
            error = LFG_TELEPORTERROR_FATIGUE;
        }
        else if (player->GetVehicle())
        {
            error = LFG_TELEPORTERROR_IN_VEHICLE;
        }
        else if (player->GetCharmGUID() || player->IsInCombat())
        {
            error = LFG_TELEPORTERROR_COMBAT;
        }
        else if (out && error == LFG_TELEPORTERROR_OK)
        {
            if (player->GetMapId() == uint32(dungeon->map))
                player->TeleportToEntryPoint();
 
            return;
        }
        else
        {
            uint32 mapid = dungeon->map;
            float x = dungeon->x;
            float y = dungeon->y;
            float z = dungeon->z;
            float orientation = dungeon->o;
 
            if (teleportLocation)
            {
                teleportLocation->GetWorldLocation(mapid, x, y, z, orientation);
            }
 
            if (!player->GetMap()->IsDungeon() || player->GetEntryPoint().GetMapId() == MAPID_INVALID)
            {
                player->SetEntryPoint();
            }
 
            if (!player->TeleportTo(mapid, x, y, z, orientation, 0, nullptr, mapid == player->GetMapId()))
            {
                error = LFG_TELEPORTERROR_INVALID_LOCATION;
            }
        }
 
        if (error != LFG_TELEPORTERROR_OK)
        {
            player->GetSession()->SendLfgTeleportError(uint8(error));
 
            LOG_DEBUG("lfg", "Player [{}] could NOT be teleported in to map [{}] (x: {}, y: {}, z: {}) Error: {}",
            player->GetName(), dungeon->map, dungeon->x, dungeon->y, dungeon->z, error);
        }
        else
        {
            LOG_DEBUG("lfg", "Player [{}] is being teleported in to map [{}] (x: {}, y: {}, z: {})",
            player->GetName(), dungeon->map, dungeon->x, dungeon->y, dungeon->z);
        }
 
    }

References FATIGUE_TIMER, Unit::GetCharmGUID(), GetDungeon(), Player::GetEntryPoint(), Player::GetGroup(), Group::GetGUID(), GetLFGDungeon(), WorldObject::GetMap(), WorldLocation::GetMapId(), WorldObject::GetName(), Player::GetSession(), Unit::GetVehicle(), WorldLocation::GetWorldLocation(), Unit::HasUnitState(), Unit::IsAlive(), Map::IsDungeon(), Player::IsFalling(), Unit::IsInCombat(), Group::isLFGGroup(), Player::IsMirrorTimerActive(), lfg::LFG_TELEPORTERROR_COMBAT, lfg::LFG_TELEPORTERROR_FALLING, lfg::LFG_TELEPORTERROR_FATIGUE, lfg::LFG_TELEPORTERROR_IN_VEHICLE, lfg::LFG_TELEPORTERROR_INVALID_LOCATION, lfg::LFG_TELEPORTERROR_OK, lfg::LFG_TELEPORTERROR_PLAYER_DEAD, LOG_DEBUG, lfg::LFGDungeonData::map, MAPID_INVALID, lfg::LFGDungeonData::o, WorldSession::SendLfgTeleportError(), Player::SetEntryPoint(), Player::TeleportTo(), Player::TeleportToEntryPoint(), UNIT_STATE_JUMPING, lfg::LFGDungeonData::x, lfg::LFGDungeonData::y, and lfg::LFGDungeonData::z.

Referenced by MakeNewGroup().

◆ ToggleTesting()

void lfg::LFGMgr::ToggleTesting ( )

    {
        if (sWorld->getBoolConfig(CONFIG_DEBUG_LFG))
        {
            m_Testing = true;
            ChatHandler(nullptr).SendWorldText(LANG_DEBUG_LFG_CONF);
        }
        else
        {
            m_Testing = !m_Testing;
            ChatHandler(nullptr).SendWorldText(m_Testing ? LANG_DEBUG_LFG_ON : LANG_DEBUG_LFG_OFF);
        }
    }

References CONFIG_DEBUG_LFG, LANG_DEBUG_LFG_CONF, LANG_DEBUG_LFG_OFF, LANG_DEBUG_LFG_ON, m_Testing, ChatHandler::SendWorldText(), and sWorld.

◆ Update()

void lfg::LFGMgr::Update	(	uint32	diff,
		uint8	task
	)

    {
        if (!isOptionEnabled(LFG_OPTION_ENABLE_DUNGEON_FINDER | LFG_OPTION_ENABLE_RAID_BROWSER | LFG_OPTION_ENABLE_SEASONAL_BOSSES))
            return;
 
        if (task == 0)
        {
            time_t currTime = GameTime::GetGameTime().count();
 
            // Remove obsolete role checks
            for (LfgRoleCheckContainer::iterator it = RoleChecksStore.begin(); it != RoleChecksStore.end();)
            {
                LfgRoleCheckContainer::iterator itRoleCheck = it++;
                LfgRoleCheck& roleCheck = itRoleCheck->second;
                if (currTime < roleCheck.cancelTime)
                    continue;
                roleCheck.state = LFG_ROLECHECK_MISSING_ROLE;
 
                for (LfgRolesMap::const_iterator itRoles = roleCheck.roles.begin(); itRoles != roleCheck.roles.end(); ++itRoles)
                {
                    ObjectGuid guid = itRoles->first;
                    RestoreState(guid, "Remove Obsolete RoleCheck");
                    SendLfgRoleCheckUpdate(guid, roleCheck);
                    if (guid == roleCheck.leader)
                        SendLfgJoinResult(guid, LfgJoinResultData(LFG_JOIN_FAILED, LFG_ROLECHECK_MISSING_ROLE));
                }
 
                RestoreState(itRoleCheck->first, "Remove Obsolete RoleCheck");
                RoleChecksStore.erase(itRoleCheck);
            }
 
            // Remove obsolete proposals
            for (LfgProposalContainer::iterator it = ProposalsStore.begin(); it != ProposalsStore.end();)
            {
                LfgProposalContainer::iterator itRemove = it++;
                if (itRemove->second.cancelTime < currTime)
                    RemoveProposal(itRemove, LFG_UPDATETYPE_PROPOSAL_FAILED);
            }
 
            // Remove obsolete kicks
            for (LfgPlayerBootContainer::iterator it = BootsStore.begin(); it != BootsStore.end();)
            {
                LfgPlayerBootContainer::iterator itBoot = it++;
                LfgPlayerBoot& boot = itBoot->second;
                if (boot.cancelTime < currTime)
                {
                    boot.inProgress = false;
                    for (LfgAnswerContainer::const_iterator itVotes = boot.votes.begin(); itVotes != boot.votes.end(); ++itVotes)
                    {
                        ObjectGuid pguid = itVotes->first;
                        if (pguid != boot.victim)
                            SendLfgBootProposalUpdate(pguid, boot);
                        SetState(pguid, LFG_STATE_DUNGEON);
                    }
                    SetState(itBoot->first, LFG_STATE_DUNGEON);
                    BootsStore.erase(itBoot);
                }
            }
 
            // Cleanup expired dungeon cooldowns
            CleanupDungeonCooldowns();
        }
        else if (task == 1)
        {
            this->lastProposalId = m_lfgProposalId; // pussywizard: task 2 is done independantly, store previous value in LFGMgr for future use
            uint8 newGroupsProcessed = 0;
            // Check if a proposal can be formed with the new groups being added
            for (LfgQueueContainer::iterator it = QueuesStore.begin(); it != QueuesStore.end(); ++it)
            {
                newGroupsProcessed += it->second.FindGroups();
                if (newGroupsProcessed)
                    break;
            }
 
            // Update all players status queue info
            if (!newGroupsProcessed) // don't do this on updates that precessed groups (performance)
                for (LfgQueueContainer::iterator it = QueuesStore.begin(); it != QueuesStore.end(); ++it)
                    it->second.UpdateQueueTimers(tdiff);
        }
        else if (task == 2)
        {
            if (lastProposalId != m_lfgProposalId)
            {
                // pussywizard: only one proposal can be created in World::Update (during maps update), and it has id == m_lfgProposalId, so try to find only that one, dunno why for loop here xD
                for (LfgProposalContainer::const_iterator itProposal = ProposalsStore.find(m_lfgProposalId); itProposal != ProposalsStore.end(); ++itProposal)
                {
                    uint32 proposalId = itProposal->first;
                    LfgProposal& proposal = ProposalsStore[proposalId];
 
                    ObjectGuid guid;
                    for (LfgProposalPlayerContainer::const_iterator itPlayers = proposal.players.begin(); itPlayers != proposal.players.end(); ++itPlayers)
                    {
                        guid = itPlayers->first;
                        SetState(guid, LFG_STATE_PROPOSAL);
                        if (ObjectGuid gguid = GetGroup(guid))
                        {
                            SetState(gguid, LFG_STATE_PROPOSAL);
                            SendLfgUpdateParty(guid, LfgUpdateData(LFG_UPDATETYPE_PROPOSAL_BEGIN, GetSelectedDungeons(guid), GetComment(guid)));
                        }
                        else
                            SendLfgUpdatePlayer(guid, LfgUpdateData(LFG_UPDATETYPE_PROPOSAL_BEGIN, GetSelectedDungeons(guid), GetComment(guid)));
                        SendLfgUpdateProposal(guid, proposal);
                    }
 
                    if (proposal.state == LFG_PROPOSAL_SUCCESS) // pussywizard: no idea what's the purpose of this xD
                        UpdateProposal(proposalId, guid, true);
                }
            }
 
            UpdateRaidBrowser(tdiff);
        }
    }

References BootsStore, lfg::LfgRoleCheck::cancelTime, lfg::LfgPlayerBoot::cancelTime, CleanupDungeonCooldowns(), GetComment(), GameTime::GetGameTime(), GetGroup(), GetSelectedDungeons(), lfg::LfgPlayerBoot::inProgress, isOptionEnabled(), lastProposalId, lfg::LfgRoleCheck::leader, lfg::LFG_JOIN_FAILED, lfg::LFG_OPTION_ENABLE_DUNGEON_FINDER, lfg::LFG_OPTION_ENABLE_RAID_BROWSER, lfg::LFG_OPTION_ENABLE_SEASONAL_BOSSES, lfg::LFG_PROPOSAL_SUCCESS, lfg::LFG_ROLECHECK_MISSING_ROLE, lfg::LFG_STATE_DUNGEON, lfg::LFG_STATE_PROPOSAL, lfg::LFG_UPDATETYPE_PROPOSAL_BEGIN, lfg::LFG_UPDATETYPE_PROPOSAL_FAILED, m_lfgProposalId, lfg::LfgProposal::players, ProposalsStore, QueuesStore, RemoveProposal(), RestoreState(), RoleChecksStore, lfg::LfgRoleCheck::roles, SendLfgBootProposalUpdate(), SendLfgJoinResult(), SendLfgRoleCheckUpdate(), SendLfgUpdateParty(), SendLfgUpdatePlayer(), SendLfgUpdateProposal(), SetState(), lfg::LfgProposal::state, lfg::LfgRoleCheck::state, UpdateProposal(), UpdateRaidBrowser(), lfg::LfgPlayerBoot::victim, and lfg::LfgPlayerBoot::votes.

◆ UpdateBoot()

void lfg::LFGMgr::UpdateBoot	(	ObjectGuid	guid,
		bool	accept
	)

Updates player boot proposal with new player answer.

Update Boot info with player answer

Parameters

[in]	guid	Player who has answered
[in]	player	answer

    {
        ObjectGuid gguid = GetGroup(guid);
        if (!gguid)
            return;
 
        LfgPlayerBootContainer::iterator itBoot = BootsStore.find(gguid);
        if (itBoot == BootsStore.end())
            return;
 
        LfgPlayerBoot& boot = itBoot->second;
 
        if (boot.votes[guid] != LFG_ANSWER_PENDING)    // Cheat check: Player can't vote twice
            return;
 
        boot.votes[guid] = LfgAnswer(accept);
 
        uint8 votesNum = 0;
        uint8 agreeNum = 0;
        for (LfgAnswerContainer::const_iterator itVotes = boot.votes.begin(); itVotes != boot.votes.end(); ++itVotes)
        {
            if (itVotes->second != LFG_ANSWER_PENDING)
            {
                ++votesNum;
                if (itVotes->second == LFG_ANSWER_AGREE)
                    ++agreeNum;
            }
        }
 
        // if we don't have enough votes (agree or deny) do nothing
        if (agreeNum < LFG_GROUP_KICK_VOTES_NEEDED && (votesNum - agreeNum) < LFG_GROUP_KICK_VOTES_NEEDED)
            return;
 
        // Send update info to all players
        boot.inProgress = false;
        for (LfgAnswerContainer::const_iterator itVotes = boot.votes.begin(); itVotes != boot.votes.end(); ++itVotes)
        {
            ObjectGuid pguid = itVotes->first;
            if (pguid != boot.victim)
            {
                SetState(pguid, LFG_STATE_DUNGEON);
                SendLfgBootProposalUpdate(pguid, boot);
            }
        }
 
        SetState(gguid, LFG_STATE_DUNGEON);
        if (agreeNum == LFG_GROUP_KICK_VOTES_NEEDED)           // Vote passed - Kick player
        {
            if (Group* group = sGroupMgr->GetGroupByGUID(gguid.GetCounter()))
                Player::RemoveFromGroup(group, boot.victim, GROUP_REMOVEMETHOD_KICK_LFG);
 
            DecreaseKicksLeft(gguid);
        }
        BootsStore.erase(itBoot);
    }

References BootsStore, DecreaseKicksLeft(), ObjectGuid::GetCounter(), GetGroup(), GROUP_REMOVEMETHOD_KICK_LFG, lfg::LfgPlayerBoot::inProgress, lfg::LFG_ANSWER_AGREE, lfg::LFG_ANSWER_PENDING, lfg::LFG_GROUP_KICK_VOTES_NEEDED, lfg::LFG_STATE_DUNGEON, Player::RemoveFromGroup(), SendLfgBootProposalUpdate(), SetState(), sGroupMgr, lfg::LfgPlayerBoot::victim, and lfg::LfgPlayerBoot::votes.

◆ UpdateProposal()

void lfg::LFGMgr::UpdateProposal	(	uint32	proposalId,
		ObjectGuid	guid,
		bool	accept
	)

Updates proposal to join dungeon with player answer.

Update Proposal info with player answer

Parameters

[in]	proposalId	Proposal id to be updated
[in]	guid	Player guid to update answer
[in]	accept	Player answer

    {
        // Check if the proposal exists
        LfgProposalContainer::iterator itProposal = ProposalsStore.find(proposalId);
        if (itProposal == ProposalsStore.end())
            return;
 
        LfgProposal& proposal = itProposal->second;
 
        // Check if proposal have the current player
        LfgProposalPlayerContainer::iterator itProposalPlayer = proposal.players.find(guid);
        if (itProposalPlayer == proposal.players.end())
            return;
 
        LfgProposalPlayer& player = itProposalPlayer->second;
        player.accept = LfgAnswer(accept);
 
        LOG_DEBUG("lfg", "LFGMgr::UpdateProposal: Player [{}] of proposal {} selected: {}", guid.ToString(), proposalId, accept);
        if (!accept)
        {
            RemoveProposal(itProposal, LFG_UPDATETYPE_PROPOSAL_DECLINED);
            return;
        }
 
        // check if all have answered and reorder players (leader first)
        bool allAnswered = true;
        for (LfgProposalPlayerContainer::const_iterator itPlayers = proposal.players.begin(); itPlayers != proposal.players.end(); ++itPlayers)
            if (itPlayers->second.accept != LFG_ANSWER_AGREE)   // No answer (-1) or not accepted (0)
                allAnswered = false;
 
        if (!m_Testing && !allAnswered)
        {
            for (LfgProposalPlayerContainer::const_iterator it = proposal.players.begin(); it != proposal.players.end(); ++it)
                SendLfgUpdateProposal(it->first, proposal);
 
            return;
        }
 
        bool sendUpdate = proposal.state != LFG_PROPOSAL_SUCCESS;
        proposal.state = LFG_PROPOSAL_SUCCESS;
        time_t joinTime = GameTime::GetGameTime().count();
 
        LFGQueue& queue = GetQueue(guid);
        LfgUpdateData updateData = LfgUpdateData(LFG_UPDATETYPE_GROUP_FOUND);
        for (LfgProposalPlayerContainer::const_iterator it = proposal.players.begin(); it != proposal.players.end(); ++it)
        {
            ObjectGuid pguid = it->first;
            ObjectGuid gguid = it->second.group;
            uint32 dungeonId = (*GetSelectedDungeons(pguid).begin());
            int32 waitTime = -1;
            if (sendUpdate)
                SendLfgUpdateProposal(pguid, proposal);
 
            if (gguid)
            {
                waitTime = int32((joinTime - queue.GetJoinTime(gguid)) / IN_MILLISECONDS);
                SendLfgUpdateParty(pguid, updateData);
            }
            else
            {
                waitTime = int32((joinTime - queue.GetJoinTime(pguid)) / IN_MILLISECONDS);
                SendLfgUpdatePlayer(pguid, updateData);
            }
            updateData.updateType = LFG_UPDATETYPE_REMOVED_FROM_QUEUE;
            SendLfgUpdatePlayer(pguid, updateData);
            SendLfgUpdateParty(pguid, updateData);
 
            // Update timers
            uint8 role = GetRoles(pguid);
            role &= ~PLAYER_ROLE_LEADER;
            switch (role)
            {
                case PLAYER_ROLE_DAMAGE:
                    queue.UpdateWaitTimeDps(waitTime, dungeonId);
                    break;
                case PLAYER_ROLE_HEALER:
                    queue.UpdateWaitTimeHealer(waitTime, dungeonId);
                    break;
                case PLAYER_ROLE_TANK:
                    queue.UpdateWaitTimeTank(waitTime, dungeonId);
                    break;
                default:
                    queue.UpdateWaitTimeAvg(waitTime, dungeonId);
                    break;
            }
 
            SetState(pguid, LFG_STATE_DUNGEON);
        }
 
        // Remove players/groups from Queue
        for (uint8 i = 0; i < 5 && proposal.queues.guids[i]; ++i)
            queue.RemoveQueueData(proposal.queues.guids[i]);
 
        MakeNewGroup(proposal);
        ProposalsStore.erase(itProposal);
    }

References lfg::LfgProposalPlayer::accept, GameTime::GetGameTime(), lfg::LFGQueue::GetJoinTime(), GetQueue(), GetRoles(), GetSelectedDungeons(), lfg::Lfg5Guids::guids, IN_MILLISECONDS, lfg::LFG_ANSWER_AGREE, lfg::LFG_PROPOSAL_SUCCESS, lfg::LFG_STATE_DUNGEON, lfg::LFG_UPDATETYPE_GROUP_FOUND, lfg::LFG_UPDATETYPE_PROPOSAL_DECLINED, lfg::LFG_UPDATETYPE_REMOVED_FROM_QUEUE, LOG_DEBUG, m_Testing, MakeNewGroup(), lfg::PLAYER_ROLE_DAMAGE, lfg::PLAYER_ROLE_HEALER, lfg::PLAYER_ROLE_TANK, lfg::LfgProposal::players, ProposalsStore, lfg::LfgProposal::queues, RemoveProposal(), lfg::LFGQueue::RemoveQueueData(), SendLfgUpdateParty(), SendLfgUpdatePlayer(), SendLfgUpdateProposal(), SetState(), lfg::LfgProposal::state, ObjectGuid::ToString(), lfg::LfgUpdateData::updateType, lfg::LFGQueue::UpdateWaitTimeAvg(), lfg::LFGQueue::UpdateWaitTimeDps(), lfg::LFGQueue::UpdateWaitTimeHealer(), and lfg::LFGQueue::UpdateWaitTimeTank().

Referenced by Update().

◆ UpdateRaidBrowser()

void lfg::LFGMgr::UpdateRaidBrowser ( uint32 diff )

    {
        for (uint8 team = 0; team < 2; ++team)
        {
            if (m_raidBrowserUpdateTimer[team] > diff)
                m_raidBrowserUpdateTimer[team] -= diff;
            else
                m_raidBrowserUpdateTimer[team] = 0;
        }
 
        if (GetMSTimeDiff(GameTime::GetGameTimeMS(), GetTimeMS()) > 98ms) // prevent lagging
        {
            return;
        }
 
        ObjectGuid guid, groupGuid, instanceGuid;
        uint8 level, Class, race, talents[3];
        float iLevel, mp5, mp5combat, baseAP, rangedAP;
        int32 spellDamage, spellHeal;
        uint32 dungeonId, encounterMask, maxPower;
        uint32 deletedCounter, groupCounter, playerCounter;
        ByteBuffer buffer_deleted, buffer_groups, buffer_players;
        std::string emptyComment;
        GuidSet deletedGroups, deletedGroupsToErase;
        RBInternalInfoMap copy;
 
        for (uint8 team = 0; team < 2; ++team)
        {
            if (m_raidBrowserLastUpdatedDungeonId[team] == 0) // new loop
            {
                if (m_raidBrowserUpdateTimer[team] > 0) // allowed only with some time interval
                    continue;
                else // reset timer
                    m_raidBrowserUpdateTimer[team] = 5000;
            }
 
            RBUsedDungeonsSet::const_iterator neitr, titr;
            for (neitr = RBUsedDungeonsStore[team].begin(); neitr != RBUsedDungeonsStore[team].end(); )
            {
                titr = neitr++;
                dungeonId = (*titr);
 
                // go to next dungeon than previously (one dungeon updated in one LFGMgr::UpdateRaidBrowser)
                if (dungeonId <= m_raidBrowserLastUpdatedDungeonId[team])
                    continue;
                m_raidBrowserLastUpdatedDungeonId[team] = dungeonId;
 
                RBEntryInfoMap& entryInfoMap = RaidBrowserStore[team][dungeonId];
                LFGDungeonData const* dungeonData = GetLFGDungeon(dungeonId); // checked if exists before inserting to the container
                RBInternalInfoMap& currInternalInfoMap = RBInternalInfoStoreCurr[team][dungeonId];
                for (RBEntryInfoMap::const_iterator sitr = entryInfoMap.begin(); sitr != entryInfoMap.end(); ++sitr)
                {
                    guid = sitr->first;
                    groupGuid.Clear();
                    Player* p = ObjectAccessor::FindConnectedPlayer(guid);
                    ASSERT(p);
                    if (sitr->second.roles == PLAYER_ROLE_LEADER)
                    {
                        ASSERT(p->GetGroup());
                        groupGuid = p->GetGroup()->GetGUID();
                    }
                    encounterMask = 0;
                    instanceGuid.Clear();
                    if (InstancePlayerBind* bind = sInstanceSaveMgr->PlayerGetBoundInstance(guid, dungeonData->map, dungeonData->difficulty))
                        if (bind->perm)
                        {
                            instanceGuid = ObjectGuid::Create<HighGuid::Instance>(bind->save->GetInstanceId());
                            encounterMask = bind->save->GetCompletedEncounterMask();
                        }
 
                    talents[0] = 0;
                    talents[1] = 0;
                    talents[2] = 0;
                    p->GetTalentTreePoints(talents);
                    spellDamage = p->SpellBaseDamageBonusDone(SPELL_SCHOOL_MASK_ALL);
                    spellHeal = p->SpellBaseHealingBonusDone(SPELL_SCHOOL_MASK_ALL);
                    mp5 = p->GetFloatValue(UNIT_FIELD_POWER_REGEN_FLAT_MODIFIER);
                    mp5combat = p->GetFloatValue(UNIT_FIELD_POWER_REGEN_INTERRUPTED_FLAT_MODIFIER);
                    baseAP = p->GetTotalAttackPowerValue(BASE_ATTACK);
                    rangedAP = p->GetTotalAttackPowerValue(RANGED_ATTACK);
                    maxPower = 0;
                    if (p->IsClass(CLASS_DRUID))
                        maxPower = p->GetMaxPower(POWER_MANA);
                    else
                        maxPower = (p->getPowerType() == POWER_RAGE || p->getPowerType() == POWER_RUNIC_POWER) ? p->GetMaxPower(p->getPowerType()) / 10 : p->GetMaxPower(p->getPowerType());
 
                    currInternalInfoMap[sitr->first] = RBInternalInfo(guid, sitr->second.comment, !groupGuid.IsEmpty(), groupGuid, sitr->second.roles, encounterMask, instanceGuid,
                                                       1, p->GetLevel(), p->getClass(), p->getRace(), p->GetAverageItemLevel(),
                                                       talents, p->GetAreaId(), p->GetArmor(), (uint32)std::max<int32>(0, spellDamage), (uint32)std::max<int32>(0, spellHeal),
                                                       p->GetUInt32Value(PLAYER_FIELD_COMBAT_RATING_1 + static_cast<uint16>(CR_CRIT_MELEE)), p->GetUInt32Value(PLAYER_FIELD_COMBAT_RATING_1 + static_cast<uint16>(CR_CRIT_RANGED)), p->GetUInt32Value(PLAYER_FIELD_COMBAT_RATING_1 + static_cast<uint16>(CR_CRIT_SPELL)), std::max<float>(0.0f, mp5), std::max<float>(0.0f, mp5combat),
                                                       std::max<uint32>(baseAP, rangedAP), (uint32)p->GetStat(STAT_AGILITY), p->GetMaxHealth(), maxPower, p->GetDefenseSkillValue(),
                                                       p->GetUInt32Value(PLAYER_FIELD_COMBAT_RATING_1 + static_cast<uint16>(CR_DODGE)), p->GetUInt32Value(PLAYER_FIELD_COMBAT_RATING_1 + static_cast<uint16>(CR_BLOCK)), p->GetUInt32Value(PLAYER_FIELD_COMBAT_RATING_1 + static_cast<uint16>(CR_PARRY)), p->GetUInt32Value(PLAYER_FIELD_COMBAT_RATING_1 + static_cast<uint16>(CR_HASTE_SPELL)), p->GetUInt32Value(PLAYER_FIELD_COMBAT_RATING_1 + static_cast<uint16>(CR_EXPERTISE)));
 
                    if (!groupGuid)
                        continue;
                    for (Group::member_citerator mitr = p->GetGroup()->GetMemberSlots().begin(); mitr != p->GetGroup()->GetMemberSlots().end(); ++mitr)
                    {
                        if (mitr->guid == sitr->first) // leader already added
                            continue;
 
                        guid = mitr->guid;
                        level = 1;
                        Class = 0;
                        race = 0;
                        iLevel = 0.0f;
                        talents[0] = 0;
                        talents[1] = 0;
                        talents[2] = 0;
                        if (CharacterCacheEntry const* gpd = sCharacterCache->GetCharacterCacheByGuid(mitr->guid))
                        {
                            level = gpd->Level;
                            Class = gpd->Class;
                            race = gpd->Race;
                        }
                        Player* mplr = ObjectAccessor::FindConnectedPlayer(guid);
                        if (mplr)
                        {
                            iLevel = mplr->GetAverageItemLevel();
                            mplr->GetTalentTreePoints(talents);
                        }
                        currInternalInfoMap[mitr->guid] = RBInternalInfo(guid, emptyComment, false, groupGuid, 0, 0, ObjectGuid::Empty,
                                                          (mplr ? 1 : 0), level, Class, race, iLevel,
                                                          talents, 0, 0, 0, 0,
                                                          0, 0, 0, 0, 0,
                                                          0, 0, 0, 0, 0,
                                                          0, 0, 0, 0, 0);
                    }
                }
 
                copy.clear();
                copy = currInternalInfoMap; // will be saved as prev at the end
 
                // compare prev with curr to build difference packet
                deletedCounter = 0;
                groupCounter = 0;
                playerCounter = 0;
                buffer_deleted.clear();
                buffer_groups.clear();
                buffer_players.clear();
                deletedGroups.clear();
                deletedGroupsToErase.clear();
 
                RBInternalInfoMap& prevInternalInfoMap = RBInternalInfoStorePrev[team][dungeonId];
                RBInternalInfoMap::iterator iter, iterTmp;
                for (RBInternalInfoMap::const_iterator sitr = prevInternalInfoMap.begin(); sitr != prevInternalInfoMap.end(); ++sitr)
                {
                    iter = currInternalInfoMap.find(sitr->first);
                    if (iter == currInternalInfoMap.end()) // was -> isn't
                    {
                        if (sitr->second.isGroupLeader)
                            deletedGroups.insert(sitr->second.groupGuid);
                        ++deletedCounter;
                        buffer_deleted << sitr->second.guid;
                    }
                    else // was -> is
                    {
                        if (sitr->second.isGroupLeader) // was a leader
                        {
                            if (!iter->second.isGroupLeader) // leader -> no longer a leader
                                deletedGroups.insert(sitr->second.groupGuid);
                            else if (sitr->second.groupGuid != iter->second.groupGuid) // leader -> leader of another group
                            {
                                deletedGroups.insert(sitr->second.groupGuid);
                                deletedGroupsToErase.insert(iter->second.groupGuid);
                                ++groupCounter;
                                RBPacketAppendGroup(iter->second, buffer_groups);
                            }
                            else if (sitr->second.comment != iter->second.comment || sitr->second.encounterMask != iter->second.encounterMask || sitr->second.instanceGuid != iter->second.instanceGuid) // leader -> nothing changed
                            {
                                ++groupCounter;
                                RBPacketAppendGroup(iter->second, buffer_groups);
                            }
                        }
                        else if (iter->second.isGroupLeader) // wasn't a leader -> is a leader
                        {
                            deletedGroupsToErase.insert(iter->second.groupGuid);
                            ++groupCounter;
                            RBPacketAppendGroup(iter->second, buffer_groups);
                        }
 
                        if (!iter->second._online) // if offline, copy previous stats (itemLevel, talents, area, etc.)
                        {
                            iterTmp = copy.find(sitr->first); // copied container is for building a full packet, so modify it there (currInternalInfoMap is erased)
                            iterTmp->second.CopyStats(sitr->second);
                            if (!sitr->second.PlayerSameAs(iterTmp->second)) // player info changed
                            {
                                ++playerCounter;
                                RBPacketAppendPlayer(iterTmp->second, buffer_players);
                            }
                        }
                        else if (!sitr->second.PlayerSameAs(iter->second)) // player info changed
                        {
                            ++playerCounter;
                            RBPacketAppendPlayer(iter->second, buffer_players);
                        }
                        currInternalInfoMap.erase(iter);
                    }
                }
                // left entries (new)
                for (RBInternalInfoMap::const_iterator sitr = currInternalInfoMap.begin(); sitr != currInternalInfoMap.end(); ++sitr)
                {
                    if (sitr->second.isGroupLeader)
                    {
                        deletedGroupsToErase.insert(sitr->second.groupGuid);
                        ++groupCounter;
                        RBPacketAppendGroup(sitr->second, buffer_groups);
                    }
                    ++playerCounter;
                    RBPacketAppendPlayer(sitr->second, buffer_players);
                }
 
                if (!deletedGroupsToErase.empty())
                {
                    for (ObjectGuid const& toErase : deletedGroupsToErase)
                    {
                        deletedGroups.erase(toErase);
                    }
                }
 
                if (!deletedGroups.empty())
                {
                    for (ObjectGuid const& deletedGroup : deletedGroups)
                    {
                        ++deletedCounter;
                        buffer_deleted << deletedGroup;
                    }
                }
 
                WorldPacket differencePacket(SMSG_UPDATE_LFG_LIST, 1000);
                RBPacketBuildDifference(differencePacket, dungeonId, deletedCounter, buffer_deleted, groupCounter, buffer_groups, playerCounter, buffer_players);
                WorldPacket fullPacket(SMSG_UPDATE_LFG_LIST, 1000);
                RBPacketBuildFull(fullPacket, dungeonId, copy);
 
                RBCacheStore[team][dungeonId] = fullPacket;
                prevInternalInfoMap = copy;
                currInternalInfoMap.clear();
 
                if (entryInfoMap.empty())
                    RBUsedDungeonsStore[team].erase(titr);
 
                // send difference packet to browsing players
                for (RBSearchersMap::const_iterator sitr = RBSearchersStore[team].begin(); sitr != RBSearchersStore[team].end(); ++sitr)
                    if (sitr->second == dungeonId)
                        if (Player* p = ObjectAccessor::FindConnectedPlayer(sitr->first))
                            p->SendDirectMessage(&differencePacket);
 
                break; // one dungeon updated in one LFGMgr::UpdateRaidBrowser
            }
 
            // already updated all in this time interval
            if (neitr == RBUsedDungeonsStore[team].end())
                m_raidBrowserLastUpdatedDungeonId[team] = 0;
        }
    }

References ASSERT, BASE_ATTACK, Class, CLASS_DRUID, ObjectGuid::Clear(), ByteBuffer::clear(), CR_BLOCK, CR_CRIT_MELEE, CR_CRIT_RANGED, CR_CRIT_SPELL, CR_DODGE, CR_EXPERTISE, CR_HASTE_SPELL, CR_PARRY, lfg::LFGDungeonData::difficulty, ObjectGuid::Empty, ObjectAccessor::FindConnectedPlayer(), WorldObject::GetAreaId(), Unit::GetArmor(), Player::GetAverageItemLevel(), Unit::getClass(), Unit::GetDefenseSkillValue(), Object::GetFloatValue(), GameTime::GetGameTimeMS(), Player::GetGroup(), Group::GetGUID(), Unit::GetLevel(), GetLFGDungeon(), Unit::GetMaxHealth(), Unit::GetMaxPower(), Group::GetMemberSlots(), GetMSTimeDiff(), Unit::getPowerType(), Unit::getRace(), Unit::GetStat(), Player::GetTalentTreePoints(), GetTimeMS(), Unit::GetTotalAttackPowerValue(), Object::GetUInt32Value(), Player::IsClass(), ObjectGuid::IsEmpty(), m_raidBrowserLastUpdatedDungeonId, m_raidBrowserUpdateTimer, lfg::LFGDungeonData::map, PLAYER_FIELD_COMBAT_RATING_1, lfg::PLAYER_ROLE_LEADER, POWER_MANA, POWER_RAGE, POWER_RUNIC_POWER, RaidBrowserStore, RANGED_ATTACK, RBCacheStore, RBInternalInfoStoreCurr, RBInternalInfoStorePrev, RBPacketAppendGroup(), RBPacketAppendPlayer(), RBPacketBuildDifference(), RBPacketBuildFull(), RBSearchersStore, RBUsedDungeonsStore, sCharacterCache, sInstanceSaveMgr, SMSG_UPDATE_LFG_LIST, SPELL_SCHOOL_MASK_ALL, Unit::SpellBaseDamageBonusDone(), Unit::SpellBaseHealingBonusDone(), STAT_AGILITY, UNIT_FIELD_POWER_REGEN_FLAT_MODIFIER, and UNIT_FIELD_POWER_REGEN_INTERRUPTED_FLAT_MODIFIER.

Referenced by Update().

◆ UpdateRoleCheck()

void lfg::LFGMgr::UpdateRoleCheck	(	ObjectGuid	gguid,
		ObjectGuid	guid = `ObjectGuid::Empty`,
		uint8	roles = `PLAYER_ROLE_NONE`
	)

Updates the role check with player answer.

Update the Role check info with the player selected role.

Parameters

[in]	grp	Group guid to update rolecheck
[in]	guid	Player guid (0 = rolecheck failed)
[in]	roles	Player selected roles

    {
        if (!gguid)
            return;
 
        LfgRoleCheckContainer::iterator itRoleCheck = RoleChecksStore.find(gguid);
        if (itRoleCheck == RoleChecksStore.end())
            return;
 
        LfgRoleCheck& roleCheck = itRoleCheck->second;
        bool sendRoleChosen = roleCheck.state != LFG_ROLECHECK_DEFAULT && guid;
 
        if (!guid)
            roleCheck.state = LFG_ROLECHECK_ABORTED;
        else if (roles < PLAYER_ROLE_TANK)                            // Player selected no role.
            roleCheck.state = LFG_ROLECHECK_NO_ROLE;
        else
        {
            roleCheck.roles[guid] = roles;
 
            // Check if all players have selected a role
            LfgRolesMap::const_iterator itRoles = roleCheck.roles.begin();
            while (itRoles != roleCheck.roles.end() && itRoles->second != PLAYER_ROLE_NONE)
                ++itRoles;
 
            if (itRoles == roleCheck.roles.end())
            {
                roleCheck.state = CheckGroupRoles(roleCheck.roles) ? LFG_ROLECHECK_FINISHED : LFG_ROLECHECK_WRONG_ROLES;
            }
        }
 
        LfgDungeonSet dungeons;
        if (roleCheck.rDungeonId)
            dungeons.insert(roleCheck.rDungeonId);
        else
            dungeons = roleCheck.dungeons;
 
        LfgJoinResultData joinData = LfgJoinResultData(LFG_JOIN_FAILED, roleCheck.state);
        for (LfgRolesMap::const_iterator it = roleCheck.roles.begin(); it != roleCheck.roles.end(); ++it)
        {
            ObjectGuid pguid = it->first;
 
            if (sendRoleChosen)
                SendLfgRoleChosen(pguid, guid, roles);
 
            SendLfgRoleCheckUpdate(pguid, roleCheck);
            switch (roleCheck.state)
            {
                case LFG_ROLECHECK_INITIALITING:
                    continue;
                case LFG_ROLECHECK_FINISHED:
                    SetState(pguid, LFG_STATE_QUEUED);
                    SetRoles(pguid, it->second);
                    SendLfgUpdateParty(pguid, LfgUpdateData(LFG_UPDATETYPE_ADDED_TO_QUEUE, dungeons, GetComment(pguid)));
                    break;
                default:
                    if (roleCheck.leader == pguid)
                        SendLfgJoinResult(pguid, joinData);
                    SendLfgUpdateParty(pguid, LfgUpdateData(LFG_UPDATETYPE_ROLECHECK_FAILED));
                    RestoreState(pguid, "Rolecheck Failed");
                    break;
            }
        }
 
        if (roleCheck.state == LFG_ROLECHECK_FINISHED)
        {
            SetState(gguid, LFG_STATE_QUEUED);
            LFGQueue& queue = GetQueue(gguid);
            queue.AddQueueData(gguid, time_t(GameTime::GetGameTime().count()), roleCheck.dungeons, roleCheck.roles);
            RoleChecksStore.erase(itRoleCheck);
        }
        else if (roleCheck.state != LFG_ROLECHECK_INITIALITING)
        {
            RestoreState(gguid, "Rolecheck Failed");
            RoleChecksStore.erase(itRoleCheck);
        }
    }

References lfg::LFGQueue::AddQueueData(), CheckGroupRoles(), lfg::LfgRoleCheck::dungeons, GetComment(), GameTime::GetGameTime(), GetQueue(), lfg::LfgRoleCheck::leader, lfg::LFG_JOIN_FAILED, lfg::LFG_ROLECHECK_ABORTED, lfg::LFG_ROLECHECK_DEFAULT, lfg::LFG_ROLECHECK_FINISHED, lfg::LFG_ROLECHECK_INITIALITING, lfg::LFG_ROLECHECK_NO_ROLE, lfg::LFG_ROLECHECK_WRONG_ROLES, lfg::LFG_STATE_QUEUED, lfg::LFG_UPDATETYPE_ADDED_TO_QUEUE, lfg::LFG_UPDATETYPE_ROLECHECK_FAILED, lfg::PLAYER_ROLE_NONE, lfg::PLAYER_ROLE_TANK, lfg::LfgRoleCheck::rDungeonId, RestoreState(), RoleChecksStore, lfg::LfgRoleCheck::roles, SendLfgJoinResult(), SendLfgRoleCheckUpdate(), SendLfgRoleChosen(), SendLfgUpdateParty(), SetRoles(), SetState(), and lfg::LfgRoleCheck::state.

Referenced by JoinLfg(), and LeaveLfg().

Member Data Documentation

◆ BootsStore

LfgPlayerBootContainer lfg::LFGMgr::BootsStore

private

Current player kicks.

Referenced by InitBoot(), Update(), and UpdateBoot().

◆ CachedDungeonMapStore

LfgCachedDungeonContainer lfg::LFGMgr::CachedDungeonMapStore

private

Stores all dungeons by groupType.

Referenced by GetDungeonsByRandom(), and LoadLFGDungeons().

◆ DungeonCooldownStore

LfgDungeonCooldownContainer lfg::LFGMgr::DungeonCooldownStore

private

Stores dungeon cooldowns per player.

Referenced by AddDungeonCooldown(), CleanupDungeonCooldowns(), ClearDungeonCooldowns(), and FilterCooldownDungeons().

◆ GroupsStore

LfgGroupDataContainer lfg::LFGMgr::GroupsStore

private

◆ lastProposalId

uint32 lfg::LFGMgr::lastProposalId

private

pussywizard, store it here because of splitting LFGMgr update into tasks

Referenced by Update().

◆ LfgDungeonStore

LFGDungeonContainer lfg::LFGMgr::LfgDungeonStore

private

Referenced by GetLFGDungeon(), GetRandomAndSeasonalDungeons(), and LoadLFGDungeons().

◆ m_lfgProposalId

uint32 lfg::LFGMgr::m_lfgProposalId

private

used as internal counter for proposals

Referenced by AddProposal(), and Update().

◆ m_options

uint32 lfg::LFGMgr::m_options

private

Stores config options.

Referenced by GetOptions(), InitializeLockedDungeons(), isOptionEnabled(), and SetOptions().

◆ m_raidBrowserLastUpdatedDungeonId

uint32 lfg::LFGMgr::m_raidBrowserLastUpdatedDungeonId[2]

private

pussywizard: for 2 factions

Referenced by LFGMgr(), and UpdateRaidBrowser().

◆ m_raidBrowserUpdateTimer

uint32 lfg::LFGMgr::m_raidBrowserUpdateTimer[2]

private

pussywizard

Referenced by LFGMgr(), and UpdateRaidBrowser().

◆ m_Testing

bool lfg::LFGMgr::m_Testing

private

Referenced by IsTesting(), MakeNewGroup(), ToggleTesting(), and UpdateProposal().

◆ PlayersStore

LfgPlayerDataContainer lfg::LFGMgr::PlayersStore

private

◆ ProposalsStore

LfgProposalContainer lfg::LFGMgr::ProposalsStore

private

Current Proposals.

Referenced by AddProposal(), LeaveLfg(), RemoveProposal(), Update(), and UpdateProposal().

◆ QueuesStore

LfgQueueContainer lfg::LFGMgr::QueuesStore

private

Queues.

Referenced by Clean(), GetQueue(), LeaveAllLfgQueues(), and Update().

◆ RaidBrowserStore

RBStoreMap lfg::LFGMgr::RaidBrowserStore[2]

private

Referenced by JoinRaidBrowser(), LeaveRaidBrowser(), LfrSetComment(), SendRaidBrowserJoinedPacket(), and UpdateRaidBrowser().

◆ RBCacheStore

RBCacheMap lfg::LFGMgr::RBCacheStore[2]

private

Referenced by SendRaidBrowserCachedList(), and UpdateRaidBrowser().

◆ RBInternalInfoStoreCurr

RBInternalInfoMapMap lfg::LFGMgr::RBInternalInfoStoreCurr[2]

private

Referenced by UpdateRaidBrowser().

◆ RBInternalInfoStorePrev

RBInternalInfoMapMap lfg::LFGMgr::RBInternalInfoStorePrev[2]

private

Referenced by UpdateRaidBrowser().

◆ RBSearchersStore

RBSearchersMap lfg::LFGMgr::RBSearchersStore[2]

private

Referenced by LfrSearchAdd(), LfrSearchRemove(), and UpdateRaidBrowser().

◆ RBUsedDungeonsStore

RBUsedDungeonsSet lfg::LFGMgr::RBUsedDungeonsStore[2]

private

Referenced by JoinRaidBrowser(), and UpdateRaidBrowser().

◆ RewardMapStore

LfgRewardContainer lfg::LFGMgr::RewardMapStore

private

Stores rewards for random dungeons.

Referenced by GetRandomDungeonReward(), LoadRewards(), and ~LFGMgr().

◆ RoleChecksStore

LfgRoleCheckContainer lfg::LFGMgr::RoleChecksStore

private

Current Role checks.

Referenced by JoinLfg(), Update(), and UpdateRoleCheck().

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

azerothcore-wotlk/src/server/game/DungeonFinding/LFGMgr.h
azerothcore-wotlk/src/server/game/DungeonFinding/LFGMgr.cpp

Public Member Functions

Static Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ LfgDungeonCooldownContainer

◆ LfgDungeonCooldownMap

◆ RBCacheMap

◆ RBEntryInfoMap

◆ RBInternalInfoMap

◆ RBInternalInfoMapMap

◆ RBSearchersMap

◆ RBStoreMap

◆ RBUsedDungeonsSet

Constructor & Destructor Documentation

◆ LFGMgr()

◆ ~LFGMgr()

Member Function Documentation

◆ _LoadFromDB()

◆ _SaveToDB()

◆ AddDungeonCooldown()

◆ AddPlayerQueuedForRandomDungeonToGroup()

◆ AddPlayerToGroup()

◆ AddProposal()

◆ AllQueued()

◆ CheckGroupRoles()

◆ Clean()

◆ CleanupDungeonCooldowns()

◆ ClearDungeonCooldowns()

◆ ClearState()

◆ DecreaseKicksLeft()

◆ FilterCooldownDungeons()

◆ FinishDungeon()

◆ GetComment()

◆ GetCompatibleDungeons()

◆ GetDungeon()

◆ GetDungeonCooldownDuration()

◆ GetDungeonMapId()

◆ GetDungeonsByRandom()

◆ GetDungeonType()

◆ GetGroup()

◆ GetKicksLeft()

◆ GetLeader()

◆ GetLFGDungeon()

◆ GetLFGDungeonEntry()

◆ GetLfgStatus()

◆ GetLockedDungeons()

◆ GetOldState()

◆ GetOptions()

◆ GetPlayerCount()

◆ GetPlayers()

◆ GetQueue()

◆ GetRandomAndSeasonalDungeons()

◆ GetRandomDungeonReward()

◆ GetRandomPlayersCount()

◆ GetRoles()

◆ GetSelectedDungeons()

◆ GetState()

◆ GetTeam()

◆ HasIgnore()

◆ InitBoot()

◆ InitializeLockedDungeons()

◆ inLfgDungeonMap()

◆ instance()

◆ IsDungeonDisabled()

◆ IsLfgGroup()

◆ isOptionEnabled()

◆ IsPlayerQueuedForRandomDungeon()

◆ IsSeasonActive()

◆ IsTesting()

◆ JoinLfg()

◆ JoinRaidBrowser()

◆ LeaveAllLfgQueues()

◆ LeaveLfg()

◆ LeaveRaidBrowser()

◆ LfrSearchAdd()

◆ LfrSearchRemove()

◆ LfrSetComment()