Battleground.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 __BATTLEGROUND_H
#define __BATTLEGROUND_H

#include "ArenaScore.h"
#include "Common.h"
#include "SharedDefines.h"
#include "DBCEnums.h"
#include "WorldPacket.h"
#include "Object.h"
#include "GameObject.h"
#include "Packets/WorldStatePackets.h"
#include "Packets/BattlegroundPackets.h"
#include "EventMap.h"

class Creature;
class GameObject;
class Group;
class Player;
class Unit;
class WorldObject;
class WorldPacket;
class BattlegroundMap;

struct PvPDifficultyEntry;
struct WorldSafeLocsEntry;

enum BattlegroundCriteriaId
{
 BG_CRITERIA_CHECK_RESILIENT_VICTORY,
 BG_CRITERIA_CHECK_SAVE_THE_DAY,
 BG_CRITERIA_CHECK_EVERYTHING_COUNTS,
 BG_CRITERIA_CHECK_AV_PERFECTION,
 BG_CRITERIA_CHECK_DEFENSE_OF_THE_ANCIENTS,
 BG_CRITERIA_CHECK_NOT_EVEN_A_SCRATCH,
};

enum BattlegroundSounds
{
 SOUND_HORDE_WINS = 8454,
 SOUND_ALLIANCE_WINS = 8455,
 SOUND_BG_START = 3439,
 SOUND_BG_START_L70ETC = 11803
};

enum BattlegroundQuests
{
 SPELL_WS_QUEST_REWARD = 43483,
 SPELL_AB_QUEST_REWARD = 43484,
 SPELL_AV_QUEST_REWARD = 43475,
 SPELL_AV_QUEST_KILLED_BOSS = 23658,
 SPELL_EY_QUEST_REWARD = 43477,
 SPELL_SA_QUEST_REWARD = 61213,
 SPELL_AB_QUEST_REWARD_4_BASES = 24061,
 SPELL_AB_QUEST_REWARD_5_BASES = 24064
};

enum BattlegroundMarks
{
 SPELL_WS_MARK_LOSER = 24950,
 SPELL_WS_MARK_WINNER = 24951,
 SPELL_AB_MARK_LOSER = 24952,
 SPELL_AB_MARK_WINNER = 24953,
 SPELL_AV_MARK_LOSER = 24954,
 SPELL_AV_MARK_WINNER = 24955,
 SPELL_SA_MARK_WINNER = 61160,
 SPELL_SA_MARK_LOSER = 61159,
 ITEM_AV_MARK_OF_HONOR = 20560,
 ITEM_WS_MARK_OF_HONOR = 20558,
 ITEM_AB_MARK_OF_HONOR = 20559,
 ITEM_EY_MARK_OF_HONOR = 29024,
 ITEM_SA_MARK_OF_HONOR = 42425
};

enum BattlegroundMarksCount
{
 ITEM_WINNER_COUNT = 3,
 ITEM_LOSER_COUNT = 1
};

enum BattlegroundCreatures
{
 BG_CREATURE_ENTRY_A_SPIRITGUIDE = 13116, // alliance
 BG_CREATURE_ENTRY_H_SPIRITGUIDE = 13117 // horde
};

enum BattlegroundSpells
{
 SPELL_WAITING_FOR_RESURRECT = 2584, // Waiting to Resurrect
 SPELL_SPIRIT_HEAL_CHANNEL = 22011, // Spirit Heal Channel
 SPELL_SPIRIT_HEAL = 22012, // Spirit Heal
 SPELL_RESURRECTION_VISUAL = 24171, // Resurrection Impact Visual
 SPELL_ARENA_PREPARATION = 32727, // use this one, 32728 not correct
 SPELL_PREPARATION = 44521, // Preparation
 SPELL_SPIRIT_HEAL_MANA = 44535, // Spirit Heal
 SPELL_RECENTLY_DROPPED_FLAG = 42792, // Recently Dropped Flag
 SPELL_AURA_PLAYER_INACTIVE = 43681, // Inactive
 SPELL_HONORABLE_DEFENDER_25Y = 68652, // +50% honor when standing at a capture point that you control, 25yards radius (added in 3.2)
 SPELL_HONORABLE_DEFENDER_60Y = 66157 // +50% honor when standing at a capture point that you control, 60yards radius (added in 3.2), probably for 40+ player battlegrounds
};

