BattlegroundMgr.h

Go to the documentation of this file.

/*
 * Copyright (C) 2008-2016 TrinityCore <http://www.trinitycore.org/>
 * Copyright (C) 2005-2009 MaNGOS <http://getmangos.com/>
 *
 * 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 __BATTLEGROUNDMGR_H
#define __BATTLEGROUNDMGR_H

#include "Common.h"
#include "DBCEnums.h"
#include "Battleground.h"
#include "BattlegroundQueue.h"

typedef std::map<uint32, Battleground*> BattlegroundContainer;
typedef std::set<uint32> BattlegroundClientIdsContainer;

typedef std::unordered_map<uint32, BattlegroundTypeId> BattleMastersMap;

#define WS_CURRENCY_RESET_TIME 20001 // Custom worldstate

struct BattlegroundData
{
 BattlegroundContainer m_Battlegrounds;
 BattlegroundClientIdsContainer m_ClientBattlegroundIds[MAX_BATTLEGROUND_BRACKETS];
 BGFreeSlotQueueContainer BGFreeSlotQueue;
};

struct BattlegroundTemplate
{
 BattlegroundTypeId Id;
 uint16 MinPlayersPerTeam;
 uint16 MaxPlayersPerTeam;
 uint8 MinLevel;
 uint8 MaxLevel;
 Position StartLocation[BG_TEAMS_COUNT];
 float MaxStartDistSq;
 uint8 Weight;
 uint32 ScriptId;
 BattlemasterListEntry const* BattlemasterEntry;

 bool IsArena() const { return BattlemasterEntry->InstanceType == MAP_ARENA; }
};

namespace WorldPackets
{
 namespace Battleground
 {
 struct BattlefieldStatusHeader;
 class BattlefieldStatusNone;
 class BattlefieldStatusNeedConfirmation;
 class BattlefieldStatusActive;
 class BattlefieldStatusQueued;
 class BattlefieldStatusFailed;
 }
}

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

 public:
 static BattlegroundMgr* instance();

 void Update(uint32 diff);

 /* Packet Building */
 void SendBattlegroundList(Player* player, ObjectGuid const& guid, BattlegroundTypeId bgTypeId);
 void BuildBattlegroundStatusHeader(WorldPackets::Battleground::BattlefieldStatusHeader* battlefieldStatus, Battleground* bg, Player* player, uint32 ticketId, uint32 joinTime, uint32 arenaType);
 void BuildBattlegroundStatusNone(WorldPackets::Battleground::BattlefieldStatusNone* battlefieldStatus, Player* player, uint32 ticketId, uint32 joinTime, uint32 arenaType);
 void BuildBattlegroundStatusNeedConfirmation(WorldPackets::Battleground::BattlefieldStatusNeedConfirmation* battlefieldStatus, Battleground* bg, Player* player, uint32 ticketId, uint32 joinTime, uint32 timeout, uint32 arenaType);
 void BuildBattlegroundStatusActive(WorldPackets::Battleground::BattlefieldStatusActive* battlefieldStatus, Battleground* bg, Player* player, uint32 ticketId, uint32 joinTime, uint32 arenaType);
 void BuildBattlegroundStatusQueued(WorldPackets::Battleground::BattlefieldStatusQueued* battlefieldStatus, Battleground* bg, Player* player, uint32 ticketId, uint32 joinTime, uint32 avgWaitTime, uint32 arenaType, bool asGroup);
 void BuildBattlegroundStatusFailed(WorldPackets::Battleground::BattlefieldStatusFailed* battlefieldStatus, Battleground* bg, Player* pPlayer, uint32 ticketId, uint32 arenaType, GroupJoinBattlegroundResult result, ObjectGuid const* errorGuid = nullptr);
 void SendAreaSpiritHealerQueryOpcode(Player* player, Battleground* bg, ObjectGuid const& guid);

 /* Battlegrounds */
 Battleground* GetBattleground(uint32 InstanceID, BattlegroundTypeId bgTypeId);
 Battleground* GetBattlegroundTemplate(BattlegroundTypeId bgTypeId);
 Battleground* CreateNewBattleground(BattlegroundTypeId bgTypeId, PvPDifficultyEntry const* bracketEntry, uint8 arenaType, bool isRated);

 void AddBattleground(Battleground* bg);
 void RemoveBattleground(BattlegroundTypeId bgTypeId, uint32 instanceId);
 void AddToBGFreeSlotQueue(BattlegroundTypeId bgTypeId, Battleground* bg);
 void RemoveFromBGFreeSlotQueue(BattlegroundTypeId bgTypeId, uint32 instanceId);
 BGFreeSlotQueueContainer& GetBGFreeSlotQueueStore(BattlegroundTypeId bgTypeId);

 void LoadBattlegroundTemplates();
 void DeleteAllBattlegrounds();

 void SendToBattleground(Player* player, uint32 InstanceID, BattlegroundTypeId bgTypeId);

 /* Battleground queues */
 BattlegroundQueue& GetBattlegroundQueue(BattlegroundQueueTypeId bgQueueTypeId) { return m_BattlegroundQueues[bgQueueTypeId]; }
 void ScheduleQueueUpdate(uint32 arenaMatchmakerRating, uint8 arenaType, BattlegroundQueueTypeId bgQueueTypeId, BattlegroundTypeId bgTypeId, BattlegroundBracketId bracket_id);
 uint32 GetPrematureFinishTime() const;

 void ToggleArenaTesting();
 void ToggleTesting();

 void SetHolidayWeekends(uint32 mask);

 bool isArenaTesting() const { return m_ArenaTesting; }
 bool isTesting() const { return m_Testing; }

 static BattlegroundQueueTypeId BGQueueTypeId(BattlegroundTypeId bgTypeId, uint8 arenaType);
 static BattlegroundTypeId BGTemplateId(BattlegroundQueueTypeId bgQueueTypeId);
 static uint8 BGArenaType(BattlegroundQueueTypeId bgQueueTypeId);

 static HolidayIds BGTypeToWeekendHolidayId(BattlegroundTypeId bgTypeId);
 static BattlegroundTypeId WeekendHolidayIdToBGType(HolidayIds holiday);
 static bool IsBGWeekend(BattlegroundTypeId bgTypeId);

 uint32 GetMaxRatingDifference() const;
 uint32 GetRatingDiscardTimer() const;
 void LoadBattleMastersEntry();
 void CheckBattleMasters();
 BattlegroundTypeId GetBattleMasterBG(uint32 entry) const
 {
 BattleMastersMap::const_iterator itr = mBattleMastersMap.find(entry);
 if (itr != mBattleMastersMap.end())
 return itr->second;
 return BATTLEGROUND_TYPE_NONE;
 }

 private:
 bool CreateBattleground(BattlegroundTemplate const* bgTemplate);
 uint32 CreateClientVisibleInstanceId(BattlegroundTypeId bgTypeId, BattlegroundBracketId bracket_id);
 static bool IsArenaType(BattlegroundTypeId bgTypeId);
 BattlegroundTypeId GetRandomBG(BattlegroundTypeId id);

 typedef std::map<BattlegroundTypeId, BattlegroundData> BattlegroundDataContainer;
 BattlegroundDataContainer bgDataStore;

 BattlegroundQueue m_BattlegroundQueues[MAX_BATTLEGROUND_QUEUE_TYPES];

 std::vector<uint64> m_QueueUpdateScheduler;
 uint32 m_NextRatedArenaUpdate;
 bool m_ArenaTesting;
 bool m_Testing;
 BattleMastersMap mBattleMastersMap;

 BattlegroundTemplate const* GetBattlegroundTemplateByTypeId(BattlegroundTypeId id)
 {
 BattlegroundTemplateMap::const_iterator itr = _battlegroundTemplates.find(id);
 if (itr != _battlegroundTemplates.end())
 return &itr->second;
 return nullptr;
 }

 BattlegroundTemplate const* GetBattlegroundTemplateByMapId(uint32 mapId)
 {
 BattlegroundMapTemplateContainer::const_iterator itr = _battlegroundMapTemplates.find(mapId);
 if (itr != _battlegroundMapTemplates.end())
 return itr->second;
 return nullptr;
 }

 typedef std::map<BattlegroundTypeId, uint8 /*weight*/> BattlegroundSelectionWeightMap;

 typedef std::map<BattlegroundTypeId, BattlegroundTemplate> BattlegroundTemplateMap;
 typedef std::map<uint32 /*mapId*/, BattlegroundTemplate*> BattlegroundMapTemplateContainer;
 BattlegroundTemplateMap _battlegroundTemplates;
 BattlegroundMapTemplateContainer _battlegroundMapTemplates;
};

#define sBattlegroundMgr BattlegroundMgr::instance()

#endif // __BATTLEGROUNDMGR_H