src/game/BattleGroundMgr.h

   1 /*
   2  * Copyright (C) 2005-2008 MaNGOS <http://getmangos.com/>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19 #ifndef __BATTLEGROUNDMGR_H
  20 #define __BATTLEGROUNDMGR_H
  21
  22 #include "BattleGround.h"
  23 #include "Policies/Singleton.h"
  24
  25 class BattleGround;
  26
  27 //TODO it is not possible to have this structure, because we should have BattlegroundSet for each queue
  28 //so i propose to change this type to array 1..MAX_BATTLEGROUND_TYPES of sets or maps..
  29 typedef std::map<uint32, BattleGround*> BattleGroundSet;
  30 //typedef std::map<uint32, BattleGroundQueue*> BattleGroundQueueSet;
  31 typedef std::deque<BattleGround*> BGFreeSlotQueueType;
  32
  33 #define MAX_BATTLEGROUND_QUEUES 7                           // for level ranges 10-19, 20-29, 30-39, 40-49, 50-59, 60-69, 70+
  34
  35 #define MAX_BATTLEGROUND_TYPES 9                            // each BG type will be in array
  36
  37 #define MAX_BATTLEGROUND_QUEUE_TYPES 8
  38
  39 #define BATTLEGROUND_ARENA_POINT_DISTRIBUTION_DAY    86400     // seconds in a day
  40
  41 struct GroupQueueInfo;                                      // type predefinition
  42 struct PlayerQueueInfo                                      // stores information for players in queue
  43 {
  44     uint32  InviteTime;                                     // first invite time
  45     uint32  LastInviteTime;                                 // last invite time
  46     uint32  LastOnlineTime;                                 // for tracking and removing offline players from queue after 5 minutes
  47     GroupQueueInfo * GroupInfo;                             // pointer to the associated groupqueueinfo
  48 };
  49
  50 struct GroupQueueInfo                                       // stores information about the group in queue (also used when joined as solo!)
  51 {
  52     std::map<uint64, PlayerQueueInfo*> Players;             // player queue info map
  53     uint32  Team;                                           // Player team (ALLIANCE/HORDE)
  54     uint32  BgTypeId;                                       // battleground type id
  55     bool    IsRated;                                        // rated
  56     uint8   ArenaType;                                      // 2v2, 3v3, 5v5 or 0 when BG
  57     uint32  ArenaTeamId;                                    // team id if rated match
  58     uint32  JoinTime;                                       // time when group was added
  59     uint32  IsInvitedToBGInstanceGUID;                      // was invited to certain BG
  60     uint32  ArenaTeamRating;                                // if rated match, inited to the rating of the team
  61     uint32  OpponentsTeamRating;                            // for rated arena matches
  62 };
  63
  64 class BattleGround;
  65 class BattleGroundQueue
  66 {
  67     public:
  68         BattleGroundQueue();
  69         ~BattleGroundQueue();
  70
  71         void Update(uint32 bgTypeId, uint32 queue_id, uint8 arenatype = 0, bool isRated = false, uint32 minRating = 0);
  72
  73         GroupQueueInfo * AddGroup(Player * leader, uint32 BgTypeId, uint8 ArenaType, bool isRated, uint32 ArenaRating, uint32 ArenaTeamId = 0);
  74         void AddPlayer(Player *plr, GroupQueueInfo *ginfo);
  75         void RemovePlayer(uint64 guid, bool decreaseInvitedCount);
  76         void DecreaseGroupLength(uint32 queueId, uint32 AsGroup);
  77         void BGEndedRemoveInvites(BattleGround * bg);
  78
  79         typedef std::map<uint64, PlayerQueueInfo> QueuedPlayersMap;
  80         QueuedPlayersMap m_QueuedPlayers[MAX_BATTLEGROUND_QUEUES];
  81
  82         typedef std::list<GroupQueueInfo*> QueuedGroupsList;
  83         QueuedGroupsList m_QueuedGroups[MAX_BATTLEGROUND_QUEUES];
  84
  85         // class to hold pointers to the groups eligible for a specific selection pool building mode
  86         class EligibleGroups : public std::list<GroupQueueInfo *>
  87         {
  88         public:
  89             void Init(QueuedGroupsList * source, uint32 BgTypeId, uint32 side, uint32 MaxPlayers, uint8 ArenaType = 0, bool IsRated = false, uint32 MinRating = 0, uint32 MaxRating = 0, uint32 DisregardTime = 0, uint32 excludeTeam = 0);
  90             void RemoveGroup(GroupQueueInfo * ginfo);
  91         };
  92
  93         EligibleGroups m_EligibleGroups;
  94
  95         // class to select and invite groups to bg
  96         class SelectionPool
  97         {
  98         public:
  99             void Init();
 100             void AddGroup(GroupQueueInfo * group);
 101             GroupQueueInfo * GetMaximalGroup();
 102             void RemoveGroup(GroupQueueInfo * group);
 103             uint32 GetPlayerCount() const {return PlayerCount;}
 104         public:
 105             std::list<GroupQueueInfo *> SelectedGroups;
 106         private:
 107             uint32 PlayerCount;
 108             GroupQueueInfo * MaxGroup;
 109         };
 110
 111         enum SelectionPoolBuildMode
 112         {
 113             NORMAL_ALLIANCE,
 114             NORMAL_HORDE,
 115             ONESIDE_ALLIANCE_TEAM1,
 116             ONESIDE_ALLIANCE_TEAM2,
 117             ONESIDE_HORDE_TEAM1,
 118             ONESIDE_HORDE_TEAM2,
 119
 120             NUM_SELECTION_POOL_TYPES
 121         };
 122
 123         SelectionPool m_SelectionPools[NUM_SELECTION_POOL_TYPES];
 124
 125         bool BuildSelectionPool(uint32 bgTypeId, uint32 queue_id, uint32 MinPlayers, uint32 MaxPlayers, SelectionPoolBuildMode mode, uint8 ArenaType = 0, bool isRated = false, uint32 MinRating = 0, uint32 MaxRating = 0, uint32 DisregardTime = 0, uint32 excludeTeam = 0);
 126
 127     private:
 128
 129         bool InviteGroupToBG(GroupQueueInfo * ginfo, BattleGround * bg, uint32 side);
 130 };
 131
 132 /*
 133     This class is used to invite player to BG again, when minute lasts from his first invitation
 134     it is capable to solve all possibilities
 135 */
 136 class BGQueueInviteEvent : public BasicEvent
 137 {
 138     public:
 139         BGQueueInviteEvent(uint64 pl_guid, uint32 BgInstanceGUID) : m_PlayerGuid(pl_guid), m_BgInstanceGUID(BgInstanceGUID) {};
 140         virtual ~BGQueueInviteEvent() {};
 141
 142         virtual bool Execute(uint64 e_time, uint32 p_time);
 143         virtual void Abort(uint64 e_time);
 144     private:
 145         uint64 m_PlayerGuid;
 146         uint32 m_BgInstanceGUID;
 147 };
 148
 149 /*
 150     This class is used to remove player from BG queue after 2 minutes from first invitation
 151 */
 152 class BGQueueRemoveEvent : public BasicEvent
 153 {
 154     public:
 155         BGQueueRemoveEvent(uint64 pl_guid, uint32 bgInstanceGUID, uint32 playersTeam) : m_PlayerGuid(pl_guid), m_BgInstanceGUID(bgInstanceGUID), m_PlayersTeam(playersTeam) {};
 156         virtual ~BGQueueRemoveEvent() {};
 157
 158         virtual bool Execute(uint64 e_time, uint32 p_time);
 159         virtual void Abort(uint64 e_time);
 160     private:
 161         uint64 m_PlayerGuid;
 162         uint32 m_BgInstanceGUID;
 163         uint32 m_PlayersTeam;
 164 };
 165
 166 class BattleGroundMgr
 167 {
 168     public:
 169         /* Construction */
 170         BattleGroundMgr();
 171         ~BattleGroundMgr();
 172         void Update(time_t diff);
 173
 174         /* Packet Building */
 175         void BuildPlayerJoinedBattleGroundPacket(WorldPacket *data, Player *plr);
 176         void BuildPlayerLeftBattleGroundPacket(WorldPacket *data, Player *plr);
 177         void BuildBattleGroundListPacket(WorldPacket *data, uint64 guid, Player *plr, uint32 bgTypeId);
 178         void BuildGroupJoinedBattlegroundPacket(WorldPacket *data, uint32 bgTypeId);
 179         void BuildUpdateWorldStatePacket(WorldPacket *data, uint32 field, uint32 value);
 180         void BuildPvpLogDataPacket(WorldPacket *data, BattleGround *bg);
 181         void BuildBattleGroundStatusPacket(WorldPacket *data, BattleGround *bg, uint32 team, uint8 QueueSlot, uint8 StatusID, uint32 Time1, uint32 Time2, uint32 arenatype = 0, uint8 israted = 0);
 182         void BuildPlaySoundPacket(WorldPacket *data, uint32 soundid);
 183
 184         /* Player invitation */
 185         // called from Queue update, or from Addplayer to queue
 186         void InvitePlayer(Player* plr, uint32 bgInstanceGUID, uint32 team);
 187
 188         /* Battlegrounds */
 189         BattleGroundSet::iterator GetBattleGroundsBegin() { return m_BattleGrounds.begin(); };
 190         BattleGroundSet::iterator GetBattleGroundsEnd() { return m_BattleGrounds.end(); };
 191
 192         BattleGround* GetBattleGround(uint32 ID)
 193         {
 194             BattleGroundSet::iterator i = m_BattleGrounds.find(ID);
 195             if(i != m_BattleGrounds.end())
 196                 return i->second;
 197             else
 198                 return NULL;
 199         };
 200
 201         BattleGround * GetBattleGroundTemplate(uint32 bgTypeId);
 202         BattleGround * CreateNewBattleGround(uint32 bgTypeId);
 203
 204         uint32 CreateBattleGround(uint32 bgTypeId, uint32 MinPlayersPerTeam, uint32 MaxPlayersPerTeam, uint32 LevelMin, uint32 LevelMax, char* BattleGroundName, uint32 MapID, float Team1StartLocX, float Team1StartLocY, float Team1StartLocZ, float Team1StartLocO, float Team2StartLocX, float Team2StartLocY, float Team2StartLocZ, float Team2StartLocO);
 205
 206         inline void AddBattleGround(uint32 ID, BattleGround* BG) { m_BattleGrounds[ID] = BG; };
 207         void RemoveBattleGround(uint32 instanceID);
 208
 209         void CreateInitialBattleGrounds();
 210
 211         void SendToBattleGround(Player *pl, uint32 bgTypeId);
 212
 213         /* Battleground queues */
 214         //these queues are instantiated when creating BattlegroundMrg
 215         BattleGroundQueue m_BattleGroundQueues[MAX_BATTLEGROUND_QUEUE_TYPES]; // public, because we need to access them in BG handler code
 216
 217         BGFreeSlotQueueType BGFreeSlotQueue[MAX_BATTLEGROUND_TYPES];
 218
 219         void SendAreaSpiritHealerQueryOpcode(Player *pl, BattleGround *bg, uint64 guid);
 220
 221         bool IsArenaType(uint32 bgTypeId) const;
 222         bool IsBattleGroundType(uint32 bgTypeId) const;
 223         uint32 BGQueueTypeId(uint32 bgTypeId, uint8 arenaType) const;
 224         uint32 BGTemplateId(uint32 bgQueueTypeId) const;
 225         uint8 BGArenaType(uint32 bgQueueTypeId) const;
 226
 227         uint32 GetMaxRatingDifference() const {return m_MaxRatingDifference;}
 228         uint32 GetRatingDiscardTimer() const {return m_RatingDiscardTimer;}
 229
 230         void InitAutomaticArenaPointDistribution();
 231         void DistributeArenaPoints();
 232         uint32 GetPrematureFinishTime() const {return m_PrematureFinishTimer;}
 233         void ToggleArenaTesting();
 234         const bool isArenaTesting() const { return m_ArenaTesting; }
 235
 236     private:
 237
 238         /* Battlegrounds */
 239         BattleGroundSet m_BattleGrounds;
 240         uint32 m_MaxRatingDifference;
 241         uint32 m_RatingDiscardTimer;
 242         uint32 m_NextRatingDiscardUpdate;
 243         bool   m_AutoDistributePoints;
 244         uint64 m_NextAutoDistributionTime;
 245         uint32 m_AutoDistributionTimeChecker;
 246         uint32 m_PrematureFinishTimer;
 247         bool   m_ArenaTesting;
 248 };
 249
 250 #define sBattleGroundMgr MaNGOS::Singleton<BattleGroundMgr>::Instance()
 251 #endif