enum BattlegroundTimeIntervals
{
 CHECK_PLAYER_POSITION_INVERVAL = 1000, // ms
 RESURRECTION_INTERVAL = 30000, // ms
 //REMIND_INTERVAL = 10000, // ms
 INVITATION_REMIND_TIME = 20000, // ms
 INVITE_ACCEPT_WAIT_TIME = 90000, // ms
 TIME_AUTOCLOSE_BATTLEGROUND = 120000, // ms
 MAX_OFFLINE_TIME = 300, // secs
 RESPAWN_ONE_DAY = 86400, // secs
 RESPAWN_IMMEDIATELY = 0, // secs
 BUFF_RESPAWN_TIME = 180, // secs
 BATTLEGROUND_COUNTDOWN_MAX = 120, // secs
 ARENA_COUNTDOWN_MAX = 60, // secs
 PLAYER_POSITION_UPDATE_INTERVAL = 5 // secs
};

enum BattlegroundStartTimeIntervals
{
 BG_START_DELAY_2M = 120000, // ms (2 minutes)
 BG_START_DELAY_1M = 60000, // ms (1 minute)
 BG_START_DELAY_30S = 30000, // ms (30 seconds)
 BG_START_DELAY_15S = 15000, // ms (15 seconds) Used only in arena
 BG_START_DELAY_NONE = 0 // ms
};

enum BattlegroundBuffObjects
{
 BG_OBJECTID_SPEEDBUFF_ENTRY = 179871,
 BG_OBJECTID_REGENBUFF_ENTRY = 179904,
 BG_OBJECTID_BERSERKERBUFF_ENTRY = 179905
};

uint32 const Buff_Entries[3] = { BG_OBJECTID_SPEEDBUFF_ENTRY, BG_OBJECTID_REGENBUFF_ENTRY, BG_OBJECTID_BERSERKERBUFF_ENTRY };

enum BattlegroundStatus
{
 STATUS_NONE = 0, // first status, should mean bg is not instance
 STATUS_WAIT_QUEUE = 1, // means bg is empty and waiting for queue
 STATUS_WAIT_JOIN = 2, // this means, that BG has already started and it is waiting for more players
 STATUS_IN_PROGRESS = 3, // means bg is running
 STATUS_WAIT_LEAVE = 4 // means some faction has won BG and it is ending
};

struct BattlegroundPlayer
{
 time_t OfflineRemoveTime; // for tracking and removing offline players from queue after 5 minutes
 uint32 Team; // Player's team
 int32 ActiveSpec; // Player's active spec
};

struct BattlegroundObjectInfo
{
 BattlegroundObjectInfo() : object(NULL), timer(0), spellid(0) { }

 GameObject *object;
 int32 timer;
 uint32 spellid;
};

enum ArenaType
{
 ARENA_TYPE_2v2 = 2,
 ARENA_TYPE_3v3 = 3,
 ARENA_TYPE_5v5 = 5
};

enum BattlegroundStartingEvents
{
 BG_STARTING_EVENT_NONE = 0x00,
 BG_STARTING_EVENT_1 = 0x01,
 BG_STARTING_EVENT_2 = 0x02,
 BG_STARTING_EVENT_3 = 0x04,
 BG_STARTING_EVENT_4 = 0x08
};

enum BattlegroundStartingEventsIds
{
 BG_STARTING_EVENT_FIRST = 0,
 BG_STARTING_EVENT_SECOND = 1,
 BG_STARTING_EVENT_THIRD = 2,
 BG_STARTING_EVENT_FOURTH = 3
};
#define BG_STARTING_EVENT_COUNT 4

enum BGHonorMode
{
 BG_NORMAL = 0,
 BG_HOLIDAY,
 BG_HONOR_MODE_NUM
};

#define BG_AWARD_ARENA_POINTS_MIN_LEVEL 71
#define ARENA_TIMELIMIT_POINTS_LOSS -16

enum BattlegroundPlayerPositionConstants
{
 PLAYER_POSITION_ICON_NONE = 0,
 PLAYER_POSITION_ICON_HORDE_FLAG = 1,
 PLAYER_POSITION_ICON_ALLIANCE_FLAG = 2,

