src/game/BattleGroundMgr.h

   1 /*
   2  * Copyright (C) 2005-2009 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 "Common.h"
  23 #include "Policies/Singleton.h"
  24 #include "BattleGround.h"
  25
  26 typedef std::map<uint32, BattleGround*> BattleGroundSet;
  27
  28 //this container can't be deque, because deque doesn't like removing the last element - if you remove it, it invalidates next iterator and crash appears
  29 typedef std::list<BattleGround*> BGFreeSlotQueueType;
  30
  31 typedef UNORDERED_MAP<uint32, BattleGroundTypeId> BattleMastersMap;
  32
  33 #define BATTLEGROUND_ARENA_POINT_DISTRIBUTION_DAY 86400     // seconds in a day
  34 #define COUNT_OF_PLAYERS_TO_AVERAGE_WAIT_TIME 10
  35
  36 struct GroupQueueInfo;                                      // type predefinition
  37 struct PlayerQueueInfo                                      // stores information for players in queue
  38 {
  39     uint32  LastOnlineTime;                                 // for tracking and removing offline players from queue after 5 minutes
  40     GroupQueueInfo * GroupInfo;                             // pointer to the associated groupqueueinfo
  41 };
  42
  43 struct GroupQueueInfo                                       // stores information about the group in queue (also used when joined as solo!)
  44 {
  45     std::map<uint64, PlayerQueueInfo*> Players;             // player queue info map
  46     uint32  Team;                                           // Player team (ALLIANCE/HORDE)
  47     BattleGroundTypeId BgTypeId;                            // battleground type id
  48     bool    IsRated;                                        // rated
  49     uint8   ArenaType;                                      // 2v2, 3v3, 5v5 or 0 when BG
  50     uint32  ArenaTeamId;                                    // team id if rated match
  51     uint32  JoinTime;                                       // time when group was added
  52     uint32  RemoveInviteTime;                               // time when we will remove invite for players in group
  53     uint32  IsInvitedToBGInstanceGUID;                      // was invited to certain BG
  54     uint32  ArenaTeamRating;                                // if rated match, inited to the rating of the team
  55     uint32  OpponentsTeamRating;                            // for rated arena matches
  56 };
  57
  58 enum BattleGroundQueueGroupTypes
  59 {
  60     BG_QUEUE_PREMADE_ALLIANCE   = 0,
  61     BG_QUEUE_PREMADE_HORDE      = 1,
  62     BG_QUEUE_NORMAL_ALLIANCE    = 2,
  63     BG_QUEUE_NORMAL_HORDE       = 3
  64 };
  65 #define BG_QUEUE_GROUP_TYPES_COUNT 4
  66
  67 class BattleGround;
  68 class BattleGroundQueue
  69 {
  70     public:
  71         BattleGroundQueue();
  72         ~BattleGroundQueue();
  73
  74         void Update(BattleGroundTypeId bgTypeId, BGQueueIdBasedOnLevel queue_id, uint8 arenaType = 0, bool isRated = false, uint32 minRating = 0);
  75
  76         void FillPlayersToBG(BattleGround* bg, BGQueueIdBasedOnLevel queue_id);
  77         bool CheckPremadeMatch(BGQueueIdBasedOnLevel queue_id, uint32 MinPlayersPerTeam, uint32 MaxPlayersPerTeam);
  78         bool CheckNormalMatch(BattleGround* bg_template, BGQueueIdBasedOnLevel queue_id, uint32 minPlayers, uint32 maxPlayers);
  79         bool CheckSkirmishForSameFaction(BGQueueIdBasedOnLevel queue_id, uint32 minPlayersPerTeam);
  80         GroupQueueInfo * AddGroup(Player * leader, BattleGroundTypeId bgTypeId, uint8 ArenaType, bool isRated, bool isPremade, uint32 ArenaRating, uint32 ArenaTeamId = 0);
  81         void AddPlayer(Player *plr, GroupQueueInfo *ginfo);
  82         void RemovePlayer(const uint64& guid, bool decreaseInvitedCount);
  83         void PlayerInvitedToBGUpdateAverageWaitTime(GroupQueueInfo* ginfo, BGQueueIdBasedOnLevel queue_id);
  84         uint32 GetAverageQueueWaitTime(GroupQueueInfo* ginfo, BGQueueIdBasedOnLevel queue_id);
  85
  86         void DecreaseGroupLength(uint32 queueId, uint32 AsGroup);
  87         void AnnounceWorld(GroupQueueInfo *ginfo, const uint64& playerGUID, bool isAddedToQueue);
  88
  89         typedef std::map<uint64, PlayerQueueInfo> QueuedPlayersMap;
  90         QueuedPlayersMap m_QueuedPlayers;
  91
  92         //we need constant add to begin and constant remove / add from the end, therefore deque suits our problem well
  93         typedef std::list<GroupQueueInfo*> GroupsQueueType;
  94
  95         /*
  96         This two dimensional array is used to store All queued groups
  97         First dimension specifies the bgTypeId
  98         Second dimension specifies the player's group types -
  99              BG_QUEUE_PREMADE_ALLIANCE  is used for premade alliance groups and alliance rated arena teams
 100              BG_QUEUE_PREMADE_HORDE     is used for premade horde groups and horde rated arena teams
 101              BG_QUEUE_NORMAL_ALLIANCE   is used for normal (or small) alliance groups or non-rated arena matches
 102              BG_QUEUE_NORMAL_HORDE      is used for normal (or small) horde groups or non-rated arena matches
 103         */
 104         GroupsQueueType m_QueuedGroups[MAX_BATTLEGROUND_QUEUES][BG_QUEUE_GROUP_TYPES_COUNT];
 105
 106         // class to select and invite groups to bg
 107         class SelectionPool
 108         {
 109         public:
 110             void Init();
 111             bool AddGroup(GroupQueueInfo *ginfo, uint32 desiredCount);
 112             bool KickGroup(uint32 size);
 113             uint32 GetPlayerCount() const {return PlayerCount;}
 114         public:
 115             GroupsQueueType SelectedGroups;
 116         private:
 117             uint32 PlayerCount;
 118         };
 119
 120         //one selection pool for horde, other one for alliance
 121         SelectionPool m_SelectionPools[BG_TEAMS_COUNT];
 122
 123     private:
 124
 125         bool InviteGroupToBG(GroupQueueInfo * ginfo, BattleGround * bg, uint32 side);
 126         uint32 m_WaitTimes[BG_TEAMS_COUNT][MAX_BATTLEGROUND_QUEUES][COUNT_OF_PLAYERS_TO_AVERAGE_WAIT_TIME];
 127         uint32 m_WaitTimeLastPlayer[BG_TEAMS_COUNT][MAX_BATTLEGROUND_QUEUES];
 128         uint32 m_SumOfWaitTimes[BG_TEAMS_COUNT][MAX_BATTLEGROUND_QUEUES];
 129 };
 130
 131 /*
 132     This class is used to invite player to BG again, when minute lasts from his first invitation
 133     it is capable to solve all possibilities
 134 */
 135 class BGQueueInviteEvent : public BasicEvent
 136 {
 137     public:
 138         BGQueueInviteEvent(const uint64& pl_guid, uint32 BgInstanceGUID, BattleGroundTypeId BgTypeId, uint32 removeTime) :
 139           m_PlayerGuid(pl_guid), m_BgInstanceGUID(BgInstanceGUID), m_BgTypeId(BgTypeId), m_RemoveTime(removeTime)
 140           {
 141           };
 142         virtual ~BGQueueInviteEvent() {};
 143
 144         virtual bool Execute(uint64 e_time, uint32 p_time);
 145         virtual void Abort(uint64 e_time);
 146     private:
 147         uint64 m_PlayerGuid;
 148         uint32 m_BgInstanceGUID;
 149         BattleGroundTypeId m_BgTypeId;
 150         uint32 m_RemoveTime;
 151 };
 152
 153 /*
 154     This class is used to remove player from BG queue after 1 minute 20 seconds from first invitation
 155     We must store removeInvite time in case player left queue and joined and is invited again
 156     We must store bgQueueTypeId, because battleground can be deleted already, when player entered it
 157 */
 158 class BGQueueRemoveEvent : public BasicEvent
 159 {
 160     public:
 161         BGQueueRemoveEvent(const uint64& pl_guid, uint32 bgInstanceGUID, BattleGroundTypeId BgTypeId, BattleGroundQueueTypeId bgQueueTypeId, uint32 removeTime)
 162             : m_PlayerGuid(pl_guid), m_BgInstanceGUID(bgInstanceGUID), m_RemoveTime(removeTime), m_BgTypeId(BgTypeId), m_BgQueueTypeId(bgQueueTypeId)
 163         {}
 164
 165         virtual ~BGQueueRemoveEvent() {}
 166
 167         virtual bool Execute(uint64 e_time, uint32 p_time);
 168         virtual void Abort(uint64 e_time);
 169     private:
 170         uint64 m_PlayerGuid;
 171         uint32 m_BgInstanceGUID;
 172         uint32 m_RemoveTime;
 173         BattleGroundTypeId m_BgTypeId;
 174         BattleGroundQueueTypeId m_BgQueueTypeId;
 175 };
 176
 177 class BattleGroundMgr
 178 {
 179     public:
 180         /* Construction */
 181         BattleGroundMgr();
 182         ~BattleGroundMgr();
 183         void Update(uint32 diff);
 184
 185         /* Packet Building */
 186         void BuildPlayerJoinedBattleGroundPacket(WorldPacket *data, Player *plr);
 187         void BuildPlayerLeftBattleGroundPacket(WorldPacket *data, const uint64& guid);
 188         void BuildBattleGroundListPacket(WorldPacket *data, const uint64& guid, Player *plr, BattleGroundTypeId bgTypeId, uint8 fromWhere);
 189         void BuildGroupJoinedBattlegroundPacket(WorldPacket *data, BattleGroundTypeId bgTypeId);
 190         void BuildUpdateWorldStatePacket(WorldPacket *data, uint32 field, uint32 value);
 191         void BuildPvpLogDataPacket(WorldPacket *data, BattleGround *bg);
 192         void BuildBattleGroundStatusPacket(WorldPacket *data, BattleGround *bg, uint8 QueueSlot, uint8 StatusID, uint32 Time1, uint32 Time2, uint8 arenatype);
 193         void BuildPlaySoundPacket(WorldPacket *data, uint32 soundid);
 194         void SendAreaSpiritHealerQueryOpcode(Player *pl, BattleGround *bg, const uint64& guid);
 195
 196         /* Battlegrounds */
 197         BattleGround* GetBattleGroundThroughClientInstance(uint32 instanceId, BattleGroundTypeId bgTypeId);
 198         BattleGround* GetBattleGround(uint32 InstanceID, BattleGroundTypeId bgTypeId); //there must be uint32 because MAX_BATTLEGROUND_TYPE_ID means unknown
 199
 200         BattleGround* GetBattleGroundTemplate(BattleGroundTypeId bgTypeId);
 201         BattleGround* CreateNewBattleGround(BattleGroundTypeId bgTypeId, BGQueueIdBasedOnLevel queue_id, uint8 arenaType, bool isRated);
 202
 203         uint32 CreateBattleGround(BattleGroundTypeId bgTypeId, bool IsArena, 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);
 204
 205         void AddBattleGround(uint32 InstanceID, BattleGroundTypeId bgTypeId, BattleGround* BG) { m_BattleGrounds[bgTypeId][InstanceID] = BG; };
 206         void RemoveBattleGround(uint32 instanceID, BattleGroundTypeId bgTypeId) { m_BattleGrounds[bgTypeId].erase(instanceID); }
 207         uint32 CreateClientVisibleInstanceId(BattleGroundTypeId bgTypeId, BGQueueIdBasedOnLevel queue_id);
 208
 209         void CreateInitialBattleGrounds();
 210         void DeleteAllBattleGrounds();
 211
 212         void SendToBattleGround(Player *pl, uint32 InstanceID, BattleGroundTypeId bgTypeId);
 213
 214         /* Battleground queues */
 215         //these queues are instantiated when creating BattlegroundMrg
 216         BattleGroundQueue m_BattleGroundQueues[MAX_BATTLEGROUND_QUEUE_TYPES]; // public, because we need to access them in BG handler code
 217
 218         BGFreeSlotQueueType BGFreeSlotQueue[MAX_BATTLEGROUND_TYPE_ID];
 219
 220         void ScheduleQueueUpdate(BattleGroundQueueTypeId bgQueueTypeId, BattleGroundTypeId bgTypeId, BGQueueIdBasedOnLevel queue_id);
 221         uint32 GetMaxRatingDifference() const;
 222         uint32 GetRatingDiscardTimer()  const;
 223         uint32 GetPrematureFinishTime() const;
 224
 225         void InitAutomaticArenaPointDistribution();
 226         void DistributeArenaPoints();
 227         void ToggleArenaTesting();
 228         void ToggleTesting();
 229
 230         void LoadBattleMastersEntry();
 231         BattleGroundTypeId GetBattleMasterBG(uint32 entry) const
 232         {
 233             BattleMastersMap::const_iterator itr = mBattleMastersMap.find(entry);
 234             if (itr != mBattleMastersMap.end())
 235                 return itr->second;
 236             return BATTLEGROUND_WS;
 237         }
 238
 239         bool isArenaTesting() const { return m_ArenaTesting; }
 240         bool isTesting() const { return m_Testing; }
 241
 242         static bool IsArenaType(BattleGroundTypeId bgTypeId);
 243         static bool IsBattleGroundType(BattleGroundTypeId bgTypeId) { return !BattleGroundMgr::IsArenaType(bgTypeId); }
 244         static BattleGroundQueueTypeId BGQueueTypeId(BattleGroundTypeId bgTypeId, uint8 arenaType);
 245         static BattleGroundTypeId BGTemplateId(BattleGroundQueueTypeId bgQueueTypeId);
 246         static uint8 BGArenaType(BattleGroundQueueTypeId bgQueueTypeId);
 247     private:
 248         BattleMastersMap    mBattleMastersMap;
 249
 250         /* Battlegrounds */
 251         BattleGroundSet m_BattleGrounds[MAX_BATTLEGROUND_TYPE_ID];
 252         std::vector<uint32>m_QueueUpdateScheduler;
 253         std::set<uint32> m_ClientBattleGroundIds[MAX_BATTLEGROUND_TYPE_ID][MAX_BATTLEGROUND_QUEUES]; //the instanceids just visible for the client
 254         uint32 m_NextRatingDiscardUpdate;
 255         time_t m_NextAutoDistributionTime;
 256         uint32 m_AutoDistributionTimeChecker;
 257         bool   m_ArenaTesting;
 258         bool   m_Testing;
 259 };
 260
 261 #define sBattleGroundMgr MaNGOS::Singleton<BattleGroundMgr>::Instance()
 262 #endif