LFGMgr.h

Go to the documentation of this file.

/*
 * Copyright (C) 2008-2016 TrinityCore <http://www.trinitycore.org/>
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program. If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef _LFGMGR_H
#define _LFGMGR_H

#include "DBCStructure.h"
#include "Field.h"
#include "LFG.h"
#include "LFGQueue.h"
#include "LFGGroupData.h"
#include "LFGPlayerData.h"

class Group;
class Player;
class Quest;

namespace lfg
{

enum LfgOptions
{
 LFG_OPTION_ENABLE_DUNGEON_FINDER = 0x01,
 LFG_OPTION_ENABLE_RAID_BROWSER = 0x02,
};

enum LFGMgrEnum
{
 LFG_TIME_ROLECHECK = 45 * IN_MILLISECONDS,
 LFG_TIME_BOOT = 120,
 LFG_TIME_PROPOSAL = 45,
 LFG_QUEUEUPDATE_INTERVAL = 15 * IN_MILLISECONDS,
 LFG_SPELL_DUNGEON_COOLDOWN = 71328,
 LFG_SPELL_DUNGEON_DESERTER = 71041,
 LFG_SPELL_LUCK_OF_THE_DRAW = 72221,
 LFG_GROUP_KICK_VOTES_NEEDED = 3
};

enum LfgFlags
{
 LFG_FLAG_UNK1 = 0x1,
 LFG_FLAG_UNK2 = 0x2,
 LFG_FLAG_SEASONAL = 0x4,
 LFG_FLAG_UNK3 = 0x8
};

enum LfgType
{
 LFG_TYPE_NONE = 0,
 LFG_TYPE_DUNGEON = 1,
 LFG_TYPE_RAID = 2,
 LFG_TYPE_HEROIC = 5,
 LFG_TYPE_RANDOM = 6
};

enum LfgProposalState
{
 LFG_PROPOSAL_INITIATING = 0,
 LFG_PROPOSAL_FAILED = 1,
 LFG_PROPOSAL_SUCCESS = 2
};

enum LfgTeleportError
{
 // 7 = "You can't do that right now" | 5 = No client reaction
 LFG_TELEPORTERROR_OK = 0, // Internal use
 LFG_TELEPORTERROR_PLAYER_DEAD = 1,
 LFG_TELEPORTERROR_FALLING = 2,
 LFG_TELEPORTERROR_IN_VEHICLE = 3,
 LFG_TELEPORTERROR_FATIGUE = 4,
 LFG_TELEPORTERROR_INVALID_LOCATION = 6,
 LFG_TELEPORTERROR_CHARMING = 8 // FIXME - It can be 7 or 8 (Need proper data)
};

enum LfgJoinResult
{
 // 3 = No client reaction | 18 = "Rolecheck failed"
 LFG_JOIN_OK = 0x00, // Joined (no client msg)
 LFG_JOIN_FAILED = 0x1B, // RoleCheck Failed
 LFG_JOIN_GROUPFULL = 0x1C, // Your group is full
 LFG_JOIN_INTERNAL_ERROR = 0x1E, // Internal LFG Error
 LFG_JOIN_NOT_MEET_REQS = 0x1F, // You do not meet the requirements for the chosen dungeons
 LFG_JOIN_PARTY_NOT_MEET_REQS = 6, // One or more party members do not meet the requirements for the chosen dungeons (FIXME)
 LFG_JOIN_MIXED_RAID_DUNGEON = 0x20, // You cannot mix dungeons, raids, and random when picking dungeons
 LFG_JOIN_MULTI_REALM = 0x21, // The dungeon you chose does not support players from multiple realms
 LFG_JOIN_DISCONNECTED = 0x22, // One or more party members are pending invites or disconnected
 LFG_JOIN_PARTY_INFO_FAILED = 0x23, // Could not retrieve information about some party members
 LFG_JOIN_DUNGEON_INVALID = 0x24, // One or more dungeons was not valid
 LFG_JOIN_DESERTER = 0x25, // You can not queue for dungeons until your deserter debuff wears off
 LFG_JOIN_PARTY_DESERTER = 0x26, // One or more party members has a deserter debuff
 LFG_JOIN_RANDOM_COOLDOWN = 0x27, // You can not queue for random dungeons while on random dungeon cooldown
 LFG_JOIN_PARTY_RANDOM_COOLDOWN = 0x28, // One or more party members are on random dungeon cooldown
 LFG_JOIN_TOO_MUCH_MEMBERS = 0x29, // You can not enter dungeons with more that 5 party members
 LFG_JOIN_USING_BG_SYSTEM = 0x2A, // You can not use the dungeon system while in BG or arenas
 LFG_JOIN_ROLE_CHECK_FAILED = 0x2B // Role check failed, client shows special error
};

enum LfgRoleCheckState
{
 LFG_ROLECHECK_DEFAULT = 0, // Internal use = Not initialized.
 LFG_ROLECHECK_FINISHED = 1, // Role check finished
 LFG_ROLECHECK_INITIALITING = 2, // Role check begins
 LFG_ROLECHECK_MISSING_ROLE = 3, // Someone didn't selected a role after 2 mins
 LFG_ROLECHECK_WRONG_ROLES = 4, // Can't form a group with that role selection
 LFG_ROLECHECK_ABORTED = 5, // Someone leave the group
 LFG_ROLECHECK_NO_ROLE = 6 // Someone selected no role
};

// Forward declaration (just to have all typedef together)
struct LFGDungeonData;
struct LfgReward;
struct LfgQueueInfo;
struct LfgRoleCheck;
struct LfgProposal;
struct LfgProposalPlayer;
struct LfgPlayerBoot;

typedef std::map<uint8, LFGQueue> LfgQueueContainer;
typedef std::multimap<uint32, LfgReward const*> LfgRewardContainer;
typedef std::pair<LfgRewardContainer::const_iterator, LfgRewardContainer::const_iterator> LfgRewardContainerBounds;
typedef std::map<uint8, LfgDungeonSet> LfgCachedDungeonContainer;
typedef std::map<ObjectGuid, LfgAnswer> LfgAnswerContainer;
typedef std::map<ObjectGuid, LfgRoleCheck> LfgRoleCheckContainer;
typedef std::map<uint32, LfgProposal> LfgProposalContainer;
typedef std::map<ObjectGuid, LfgProposalPlayer> LfgProposalPlayerContainer;
typedef std::map<ObjectGuid, LfgPlayerBoot> LfgPlayerBootContainer;
typedef std::map<ObjectGuid, LfgGroupData> LfgGroupDataContainer;
typedef std::map<ObjectGuid, LfgPlayerData> LfgPlayerDataContainer;
typedef std::unordered_map<uint32, LFGDungeonData> LFGDungeonContainer;

// Data needed by SMSG_LFG_JOIN_RESULT
struct LfgJoinResultData
{
 LfgJoinResultData(LfgJoinResult _result = LFG_JOIN_OK, LfgRoleCheckState _state = LFG_ROLECHECK_DEFAULT):
 result(_result), state(_state) { }
 LfgJoinResult result;
 LfgRoleCheckState state;
 LfgLockPartyMap lockmap;
};

// Data needed by SMSG_LFG_UPDATE_STATUS
struct LfgUpdateData
{
 LfgUpdateData(LfgUpdateType _type = LFG_UPDATETYPE_DEFAULT): updateType(_type), state(LFG_STATE_NONE), comment("") { }
 LfgUpdateData(LfgUpdateType _type, LfgDungeonSet const& _dungeons, std::string const& _comment):
 updateType(_type), state(LFG_STATE_NONE), dungeons(_dungeons), comment(_comment) { }
 LfgUpdateData(LfgUpdateType _type, LfgState _state, LfgDungeonSet const& _dungeons, std::string const& _comment = ""):
 updateType(_type), state(_state), dungeons(_dungeons), comment(_comment) { }

 LfgUpdateType updateType;
 LfgState state;
 LfgDungeonSet dungeons;
 std::string comment;
};

// Data needed by SMSG_LFG_QUEUE_STATUS
struct LfgQueueStatusData
{
 LfgQueueStatusData(uint8 _queueId = 0, uint32 _dungeonId = 0, time_t _joinTime = 0, int32 _waitTime = -1, int32 _waitTimeAvg = -1, int32 _waitTimeTank = -1, int32 _waitTimeHealer = -1,
 int32 _waitTimeDps = -1, uint32 _queuedTime = 0, uint8 _tanks = 0, uint8 _healers = 0, uint8 _dps = 0) :
 queueId(_queueId), dungeonId(_dungeonId), joinTime(_joinTime), waitTime(_waitTime), waitTimeAvg(_waitTimeAvg), waitTimeTank(_waitTimeTank),
 waitTimeHealer(_waitTimeHealer), waitTimeDps(_waitTimeDps), queuedTime(_queuedTime), tanks(_tanks), healers(_healers), dps(_dps) { }

 uint8 queueId;
 uint32 dungeonId;
 time_t joinTime;
 int32 waitTime;
 int32 waitTimeAvg;
 int32 waitTimeTank;
 int32 waitTimeHealer;
 int32 waitTimeDps;
 uint32 queuedTime;
 uint8 tanks;
 uint8 healers;
 uint8 dps;
};

struct LfgPlayerRewardData
{
 LfgPlayerRewardData(uint32 random, uint32 current, bool _done, Quest const* _quest):
 rdungeonEntry(random), sdungeonEntry(current), done(_done), quest(_quest) { }
 uint32 rdungeonEntry;
 uint32 sdungeonEntry;
 bool done;
 Quest const* quest;
};

struct LfgReward
{
 LfgReward(uint32 _maxLevel = 0, uint32 _firstQuest = 0, uint32 _otherQuest = 0):
 maxLevel(_maxLevel), firstQuest(_firstQuest), otherQuest(_otherQuest) { }

 uint32 maxLevel;
 uint32 firstQuest;
 uint32 otherQuest;
};

struct LfgProposalPlayer
{
 LfgProposalPlayer(): role(0), accept(LFG_ANSWER_PENDING), group() { }
 uint8 role; 
 LfgAnswer accept; 
 ObjectGuid group; 
};

struct LfgProposal
{
 LfgProposal(uint32 dungeon = 0): id(0), dungeonId(dungeon), state(LFG_PROPOSAL_INITIATING),
 group(), leader(), cancelTime(0), encounters(0), isNew(true)
 { }

 uint32 id; 
 uint32 dungeonId; 
 LfgProposalState state; 
 ObjectGuid group; 
 ObjectGuid leader; 
 time_t cancelTime; 
 uint32 encounters; 
 bool isNew; 
 GuidList queues; 
 GuidList showorder; 
 LfgProposalPlayerContainer players; 
};

struct LfgRoleCheck
{
 time_t cancelTime; 
 LfgRolesMap roles; 
 LfgRoleCheckState state; 
 LfgDungeonSet dungeons; 
 uint32 rDungeonId; 
 ObjectGuid leader; 
};

struct LfgPlayerBoot
{
 time_t cancelTime; 
 bool inProgress; 
 LfgAnswerContainer votes; 
 ObjectGuid victim; 
 std::string reason; 
};

struct LFGDungeonData
{
 LFGDungeonData(): id(0), name(""), map(0), type(0), expansion(0), group(0), minlevel(0),
 maxlevel(0), difficulty(DIFFICULTY_NONE), seasonal(false), x(0.0f), y(0.0f), z(0.0f), o(0.0f),
 requiredItemLevel(0)
 { }
 LFGDungeonData(LFGDungeonEntry const* dbc): id(dbc->ID), name(dbc->Name_lang), map(dbc->MapID),
 type(uint8(dbc->Type)), expansion(uint8(dbc->Expansion)), group(uint8(dbc->GroupID)),
 minlevel(uint8(dbc->MinLevel)), maxlevel(uint8(dbc->MaxLevel)), difficulty(Difficulty(dbc->DifficultyID)),
 seasonal((dbc->Flags & LFG_FLAG_SEASONAL) != 0), x(0.0f), y(0.0f), z(0.0f), o(0.0f),
 requiredItemLevel(0)
 { }

 uint32 id;
 std::string name;
 uint32 map;
 uint8 type;
 uint8 expansion;
 uint8 group;
 uint8 minlevel;
 uint8 maxlevel;
 Difficulty difficulty;
 bool seasonal;
 float x, y, z, o;
 uint16 requiredItemLevel;

 // Helpers
 uint32 Entry() const { return id + (type << 24); }
};

class TC_GAME_API LFGMgr
{
 private:
 LFGMgr();
 ~LFGMgr();

 public:
 static LFGMgr* instance();

 // Functions used outside lfg namespace
 void Update(uint32 diff);

 // World.cpp
 void FinishDungeon(ObjectGuid gguid, uint32 dungeonId);
 void LoadRewards();
 void LoadLFGDungeons(bool reload = false);

 // Multiple files
 bool selectedRandomLfgDungeon(ObjectGuid guid);
 bool inLfgDungeonMap(ObjectGuid guid, uint32 map, Difficulty difficulty);
 LfgDungeonSet const& GetSelectedDungeons(ObjectGuid guid);
 LfgState GetState(ObjectGuid guid);
 bool IsVoteKickActive(ObjectGuid gguid);
 uint32 GetDungeon(ObjectGuid guid, bool asId = true);
 uint32 GetDungeonMapId(ObjectGuid guid);
 uint8 GetKicksLeft(ObjectGuid gguid);
 void _LoadFromDB(Field* fields, ObjectGuid guid);
 void SetupGroupMember(ObjectGuid guid, ObjectGuid gguid);
 uint32 GetLFGDungeonEntry(uint32 id);

 // cs_lfg
 uint8 GetRoles(ObjectGuid guid);
 std::string const& GetComment(ObjectGuid gguid);
 uint32 GetOptions();
 void SetOptions(uint32 options);
 bool isOptionEnabled(uint32 option);
 void Clean();
 std::string DumpQueueInfo(bool full = false);

 // LFGScripts
 ObjectGuid GetLeader(ObjectGuid guid);
 void SetTeam(ObjectGuid guid, uint8 team);
 void SetGroup(ObjectGuid guid, ObjectGuid group);
 ObjectGuid GetGroup(ObjectGuid guid);
 void SetLeader(ObjectGuid gguid, ObjectGuid leader);
 void RemoveGroupData(ObjectGuid guid);
 uint8 RemovePlayerFromGroup(ObjectGuid gguid, ObjectGuid guid);
 void AddPlayerToGroup(ObjectGuid gguid, ObjectGuid guid);

 // LFGHandler
 LfgLockMap const GetLockedDungeons(ObjectGuid guid);
 LfgUpdateData GetLfgStatus(ObjectGuid guid);
 bool IsSeasonActive(uint32 dungeonId);
 LfgReward const* GetRandomDungeonReward(uint32 dungeon, uint8 level);
 LfgDungeonSet GetRandomAndSeasonalDungeons(uint8 level, uint8 expansion);
 void TeleportPlayer(Player* player, bool out, bool fromOpcode = false);
 void InitBoot(ObjectGuid gguid, ObjectGuid kguid, ObjectGuid vguid, std::string const& reason);
 void UpdateBoot(ObjectGuid guid, bool accept);
 void UpdateProposal(uint32 proposalId, ObjectGuid guid, bool accept);
 void UpdateRoleCheck(ObjectGuid gguid, ObjectGuid guid = ObjectGuid::Empty, uint8 roles = PLAYER_ROLE_NONE);
 void SetRoles(ObjectGuid guid, uint8 roles);
 void SetComment(ObjectGuid guid, std::string const& comment);
 void JoinLfg(Player* player, uint8 roles, LfgDungeonSet& dungeons, std::string const& comment);
 void LeaveLfg(ObjectGuid guid, bool disconnected = false);

 // LfgQueue
 LfgState GetOldState(ObjectGuid guid);
 bool IsLfgGroup(ObjectGuid guid);
 uint8 GetPlayerCount(ObjectGuid guid);
 uint32 AddProposal(LfgProposal& proposal);
 uint8 GetQueueId(ObjectGuid guid);
 bool AllQueued(GuidList const& check);
 time_t GetQueueJoinTime(ObjectGuid guid);
 static bool CheckGroupRoles(LfgRolesMap &groles);
 static bool HasIgnore(ObjectGuid guid1, ObjectGuid guid2);
 static void SendLfgQueueStatus(ObjectGuid guid, LfgQueueStatusData const& data);

 private:
 uint8 GetTeam(ObjectGuid guid);
 void RestoreState(ObjectGuid guid, char const* debugMsg);
 void ClearState(ObjectGuid guid, char const* debugMsg);
 void SetDungeon(ObjectGuid guid, uint32 dungeon);
 void SetSelectedDungeons(ObjectGuid guid, LfgDungeonSet const& dungeons);
 void DecreaseKicksLeft(ObjectGuid guid);
 void SetState(ObjectGuid guid, LfgState state);
 void SetVoteKick(ObjectGuid gguid, bool active);
 void RemovePlayerData(ObjectGuid guid);
 void GetCompatibleDungeons(LfgDungeonSet& dungeons, GuidSet const& players, LfgLockPartyMap& lockMap, bool isContinue);
 void _SaveToDB(ObjectGuid guid, uint32 db_guid);
 LFGDungeonData const* GetLFGDungeon(uint32 id);

 // Proposals
 void RemoveProposal(LfgProposalContainer::iterator itProposal, LfgUpdateType type);
 void MakeNewGroup(LfgProposal const& proposal);

 // Generic
 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 SendLfgUpdateStatus(ObjectGuid guid, LfgUpdateData const& data, bool party);
 void SendLfgUpdateProposal(ObjectGuid guid, LfgProposal const& proposal);

 GuidSet const& GetPlayers(ObjectGuid guid);

 // General variables
 uint32 m_QueueTimer; 
 uint32 m_lfgProposalId; 
 uint32 m_options; 

 LfgQueueContainer QueuesStore; 
 LfgCachedDungeonContainer CachedDungeonMapStore; 
 // Reward System
 LfgRewardContainer RewardMapStore; 
 LFGDungeonContainer LfgDungeonStore;
 // Rolecheck - Proposal - Vote Kicks
 LfgRoleCheckContainer RoleChecksStore; 
 LfgProposalContainer ProposalsStore; 
 LfgPlayerBootContainer BootsStore; 
 LfgPlayerDataContainer PlayersStore; 
 LfgGroupDataContainer GroupsStore; 
};

} // namespace lfg

#define sLFGMgr lfg::LFGMgr::instance()
#endif