 PLAYER_POSITION_ARENA_SLOT_NONE = 1,
 PLAYER_POSITION_ARENA_SLOT_1 = 2,
 PLAYER_POSITION_ARENA_SLOT_2 = 3,
 PLAYER_POSITION_ARENA_SLOT_3 = 4,
 PLAYER_POSITION_ARENA_SLOT_4 = 5,
 PLAYER_POSITION_ARENA_SLOT_5 = 6
};

/*
This class is used to:
1. Add player to battleground
2. Remove player from battleground
3. some certain cases, same for all battlegrounds
4. It has properties same for all battlegrounds
*/
class TC_GAME_API Battleground
{
 public:
 Battleground();
 virtual ~Battleground();

 void Update(uint32 diff);

 virtual bool SetupBattleground() // must be implemented in BG subclass
 {
 return true;
 }
 virtual void Reset(); // resets all common properties for battlegrounds, must be implemented and called in BG subclass
 virtual void StartingEventCloseDoors() { }
 virtual void StartingEventOpenDoors() { }
 virtual void ResetBGSubclass() { } // must be implemented in BG subclass

 virtual void DestroyGate(Player* /*player*/, GameObject* /*go*/) { }

 /* achievement req. */
 virtual bool IsAllNodesControlledByTeam(uint32 /*team*/) const { return false; }
 void StartTimedAchievement(AchievementCriteriaTimedTypes type, uint32 entry);
 virtual bool CheckAchievementCriteriaMeet(uint32 /*criteriaId*/, Player const* /*player*/, Unit const* /*target*/ = NULL, uint32 /*miscvalue1*/ = 0);

 /* Battleground */
 // Get methods:
 std::string const& GetName() const { return m_Name; }
 uint64 GetQueueId() const { return m_queueId; }
 BattlegroundTypeId GetTypeID(bool GetRandom = false) const { return GetRandom ? m_RandomTypeID : m_TypeID; }
 BattlegroundBracketId GetBracketId() const { return m_BracketId; }
 uint32 GetInstanceID() const { return m_InstanceID; }
 BattlegroundStatus GetStatus() const { return m_Status; }
 uint32 GetClientInstanceID() const { return m_ClientInstanceID; }
 uint32 GetElapsedTime() const { return m_StartTime; }
 uint32 GetRemainingTime() const { return m_EndTime; }
 uint32 GetLastResurrectTime() const { return m_LastResurrectTime; }
 uint32 GetMaxPlayers() const { return m_MaxPlayers; }
 uint32 GetMinPlayers() const { return m_MinPlayers; }

 uint32 GetMinLevel() const { return m_LevelMin; }
 uint32 GetMaxLevel() const { return m_LevelMax; }

 uint32 GetMaxPlayersPerTeam() const { return m_MaxPlayersPerTeam; }
 uint32 GetMinPlayersPerTeam() const { return m_MinPlayersPerTeam; }

 int32 GetStartDelayTime() const { return m_StartDelayTime; }
 uint8 GetArenaType() const { return m_ArenaType; }
 BattlegroundTeamId GetWinner() const { return _winnerTeamId; }
 uint32 GetScriptId() const { return ScriptId; }
 uint32 GetBonusHonorFromKill(uint32 kills) const;
 bool IsRandom() const { return m_IsRandom; }

 // Set methods:
 void SetQueueId(uint64 queueId) { m_queueId = queueId; }
 void SetName(std::string const& name) { m_Name = name; }
 void SetTypeID(BattlegroundTypeId TypeID) { m_TypeID = TypeID; }
 void SetRandomTypeID(BattlegroundTypeId TypeID) { m_RandomTypeID = TypeID; }
 //here we can count minlevel and maxlevel for players
 void SetBracket(PvPDifficultyEntry const* bracketEntry);
 void SetInstanceID(uint32 InstanceID) { m_InstanceID = InstanceID; }
 void SetStatus(BattlegroundStatus Status) { m_Status = Status; }
 void SetClientInstanceID(uint32 InstanceID) { m_ClientInstanceID = InstanceID; }
 void SetElapsedTime(uint32 Time) { m_StartTime = Time; }
 void SetRemainingTime(uint32 Time) { m_EndTime = Time; }
 void SetLastResurrectTime(uint32 Time) { m_LastResurrectTime = Time; }
 void SetMaxPlayers(uint32 MaxPlayers) { m_MaxPlayers = MaxPlayers; }
 void SetMinPlayers(uint32 MinPlayers) { m_MinPlayers = MinPlayers; }
 void SetLevelRange(uint32 min, uint32 max) { m_LevelMin = min; m_LevelMax = max; }
 void SetRated(bool state) { m_IsRated = state; }
 void SetArenaType(uint8 type) { m_ArenaType = type; }
 void SetArenaorBGType(bool _isArena) { m_IsArena = _isArena; }
 void SetWinner(BattlegroundTeamId winnerTeamId) { _winnerTeamId = winnerTeamId; }
 void SetScriptId(uint32 scriptId) { ScriptId = scriptId; }

 void ModifyStartDelayTime(int diff) { m_StartDelayTime -= diff; }
 void SetStartDelayTime(int Time) { m_StartDelayTime = Time; }

 void SetMaxPlayersPerTeam(uint32 MaxPlayers) { m_MaxPlayersPerTeam = MaxPlayers; }
 void SetMinPlayersPerTeam(uint32 MinPlayers) { m_MinPlayersPerTeam = MinPlayers; }

 void AddToBGFreeSlotQueue(); //this queue will be useful when more battlegrounds instances will be available
 void RemoveFromBGFreeSlotQueue(); //this method could delete whole BG instance, if another free is available

 void DecreaseInvitedCount(uint32 team) { (team == ALLIANCE) ? --m_InvitedAlliance : --m_InvitedHorde; }
 void IncreaseInvitedCount(uint32 team) { (team == ALLIANCE) ? ++m_InvitedAlliance : ++m_InvitedHorde; }

 void SetRandom(bool isRandom) { m_IsRandom = isRandom; }
 uint32 GetInvitedCount(uint32 team) const { return (team == ALLIANCE) ? m_InvitedAlliance : m_InvitedHorde; }
 bool HasFreeSlots() const;
 uint32 GetFreeSlotsForTeam(uint32 Team) const;

 bool isArena() const { return m_IsArena; }
 bool isBattleground() const { return !m_IsArena; }
 bool isRated() const { return m_IsRated; }

 typedef std::map<ObjectGuid, BattlegroundPlayer> BattlegroundPlayerMap;
 BattlegroundPlayerMap const& GetPlayers() const { return m_Players; }
 uint32 GetPlayersSize() const { return uint32(m_Players.size()); }

 typedef std::map<ObjectGuid, BattlegroundScore*> BattlegroundScoreMap;
 uint32 GetPlayerScoresSize() const { return uint32(PlayerScores.size()); }

 uint32 GetReviveQueueSize() const { return uint32(m_ReviveQueue.size()); }

 void AddPlayerToResurrectQueue(ObjectGuid npc_guid, ObjectGuid player_guid);
 void RemovePlayerFromResurrectQueue(ObjectGuid player_guid);

 void RelocateDeadPlayers(ObjectGuid guideGuid);

 void StartBattleground();

 GameObject* GetBGObject(uint32 type, bool logError = true);
 Creature* GetBGCreature(uint32 type, bool logError = true);

 // Location
 void SetMapId(uint32 MapID) { m_MapId = MapID; }
 uint32 GetMapId() const { return m_MapId; }

 // Map pointers
 void SetBgMap(BattlegroundMap* map) { m_Map = map; }
 BattlegroundMap* GetBgMap() const { ASSERT(m_Map); return m_Map; }
 BattlegroundMap* FindBgMap() const { return m_Map; }

 void SetTeamStartPosition(TeamId teamId, Position const& pos);
 Position const* GetTeamStartPosition(TeamId teamId) const;

 void SetStartMaxDist(float startMaxDist) { m_StartMaxDist = startMaxDist; }
 float GetStartMaxDist() const { return m_StartMaxDist; }

 // Packet Transfer
 // method that should fill worldpacket with actual world states (not yet implemented for all battlegrounds!)
 virtual void FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& /*data*/) { }
 void SendPacketToTeam(uint32 TeamID, WorldPacket const* packet, Player* sender = NULL, bool self = true) const;
 void SendPacketToAll(WorldPacket const* packet) const;

 void SendChatMessage(Creature* source, uint8 textId, WorldObject* target = NULL);

 template<class Do>
 void BroadcastWorker(Do& _do);

 void PlaySoundToTeam(uint32 SoundID, uint32 TeamID);
 void PlaySoundToAll(uint32 SoundID);
 void CastSpellOnTeam(uint32 SpellID, uint32 TeamID);
 void RemoveAuraOnTeam(uint32 SpellID, uint32 TeamID);
 void RewardHonorToTeam(uint32 Honor, uint32 TeamID);
 void RewardReputationToTeam(uint32 faction_id, uint32 Reputation, uint32 TeamID);
 void UpdateWorldState(uint32 variable, uint32 value, bool hidden = false);
 virtual void EndBattleground(uint32 winner);
 void BlockMovement(Player* player);

 void SendMessageToAll(uint32 entry, ChatMsg type, Player const* source = NULL);
 void PSendMessageToAll(uint32 entry, ChatMsg type, Player const* source, ...);

 // specialized version with 2 string id args
 void SendMessage2ToAll(uint32 entry, ChatMsg type, Player const* source, uint32 strId1 = 0, uint32 strId2 = 0);

 // Raid Group
 Group* GetBgRaid(uint32 TeamID) const { return TeamID == ALLIANCE ? m_BgRaids[TEAM_ALLIANCE] : m_BgRaids[TEAM_HORDE]; }
 void SetBgRaid(uint32 TeamID, Group* bg_raid);

 void BuildPvPLogDataPacket(WorldPackets::Battleground::PVPLogData& pvpLogData);
 virtual bool UpdatePlayerScore(Player* player, uint32 type, uint32 value, bool doAddHonor = true);

 static TeamId GetTeamIndexByTeamId(uint32 Team) { return Team == ALLIANCE ? TEAM_ALLIANCE : TEAM_HORDE; }
 uint32 GetPlayersCountByTeam(uint32 Team) const { return m_PlayersCount[GetTeamIndexByTeamId(Team)]; }
 uint32 GetAlivePlayersCountByTeam(uint32 Team) const; // used in arenas to correctly handle death in spirit of redemption / last stand etc. (killer = killed) cases
 void UpdatePlayersCountByTeam(uint32 Team, bool remove)
 {
 if (remove)
 --m_PlayersCount[GetTeamIndexByTeamId(Team)];
 else
 ++m_PlayersCount[GetTeamIndexByTeamId(Team)];
 }

 virtual void CheckWinConditions() { }

 // used for rated arena battles
 void SetArenaTeamIdForTeam(uint32 Team, uint32 ArenaTeamId) { m_ArenaTeamIds[GetTeamIndexByTeamId(Team)] = ArenaTeamId; }
 uint32 GetArenaTeamIdForTeam(uint32 Team) const { return m_ArenaTeamIds[GetTeamIndexByTeamId(Team)]; }
 uint32 GetArenaTeamIdByIndex(uint32 index) const { return m_ArenaTeamIds[index]; }
 void SetArenaMatchmakerRating(uint32 Team, uint32 MMR){ m_ArenaTeamMMR[GetTeamIndexByTeamId(Team)] = MMR; }
 uint32 GetArenaMatchmakerRating(uint32 Team) const { return m_ArenaTeamMMR[GetTeamIndexByTeamId(Team)]; }

 // Triggers handle
 // must be implemented in BG subclass
 virtual void HandleAreaTrigger(Player* /*player*/, uint32 /*trigger*/, bool /*entered*/);
 // must be implemented in BG subclass if need AND call base class generic code
 virtual void HandleKillPlayer(Player* player, Player* killer);
 virtual void HandleKillUnit(Creature* /*creature*/, Player* /*killer*/) { }

 // Battleground events
 virtual void EventPlayerDroppedFlag(Player* /*player*/) { }
 virtual void EventPlayerClickedOnFlag(Player* /*player*/, GameObject* /*target_obj*/) { }
 void EventPlayerLoggedIn(Player* player);
 void EventPlayerLoggedOut(Player* player);
 virtual void ProcessEvent(WorldObject* /*obj*/, uint32 /*eventId*/, WorldObject* /*invoker*/ = NULL) { }

 // this function can be used by spell to interact with the BG map
 virtual void DoAction(uint32 /*action*/, ObjectGuid /*var*/) { }

 virtual void HandlePlayerResurrect(Player* /*player*/) { }

 // Death related
 virtual WorldSafeLocsEntry const* GetClosestGraveYard(Player* player);

 virtual void AddPlayer(Player* player); // must be implemented in BG subclass

 void AddOrSetPlayerToCorrectBgGroup(Player* player, uint32 team);

 virtual void RemovePlayerAtLeave(ObjectGuid guid, bool Transport, bool SendPacket);
 // can be extended in in BG subclass

 void HandleTriggerBuff(ObjectGuid go_guid);
 void SetHoliday(bool is_holiday);

 GuidVector BgObjects;
 GuidVector BgCreatures;
 void SpawnBGObject(uint32 type, uint32 respawntime);
 virtual bool AddObject(uint32 type, uint32 entry, float x, float y, float z, float o, float rotation0, float rotation1, float rotation2, float rotation3, uint32 respawnTime = 0, GOState goState = GO_STATE_READY);
 bool AddObject(uint32 type, uint32 entry, Position const& pos, float rotation0, float rotation1, float rotation2, float rotation3, uint32 respawnTime = 0, GOState goState = GO_STATE_READY);
 virtual Creature* AddCreature(uint32 entry, uint32 type, float x, float y, float z, float o, TeamId teamId = TEAM_NEUTRAL, uint32 respawntime = 0, Transport* transport = NULL);
 Creature* AddCreature(uint32 entry, uint32 type, Position const& pos, TeamId teamId = TEAM_NEUTRAL, uint32 respawntime = 0, Transport* transport = NULL);
 bool DelCreature(uint32 type);
 bool DelObject(uint32 type);
 virtual bool AddSpiritGuide(uint32 type, float x, float y, float z, float o, TeamId teamId = TEAM_NEUTRAL);
 bool AddSpiritGuide(uint32 type, Position const& pos, TeamId teamId = TEAM_NEUTRAL);
 int32 GetObjectType(ObjectGuid guid);

 void DoorOpen(uint32 type);
 void DoorClose(uint32 type);

 virtual bool HandlePlayerUnderMap(Player* /*player*/) { return false; }

 // since arenas can be AvA or Hvh, we have to get the "temporary" team of a player
 uint32 GetPlayerTeam(ObjectGuid guid) const;
 uint32 GetOtherTeam(uint32 teamId) const;
 bool IsPlayerInBattleground(ObjectGuid guid) const;

 bool ToBeDeleted() const { return m_SetDeleteThis; }
 void SetDeleteThis() { m_SetDeleteThis = true; }

 void RewardXPAtKill(Player* killer, Player* victim);
 bool CanAwardArenaPoints() const { return m_LevelMin >= BG_AWARD_ARENA_POINTS_MIN_LEVEL; }

 virtual ObjectGuid GetFlagPickerGUID(int32 /*team*/ = -1) const { return ObjectGuid::Empty; }
 virtual void SetDroppedFlagGUID(ObjectGuid /*guid*/, int32 /*team*/ = -1) { }
 virtual void HandleQuestComplete(uint32 /*questid*/, Player* /*player*/) { }
 virtual bool CanActivateGO(int32 /*entry*/, uint32 /*team*/) const { return true; }
 virtual bool IsSpellAllowed(uint32 /*spellId*/, Player const* /*player*/) const { return true; }
 uint32 GetTeamScore(uint32 TeamID) const;

 virtual uint32 GetPrematureWinner();

 // because BattleGrounds with different types and same level range has different m_BracketId
 uint8 GetUniqueBracketId() const;

 protected:
 // this method is called, when BG cannot spawn its own spirit guide, or something is wrong, It correctly ends Battleground
 void EndNow();
 void PlayerAddedToBGCheckIfBGIsRunning(Player* player);

 Player* _GetPlayer(ObjectGuid guid, bool offlineRemove, const char* context) const;
 Player* _GetPlayer(BattlegroundPlayerMap::iterator itr, const char* context) { return _GetPlayer(itr->first, itr->second.OfflineRemoveTime != 0, context); }
 Player* _GetPlayer(BattlegroundPlayerMap::const_iterator itr, const char* context) const { return _GetPlayer(itr->first, itr->second.OfflineRemoveTime != 0, context); }
 Player* _GetPlayerForTeam(uint32 teamId, BattlegroundPlayerMap::const_iterator itr, const char* context) const;

 /* Pre- and post-update hooks */

 virtual bool PreUpdateImpl(uint32 /* diff */) { return true; }

 virtual void PostUpdateImpl(uint32 /* diff */) { }

 void _ProcessOfflineQueue();
 void _ProcessResurrect(uint32 diff);
 void _ProcessProgress(uint32 diff);
 void _ProcessLeave(uint32 diff);
 void _ProcessJoin(uint32 diff);
 void _CheckSafePositions(uint32 diff);
 void _ProcessPlayerPositionBroadcast(uint32 diff);
 virtual void GetPlayerPositionData(std::vector<WorldPackets::Battleground::BattlegroundPlayerPosition>* /*positions*/) const { }

 // Scorekeeping
 BattlegroundScoreMap PlayerScores; // Player scores
 // must be implemented in BG subclass
 virtual void RemovePlayer(Player* /*player*/, ObjectGuid /*guid*/, uint32 /*team*/) { }

 // Player lists, those need to be accessible by inherited classes
 BattlegroundPlayerMap m_Players;
 // Spirit Guide guid + Player list GUIDS
 std::map<ObjectGuid, GuidVector> m_ReviveQueue;

 // these are important variables used for starting messages
 uint8 m_Events;
 BattlegroundStartTimeIntervals StartDelayTimes[BG_STARTING_EVENT_COUNT];
 // this must be filled in constructors!
 uint32 StartMessageIds[BG_STARTING_EVENT_COUNT];

 bool m_BuffChange;
 bool m_IsRandom;

 BGHonorMode m_HonorMode;
 int32 m_TeamScores[BG_TEAMS_COUNT];

 ArenaTeamScore _arenaTeamScores[BG_TEAMS_COUNT];

 private:
 // Battleground
 BattlegroundTypeId m_TypeID;
 BattlegroundTypeId m_RandomTypeID;
 uint32 m_InstanceID; // Battleground Instance's GUID!
 BattlegroundStatus m_Status;
 uint32 m_ClientInstanceID; // the instance-id which is sent to the client and without any other internal use
 uint32 m_StartTime;
 uint32 m_CountdownTimer;
 uint32 m_ResetStatTimer;
 uint32 m_ValidStartPositionTimer;
 int32 m_EndTime; // it is set to 120000 when bg is ending and it decreases itself
 uint32 m_LastResurrectTime;
 BattlegroundBracketId m_BracketId;
 uint8 m_ArenaType; // 2=2v2, 3=3v3, 5=5v5
 bool m_InBGFreeSlotQueue; // used to make sure that BG is only once inserted into the BattlegroundMgr.BGFreeSlotQueue[bgTypeId] deque
 bool m_SetDeleteThis; // used for safe deletion of the bg after end / all players leave
 bool m_IsArena;
 BattlegroundTeamId _winnerTeamId;
 int32 m_StartDelayTime;
 bool m_IsRated; // is this battle rated?
 bool m_PrematureCountDown;
 uint32 m_PrematureCountDownTimer;
 std::string m_Name;
 uint64 m_queueId;
 uint32 m_LastPlayerPositionBroadcast;

 // Player lists
 GuidVector m_ResurrectQueue; // Player GUID
 GuidDeque m_OfflineQueue; // Player GUID

 // Invited counters are useful for player invitation to BG - do not allow, if BG is started to one faction to have 2 more players than another faction
 // Invited counters will be changed only when removing already invited player from queue, removing player from battleground and inviting player to BG
 // Invited players counters
 uint32 m_InvitedAlliance;
 uint32 m_InvitedHorde;

 // Raid Group
 Group* m_BgRaids[BG_TEAMS_COUNT]; // 0 - alliance, 1 - horde

 // Players count by team
 uint32 m_PlayersCount[BG_TEAMS_COUNT];

 // Arena team ids by team
 uint32 m_ArenaTeamIds[BG_TEAMS_COUNT];

 uint32 m_ArenaTeamMMR[BG_TEAMS_COUNT];

 // Limits
 uint32 m_LevelMin;
 uint32 m_LevelMax;
 uint32 m_MaxPlayersPerTeam;
 uint32 m_MaxPlayers;
 uint32 m_MinPlayersPerTeam;
 uint32 m_MinPlayers;

 // Start location
 uint32 m_MapId;
 BattlegroundMap* m_Map;
 Position StartPosition[BG_TEAMS_COUNT];
 float m_StartMaxDist;
 uint32 ScriptId;
};
#endif