#include "Battleground.h"

Inheritance diagram for Battleground:

Public Types
typedef std::set< Player * >	SpectatorList

typedef std::map< ObjectGuid, ObjectGuid >	ToBeTeleportedMap

typedef std::map< ObjectGuid, Player * >	BattlegroundPlayerMap

typedef std::unordered_map< ObjectGuid::LowType, BattlegroundScore * >	BattlegroundScoreMap

typedef std::unordered_map< ObjectGuid, ArenaLogEntryData >	ArenaLogEntryDataMap

typedef GuidVector	BGObjects

typedef GuidVector	BGCreatures

Public Member Functions
	Battleground ()

virtual	~Battleground ()

void	Update (uint32 diff)

virtual bool	SetupBattleground ()

virtual void	Init ()

virtual void	StartingEventCloseDoors ()

virtual void	StartingEventOpenDoors ()

virtual void	ResetBGSubclass ()

virtual void	DestroyGate (Player , GameObject )

virtual bool	AllNodesConrolledByTeam (TeamId) const

void	StartTimedAchievement (AchievementCriteriaTimedTypes type, uint32 entry)

std::string	GetName () const

BattlegroundTypeId	GetBgTypeID (bool GetRandom=false) const

BattlegroundBracketId	GetBracketId () const

uint32	GetInstanceID () const

BattlegroundStatus	GetStatus () const

uint32	GetClientInstanceID () const

uint32	GetStartTime () const

uint32	GetEndTime () const

uint32	GetLastResurrectTime () const

uint32	GetMinLevel () const

uint32	GetMaxLevel () const

bool	isTemplate () const

bool	isMaxLevel () const

uint32	GetMaxPlayersPerTeam () const

uint32	GetMinPlayersPerTeam () const

int32	GetStartDelayTime () const

uint8	GetArenaType () const

PvPTeamId	GetWinner () const

uint32	GetScriptId () const

uint32	GetBonusHonorFromKill (uint32 kills) const

void	SpiritOfCompetitionEvent (PvPTeamId winnerTeamId) const

bool	IsRandom ()

void	SetName (std::string_view name)

void	SetBgTypeID (BattlegroundTypeId TypeID)

void	SetRandomTypeID (BattlegroundTypeId TypeID)

void	SetBracket (PvPDifficultyEntry const *bracketEntry)

void	SetInstanceID (uint32 InstanceID)

void	SetStatus (BattlegroundStatus Status)

void	SetClientInstanceID (uint32 InstanceID)

void	SetStartTime (uint32 Time)

void	SetEndTime (uint32 Time)

void	SetLastResurrectTime (uint32 Time)

void	SetLevelRange (uint32 min, uint32 max)

void	SetRated (bool state)

void	SetArenaType (uint8 type)

void	SetArenaorBGType (bool _isArena)

void	SetWinner (PvPTeamId winner)

void	SetScriptId (uint32 scriptId)

void	SetRandom (bool isRandom)

void	ModifyStartDelayTime (int32 diff)

void	SetStartDelayTime (int32 Time)

void	SetMaxPlayersPerTeam (uint32 MaxPlayers)

void	SetMinPlayersPerTeam (uint32 MinPlayers)

void	AddToBGFreeSlotQueue ()

void	RemoveFromBGFreeSlotQueue ()

void	DecreaseInvitedCount (TeamId teamId)

void	IncreaseInvitedCount (TeamId teamId)

uint32	GetInvitedCount (TeamId teamId) const

bool	HasFreeSlots () const

uint32	GetFreeSlotsForTeam (TeamId teamId) const

uint32	GetMaxFreeSlots () const

void	AddSpectator (Player *p)

void	RemoveSpectator (Player *p)

bool	HaveSpectators ()

const SpectatorList &	GetSpectators () const

void	AddToBeTeleported (ObjectGuid spectator, ObjectGuid participant)

void	RemoveToBeTeleported (ObjectGuid spectator)

void	SpectatorsSendPacket (WorldPacket &data)

bool	isArena () const

bool	isBattleground () const

bool	isRated () const

BattlegroundPlayerMap const &	GetPlayers () const

uint32	GetPlayersSize () const

void	ReadyMarkerClicked (Player *p)

BattlegroundScoreMap const *	GetPlayerScores () const

std::size_t	GetPlayerScoresSize () const

uint32	GetReviveQueueSize () const

void	AddPlayerToResurrectQueue (ObjectGuid npc_guid, ObjectGuid player_guid)

void	RemovePlayerFromResurrectQueue (Player *player)

void	RelocateDeadPlayers (ObjectGuid queueIndex)
	Relocate all players in ReviveQueue to the closest graveyard.

void	StartBattleground ()

GameObject *	GetBGObject (uint32 type)

Creature *	GetBGCreature (uint32 type)

void	SetMapId (uint32 MapID)

uint32	GetMapId () const

void	SetBgMap (BattlegroundMap *map)

BattlegroundMap *	GetBgMap () const

BattlegroundMap *	FindBgMap () const

void	SetTeamStartPosition (TeamId teamId, Position const &pos)

Position const *	GetTeamStartPosition (TeamId teamId) const

void	SetStartMaxDist (float startMaxDist)

float	GetStartMaxDist () const

virtual void	FillInitialWorldStates (WorldPackets::WorldState::InitWorldStates &)

void	SendPacketToTeam (TeamId teamId, WorldPacket const packet, Player sender=nullptr, bool self=true)

void	SendPacketToAll (WorldPacket const *packet)

void	YellToAll (Creature creature, const char text, uint32 language)

void	SendChatMessage (Creature source, uint8 textId, WorldObject target=nullptr)

void	SendBroadcastText (uint32 id, ChatMsg msgType, WorldObject const *target=nullptr)

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

void	PlaySoundToAll (uint32 soundId)

void	CastSpellOnTeam (uint32 spellId, TeamId teamId)

void	RemoveAuraOnTeam (uint32 spellId, TeamId teamId)

void	RewardHonorToTeam (uint32 honor, TeamId teamId)

void	RewardReputationToTeam (uint32 factionId, uint32 reputation, TeamId teamId)

uint32	GetRealRepFactionForPlayer (uint32 factionId, Player *player)

void	UpdateWorldState (uint32 variable, uint32 value)

void	EndBattleground (PvPTeamId winnerTeamId)

virtual void	EndBattleground (TeamId winnerTeamId)

void	BlockMovement (Player *player)

Group *	GetBgRaid (TeamId teamId) const

void	SetBgRaid (TeamId teamId, Group *bg_raid)

void	BuildPvPLogDataPacket (WorldPacket &data)

virtual bool	UpdatePlayerScore (Player *player, uint32 type, uint32 value, bool doAddHonor=true)

uint32	GetPlayersCountByTeam (TeamId teamId) const

uint32	GetAlivePlayersCountByTeam (TeamId teamId) const

void	UpdatePlayersCountByTeam (TeamId teamId, bool remove)

virtual void	CheckWinConditions ()

void	SetArenaTeamIdForTeam (TeamId teamId, uint32 ArenaTeamId)

uint32	GetArenaTeamIdForTeam (TeamId teamId) const

void	SetArenaMatchmakerRating (TeamId teamId, uint32 MMR)

uint32	GetArenaMatchmakerRating (TeamId teamId) const

virtual void	HandleAreaTrigger (Player *, uint32)

virtual void	HandleKillPlayer (Player player, Player killer)

virtual void	HandleKillUnit (Creature , Player )

virtual void	EventPlayerDroppedFlag (Player *)

virtual void	EventPlayerClickedOnFlag (Player , GameObject )

virtual void	EventPlayerDamagedGO (Player , GameObject , uint32)

virtual void	EventPlayerUsedGO (Player , GameObject )

virtual void	DoAction (uint32, ObjectGuid)

virtual void	HandlePlayerResurrect (Player *)

virtual GraveyardStruct const *	GetClosestGraveyard (Player *player)

virtual void	AddPlayer (Player *player)

void	AddOrSetPlayerToCorrectBgGroup (Player *player, TeamId teamId)

virtual void	RemovePlayerAtLeave (Player *player)

void	HandleTriggerBuff (GameObject *gameObject)

void	SetHoliday (bool is_holiday)

void	SpawnBGObject (uint32 type, uint32 respawntime, uint32 forceRespawnDelay=0)

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)

Creature *	AddCreature (uint32 entry, uint32 type, float x, float y, float z, float o, uint32 respawntime=0, MotionTransport *transport=nullptr)

bool	DelCreature (uint32 type)

bool	DelObject (uint32 type)

bool	AddSpiritGuide (uint32 type, float x, float y, float z, float o, TeamId teamId)

int32	GetObjectType (ObjectGuid guid)

void	DoorOpen (uint32 type)

void	DoorClose (uint32 type)

virtual bool	HandlePlayerUnderMap (Player *)

bool	IsPlayerInBattleground (ObjectGuid guid) const

bool	ToBeDeleted () const

void	RewardXPAtKill (Player killer, Player victim)

virtual ObjectGuid	GetFlagPickerGUID (TeamId=TEAM_NEUTRAL) const

virtual void	SetDroppedFlagGUID (ObjectGuid, TeamId=TEAM_NEUTRAL)

uint32	GetTeamScore (TeamId teamId) const

virtual TeamId	GetPrematureWinner ()

uint8	GetUniqueBracketId () const

BattlegroundAV *	ToBattlegroundAV ()

BattlegroundAV const *	ToBattlegroundAV () const

BattlegroundWS *	ToBattlegroundWS ()

BattlegroundWS const *	ToBattlegroundWS () const

BattlegroundAB *	ToBattlegroundAB ()

BattlegroundAB const *	ToBattlegroundAB () const

BattlegroundNA *	ToBattlegroundNA ()

BattlegroundNA const *	ToBattlegroundNA () const

BattlegroundBE *	ToBattlegroundBE ()

BattlegroundBE const *	ToBattlegroundBE () const

BattlegroundEY *	ToBattlegroundEY ()

BattlegroundEY const *	ToBattlegroundEY () const

BattlegroundRL *	ToBattlegroundRL ()

BattlegroundRL const *	ToBattlegroundRL () const

BattlegroundSA *	ToBattlegroundSA ()

BattlegroundSA const *	ToBattlegroundSA () const

BattlegroundDS *	ToBattlegroundDS ()

BattlegroundDS const *	ToBattlegroundDS () const

BattlegroundRV *	ToBattlegroundRV ()

BattlegroundRV const *	ToBattlegroundRV () const

BattlegroundIC *	ToBattlegroundIC ()

BattlegroundIC const *	ToBattlegroundIC () const

Static Public Member Functions
static TeamId	GetOtherTeamId (TeamId teamId)

Public Attributes
GuidSet	readyMarkerClickedSet

ArenaLogEntryDataMap	ArenaLogEntries

BGObjects	BgObjects

BGCreatures	BgCreatures

Protected Member Functions
void	EndNow ()

void	PlayerAddedToBGCheckIfBGIsRunning (Player *player)

void	_ProcessResurrect (uint32 diff)

void	_ProcessProgress (uint32 diff)

void	_ProcessLeave (uint32 diff)

void	_ProcessJoin (uint32 diff)

void	_CheckSafePositions (uint32 diff)

virtual void	RemovePlayer (Player *)

Private Member Functions
virtual bool	PreUpdateImpl (uint32)
	Pre-update hook.

virtual void	PostUpdateImpl (uint32)
	Post-update hook.

Private Attributes
BattlegroundTypeId	m_RealTypeID

BattlegroundTypeId	m_RandomTypeID

uint32	m_InstanceID

BattlegroundStatus	m_Status

uint32	m_ClientInstanceID

uint32	m_StartTime

uint32	m_ResetStatTimer

uint32	m_ValidStartPositionTimer

int32	m_EndTime

uint32	m_LastResurrectTime

BattlegroundBracketId	m_BracketId { BG_BRACKET_ID_FIRST }

uint8	m_ArenaType

bool	_InBGFreeSlotQueue { false }

bool	m_SetDeleteThis

bool	m_IsArena

bool	m_IsTemplate

PvPTeamId	m_WinnerId

int32	m_StartDelayTime

bool	m_IsRated

bool	m_PrematureCountDown

uint32	m_PrematureCountDownTimer

std::string	m_Name {}

GuidVector	m_ResurrectQueue

GuidDeque	m_OfflineQueue

uint32	m_BgInvitedPlayers [PVP_TEAMS_COUNT]

Group *	m_BgRaids [PVP_TEAMS_COUNT]

SpectatorList	m_Spectators

ToBeTeleportedMap	m_ToBeTeleported

uint32	m_PlayersCount [PVP_TEAMS_COUNT]

uint32	m_ArenaTeamIds [PVP_TEAMS_COUNT]

uint32	m_ArenaTeamMMR [PVP_TEAMS_COUNT]

uint32	m_LevelMin

uint32	m_LevelMax

uint32	m_MaxPlayersPerTeam

uint32	m_MinPlayersPerTeam

uint32	m_MapId

BattlegroundMap *	m_Map

float	m_StartMaxDist

std::array< Position, PVP_TEAMS_COUNT >	_startPosition

uint32	ScriptId

Detailed Description

Member Typedef Documentation

◆ ArenaLogEntryDataMap

typedef std::unordered_map<ObjectGuid, ArenaLogEntryData> Battleground::ArenaLogEntryDataMap

◆ BattlegroundPlayerMap

typedef std::map<ObjectGuid, Player*> Battleground::BattlegroundPlayerMap

◆ BattlegroundScoreMap

typedef std::unordered_map<ObjectGuid::LowType, BattlegroundScore*> Battleground::BattlegroundScoreMap

◆ BGCreatures

typedef GuidVector Battleground::BGCreatures

◆ BGObjects

typedef GuidVector Battleground::BGObjects

Todo:: : make this protected:

◆ SpectatorList

typedef std::set<Player*> Battleground::SpectatorList

◆ ToBeTeleportedMap

typedef std::map<ObjectGuid, ObjectGuid> Battleground::ToBeTeleportedMap

Constructor & Destructor Documentation

◆ Battleground()

Battleground::Battleground ( )

{
    m_RealTypeID        = BATTLEGROUND_TYPE_NONE;
    m_RandomTypeID      = BATTLEGROUND_TYPE_NONE;
    m_InstanceID        = 0;
    m_Status            = STATUS_NONE;
    m_ClientInstanceID  = 0;
    m_EndTime           = 0;
    m_LastResurrectTime = 0;
    m_ArenaType         = 0;
    m_IsArena           = false;
    m_IsTemplate        = true;
    m_WinnerId          = PVP_TEAM_NEUTRAL;
    m_StartTime         = 0;
    m_ResetStatTimer    = 0;
    m_ValidStartPositionTimer = 0;
    m_Events            = 0;
    m_StartDelayTime    = 0;
    m_IsRated           = false;
    m_BuffChange        = false;
    m_IsRandom          = false;
    m_LevelMin          = 0;
    m_LevelMax          = 0;
    m_SetDeleteThis     = false;
 
    m_MaxPlayersPerTeam = 0;
    m_MinPlayersPerTeam = 0;
 
    m_MapId             = 0;
    m_Map               = nullptr;
    m_StartMaxDist      = 0.0f;
    ScriptId            = 0;
 
    m_ArenaTeamIds[TEAM_ALLIANCE]   = 0;
    m_ArenaTeamIds[TEAM_HORDE]      = 0;
 
    m_ArenaTeamMMR[TEAM_ALLIANCE]   = 0;
    m_ArenaTeamMMR[TEAM_HORDE]      = 0;
 
    m_BgRaids[TEAM_ALLIANCE]         = nullptr;
    m_BgRaids[TEAM_HORDE]            = nullptr;
 
    m_PlayersCount[TEAM_ALLIANCE]    = 0;
    m_PlayersCount[TEAM_HORDE]       = 0;
 
    m_BgInvitedPlayers[TEAM_ALLIANCE] = 0;
    m_BgInvitedPlayers[TEAM_HORDE]   = 0;
 
    m_TeamScores[TEAM_ALLIANCE]      = 0;
    m_TeamScores[TEAM_HORDE]         = 0;
 
    m_PrematureCountDown = false;
    m_PrematureCountDownTimer = 0;
 
    m_HonorMode = BG_NORMAL;
 
    m_SetupCompleted = false;
 
    StartDelayTimes[BG_STARTING_EVENT_FIRST]  = BG_START_DELAY_2M;
    StartDelayTimes[BG_STARTING_EVENT_SECOND] = BG_START_DELAY_1M;
    StartDelayTimes[BG_STARTING_EVENT_THIRD]  = BG_START_DELAY_30S;
    StartDelayTimes[BG_STARTING_EVENT_FOURTH] = BG_START_DELAY_NONE;
 
    StartMessageIds[BG_STARTING_EVENT_FIRST] = BG_TEXT_START_TWO_MINUTES;
    StartMessageIds[BG_STARTING_EVENT_SECOND] = BG_TEXT_START_ONE_MINUTE;
    StartMessageIds[BG_STARTING_EVENT_THIRD] = BG_TEXT_START_HALF_MINUTE;
    StartMessageIds[BG_STARTING_EVENT_FOURTH] = BG_TEXT_BATTLE_HAS_BEGUN;
 
    // pussywizard:
    m_UpdateTimer = 0;
}

References BATTLEGROUND_TYPE_NONE, BG_NORMAL, BG_START_DELAY_1M, BG_START_DELAY_2M, BG_START_DELAY_30S, BG_START_DELAY_NONE, BG_STARTING_EVENT_FIRST, BG_STARTING_EVENT_FOURTH, BG_STARTING_EVENT_SECOND, BG_STARTING_EVENT_THIRD, BG_TEXT_BATTLE_HAS_BEGUN, BG_TEXT_START_HALF_MINUTE, BG_TEXT_START_ONE_MINUTE, BG_TEXT_START_TWO_MINUTES, m_ArenaTeamIds, m_ArenaTeamMMR, m_ArenaType, m_BgInvitedPlayers, m_BgRaids, m_BuffChange, m_ClientInstanceID, m_EndTime, m_Events, m_HonorMode, m_InstanceID, m_IsArena, m_IsRandom, m_IsRated, m_IsTemplate, m_LastResurrectTime, m_LevelMax, m_LevelMin, m_Map, m_MapId, m_MaxPlayersPerTeam, m_MinPlayersPerTeam, m_PlayersCount, m_PrematureCountDown, m_PrematureCountDownTimer, m_RandomTypeID, m_RealTypeID, m_ResetStatTimer, m_SetDeleteThis, m_SetupCompleted, m_StartDelayTime, m_StartMaxDist, m_StartTime, m_Status, m_TeamScores, m_UpdateTimer, m_ValidStartPositionTimer, m_WinnerId, PVP_TEAM_NEUTRAL, ScriptId, StartDelayTimes, StartMessageIds, STATUS_NONE, TEAM_ALLIANCE, and TEAM_HORDE.

◆ ~Battleground()

Battleground::~Battleground ( )

virtual

{
    LOG_DEBUG("bg.battleground", "> Remove Battleground {} {} {}", GetName(), GetBgTypeID(), GetInstanceID());
 
    _reviveEvents.KillAllEvents(false);
 
    // remove objects and creatures
    // (this is done automatically in mapmanager update, when the instance is reset after the reset time)
    uint32 size = uint32(BgCreatures.size());
    for (uint32 i = 0; i < size; ++i)
        DelCreature(i);
 
    size = uint32(BgObjects.size());
    for (uint32 i = 0; i < size; ++i)
        DelObject(i);
 
    sScriptMgr->OnBattlegroundDestroy(this);
 
    sBattlegroundMgr->RemoveBattleground(GetBgTypeID(), GetInstanceID());
    // unload map
    if (m_Map)
    {
        m_Map->SetUnload();
        //unlink to prevent crash, always unlink all pointer reference before destruction
        m_Map->SetBG(nullptr);
        m_Map = nullptr;
    }
 
    // remove from bg free slot queue
    RemoveFromBGFreeSlotQueue();
 
    for (auto const& itr : PlayerScores)
        delete itr.second;
}

References _reviveEvents, BgCreatures, BgObjects, DelCreature(), DelObject(), GetBgTypeID(), GetInstanceID(), GetName(), EventProcessor::KillAllEvents(), LOG_DEBUG, m_Map, PlayerScores, RemoveFromBGFreeSlotQueue(), sBattlegroundMgr, BattlegroundMap::SetBG(), BattlegroundMap::SetUnload(), and sScriptMgr.

Member Function Documentation

◆ _CheckSafePositions()

void Battleground::_CheckSafePositions ( uint32 diff )

inlineprotected

{
    float maxDist = GetStartMaxDist();
    if (!maxDist)
        return;
 
    m_ValidStartPositionTimer += diff;
 
    if (m_ValidStartPositionTimer >= CHECK_PLAYER_POSITION_INVERVAL)
    {
        m_ValidStartPositionTimer = 0;
 
        for (auto const& [playerGuid, player] : GetPlayers())
        {
            Position pos = player->GetPosition();
            Position const* startPos = GetTeamStartPosition(player->GetBgTeamId());
 
            if (pos.GetExactDistSq(startPos) > maxDist)
            {
                LOG_DEBUG("bg.battleground", "BATTLEGROUND: Sending {} back to start location (map: {}) (possible exploit)", player->GetName(), GetMapId());
                player->TeleportTo(GetMapId(), startPos->GetPositionX(), startPos->GetPositionY(), startPos->GetPositionZ(), startPos->GetOrientation());
            }
        }
    }
}

References CHECK_PLAYER_POSITION_INVERVAL, Position::GetExactDistSq(), GetMapId(), Position::GetOrientation(), GetPlayers(), Position::GetPosition(), Position::GetPositionX(), Position::GetPositionY(), Position::GetPositionZ(), GetStartMaxDist(), GetTeamStartPosition(), LOG_DEBUG, and m_ValidStartPositionTimer.

Referenced by Update().

◆ _ProcessJoin()

void Battleground::_ProcessJoin ( uint32 diff )

inlineprotected

{
    // *********************************************************
    // ***           BATTLEGROUND STARTING SYSTEM            ***
    // *********************************************************
    ModifyStartDelayTime(diff);
 
    if (m_ResetStatTimer > 5000)
    {
        m_ResetStatTimer = 0;
        for (BattlegroundPlayerMap::const_iterator itr = GetPlayers().begin(); itr != GetPlayers().end(); ++itr)
            itr->second->ResetAllPowers();
    }
 
    if (!m_SetupCompleted)
    {
        if (!FindBgMap())
        {
            LOG_ERROR("bg.battleground", "Battleground::_ProcessJoin: map (map id: {}, instance id: {}) is not created!", m_MapId, m_InstanceID);
            EndNow();
            return;
        }
 
        // Setup here, only when at least one player has ported to the map
        if (!SetupBattleground())
        {
            EndNow();
            return;
        }
 
        StartingEventCloseDoors();
 
        // Get the configured prep time
        uint32 configuredPrepTime;
 
        // Special case for Strand of the Ancients - always use 120 seconds due to boat timing mechanics
        if (GetBgTypeID() == BATTLEGROUND_SA)
            configuredPrepTime = 120 * IN_MILLISECONDS;
        else
            configuredPrepTime = isArena() ?
                sWorld->getIntConfig(CONFIG_ARENA_PREP_TIME) * IN_MILLISECONDS :
                sWorld->getIntConfig(CONFIG_BATTLEGROUND_PREP_TIME) * IN_MILLISECONDS;
 
        SetStartDelayTime(configuredPrepTime);
 
        // Pre-mark events for announcements that should be skipped based on configured prep time
        if (configuredPrepTime < StartDelayTimes[BG_STARTING_EVENT_FIRST])
        {
            // Skip first announcement (120s for BG, 60s for Arena)
            m_Events |= BG_STARTING_EVENT_1;
 
            if (configuredPrepTime < StartDelayTimes[BG_STARTING_EVENT_SECOND])
            {
                // Skip second announcement (60s for BG, 30s for Arena)
                m_Events |= BG_STARTING_EVENT_2;
 
                if (configuredPrepTime < StartDelayTimes[BG_STARTING_EVENT_THIRD])
                {
                    // Skip third announcement (30s for BG, 15s for Arena)
                    m_Events |= BG_STARTING_EVENT_3;
                }
            }
        }
 
        // Mark setup as completed
        m_SetupCompleted = true;
    }
 
    // First announcement at 120s or 60s (Depending on BG or Arena and configured time)
    if (GetStartDelayTime() <= StartDelayTimes[BG_STARTING_EVENT_FIRST] && !(m_Events & BG_STARTING_EVENT_1))
    {
        m_Events |= BG_STARTING_EVENT_1;
 
        if (StartMessageIds[BG_STARTING_EVENT_FIRST])
            SendBroadcastText(StartMessageIds[BG_STARTING_EVENT_FIRST], CHAT_MSG_BG_SYSTEM_NEUTRAL);
    }
    // Second announcement at 60s or 30s
    else if (GetStartDelayTime() <= StartDelayTimes[BG_STARTING_EVENT_SECOND] && !(m_Events & BG_STARTING_EVENT_2))
    {
        m_Events |= BG_STARTING_EVENT_2;
 
        if (StartMessageIds[BG_STARTING_EVENT_SECOND])
            SendBroadcastText(StartMessageIds[BG_STARTING_EVENT_SECOND], CHAT_MSG_BG_SYSTEM_NEUTRAL);
    }
    // Third announcement at 30s or 15s
    else if (GetStartDelayTime() <= StartDelayTimes[BG_STARTING_EVENT_THIRD] && !(m_Events & BG_STARTING_EVENT_3))
    {
        m_Events |= BG_STARTING_EVENT_3;
 
        if (StartMessageIds[BG_STARTING_EVENT_THIRD])
            SendBroadcastText(StartMessageIds[BG_STARTING_EVENT_THIRD], CHAT_MSG_BG_SYSTEM_NEUTRAL);
 
        if (isArena())
            switch (GetBgTypeID())
            {
                case BATTLEGROUND_NA:
                    DelObject(BG_NA_OBJECT_READY_MARKER_1);
                    DelObject(BG_NA_OBJECT_READY_MARKER_2);
                    break;
                case BATTLEGROUND_BE:
                    DelObject(BG_BE_OBJECT_READY_MARKER_1);
                    DelObject(BG_BE_OBJECT_READY_MARKER_2);
                    break;
                case BATTLEGROUND_RL:
                    DelObject(BG_RL_OBJECT_READY_MARKER_1);
                    DelObject(BG_RL_OBJECT_READY_MARKER_2);
                    break;
                case BATTLEGROUND_DS:
                    DelObject(BG_DS_OBJECT_READY_MARKER_1);
                    DelObject(BG_DS_OBJECT_READY_MARKER_2);
                    break;
                case BATTLEGROUND_RV:
                    DelObject(BG_RV_OBJECT_READY_MARKER_1);
                    DelObject(BG_RV_OBJECT_READY_MARKER_2);
                    break;
                default:
                    break;
            }
    }
    // Delay expired (after configured prep time)
    else if (GetStartDelayTime() <= 0 && !(m_Events & BG_STARTING_EVENT_4))
    {
        m_Events |= BG_STARTING_EVENT_4;
 
        // Start the battle
        StartingEventOpenDoors();
 
        if (StartMessageIds[BG_STARTING_EVENT_FOURTH])
            SendBroadcastText(StartMessageIds[BG_STARTING_EVENT_FOURTH], CHAT_MSG_BG_SYSTEM_NEUTRAL);
 
        SetStatus(STATUS_IN_PROGRESS);
        SetStartDelayTime(StartDelayTimes[BG_STARTING_EVENT_FOURTH]);
 
        // Remove preparation
        if (isArena())
        {
            // pussywizard: initial visibility range is 30yd, set it to a proper value now:
            if (BattlegroundMap* map = GetBgMap())
                map->SetVisibilityRange(World::GetMaxVisibleDistanceInBGArenas());
 
            for (BattlegroundPlayerMap::const_iterator itr = GetPlayers().begin(); itr != GetPlayers().end(); ++itr)
                if (Player* player = itr->second)
                {
                    WorldPacket status;
                    sBattlegroundMgr->BuildBattlegroundStatusPacket(&status, this, player->GetCurrentBattlegroundQueueSlot(), STATUS_IN_PROGRESS, 0, GetStartTime(), GetArenaType(), player->GetBgTeamId());
                    player->GetSession()->SendPacket(&status);
 
                    player->RemoveAurasDueToSpell(SPELL_ARENA_PREPARATION);
                    player->ResetAllPowers();
                    // remove auras with duration lower than 30s
                    Unit::AuraApplicationMap& auraMap = player->GetAppliedAuras();
                    for (Unit::AuraApplicationMap::iterator iter = auraMap.begin(); iter != auraMap.end();)
                    {
                        AuraApplication* aurApp = iter->second;
                        Aura* aura = aurApp->GetBase();
                        if (!aura->IsPermanent()
                                && aura->GetDuration() <= 30 * IN_MILLISECONDS
                                && aurApp->IsPositive()
                                // && (!aura->GetSpellInfo()->HasAttribute(SPELL_ATTR0_NO_IMMUNITIES)) Xinef: condition, ALL buffs should be removed
                                && (!aura->HasEffectType(SPELL_AURA_MOD_INVISIBILITY)))
                            player->RemoveAura(iter);
                        else
                            ++iter;
                    }
 
                    player->UpdateObjectVisibility(true);
                }
 
            for (SpectatorList::const_iterator itr = m_Spectators.begin(); itr != m_Spectators.end(); ++itr)
                ArenaSpectator::HandleResetCommand(*itr);
 
            CheckWinConditions();
 
            // pussywizard: arena spectator stuff
            if (GetStatus() == STATUS_IN_PROGRESS)
            {
                for (ToBeTeleportedMap::const_iterator itr = m_ToBeTeleported.begin(); itr != m_ToBeTeleported.end(); ++itr)
                    if (Player* p = ObjectAccessor::FindConnectedPlayer(itr->first))
                        if (Player* t = ObjectAccessor::FindPlayer(itr->second))
                        {
                            if (!t->FindMap() || t->FindMap() != GetBgMap())
                                continue;
 
                            p->SetSummonPoint(t->GetMapId(), t->GetPositionX(), t->GetPositionY(), t->GetPositionZ(), 15, true);
 
                            WorldPacket data(SMSG_SUMMON_REQUEST, 8 + 4 + 4);
                            data << t->GetGUID();
                            data << uint32(t->GetZoneId());
                            data << uint32(15 * IN_MILLISECONDS);
                            p->GetSession()->SendPacket(&data);
                        }
                m_ToBeTeleported.clear();
            }
 
            sScriptMgr->OnArenaStart(this);
        }
        else
        {
            PlaySoundToAll(SOUND_BG_START);
 
            for (BattlegroundPlayerMap::const_iterator itr = GetPlayers().begin(); itr != GetPlayers().end(); ++itr)
            {
                itr->second->RemoveAurasDueToSpell(SPELL_PREPARATION);
                itr->second->ResetAllPowers();
            }
 
            // Announce BG starting
            if (sWorld->getBoolConfig(CONFIG_BATTLEGROUND_QUEUE_ANNOUNCER_ENABLE))
                ChatHandler(nullptr).SendWorldText(LANG_BG_STARTED_ANNOUNCE_WORLD, GetName(), std::min(GetMinLevel(), (uint32)80), std::min(GetMaxLevel(), (uint32)80));
 
            sScriptMgr->OnBattlegroundStart(this);
        }
    }
}

Referenced by Update().

◆ _ProcessLeave()

void Battleground::_ProcessLeave ( uint32 diff )

inlineprotected

{
    // *********************************************************
    // ***           BATTLEGROUND ENDING SYSTEM              ***
    // *********************************************************
    // remove all players from battleground after 2 minutes
    m_EndTime -= diff;
    if (m_EndTime <= 0)
    {
        m_EndTime = TIME_TO_AUTOREMOVE; // pussywizard: 0 -> TIME_TO_AUTOREMOVE
        BattlegroundPlayerMap::iterator itr, next;
        for (itr = m_Players.begin(); itr != m_Players.end(); itr = next)
        {
            next = itr;
            ++next;
            itr->second->LeaveBattleground(this); //itr is erased here!
        }
    }
}

References m_EndTime, m_Players, and TIME_TO_AUTOREMOVE.

Referenced by Update().

◆ _ProcessProgress()

void Battleground::_ProcessProgress ( uint32 diff )

inlineprotected

{
    // *********************************************************
    // ***           BATTLEGROUND BALLANCE SYSTEM            ***
    // *********************************************************
    // if less then minimum players are in on one side, then start premature finish timer
    if (!m_PrematureCountDown)
    {
        m_PrematureCountDown = true;
        m_PrematureCountDownTimer = sBattlegroundMgr->GetPrematureFinishTime();
    }
    else if (m_PrematureCountDownTimer < diff)
    {
        // time's up!
        EndBattleground(GetPrematureWinner());
        m_PrematureCountDown = false;
    }
    else if (!sBattlegroundMgr->isTesting())
    {
        uint32 newtime = m_PrematureCountDownTimer - diff;
        // announce every minute
        if (newtime > (MINUTE * IN_MILLISECONDS))
        {
            if (newtime / (MINUTE * IN_MILLISECONDS) != m_PrematureCountDownTimer / (MINUTE * IN_MILLISECONDS))
                GetBgMap()->DoForAllPlayers([&](Player* player)
                    {
                        ChatHandler(player->GetSession()).PSendSysMessage(LANG_BATTLEGROUND_PREMATURE_FINISH_WARNING, (uint32)(m_PrematureCountDownTimer / (MINUTE * IN_MILLISECONDS)));
                    });
        }
        else
        {
            //announce every 15 seconds
            if (newtime / (15 * IN_MILLISECONDS) != m_PrematureCountDownTimer / (15 * IN_MILLISECONDS))
                GetBgMap()->DoForAllPlayers([&](Player* player)
                    {
                        ChatHandler(player->GetSession()).PSendSysMessage(LANG_BATTLEGROUND_PREMATURE_FINISH_WARNING_SECS, (uint32)(m_PrematureCountDownTimer / IN_MILLISECONDS));
                    });
        }
        m_PrematureCountDownTimer = newtime;
    }
}

References Map::DoForAllPlayers(), EndBattleground(), GetBgMap(), GetPrematureWinner(), Player::GetSession(), IN_MILLISECONDS, LANG_BATTLEGROUND_PREMATURE_FINISH_WARNING, LANG_BATTLEGROUND_PREMATURE_FINISH_WARNING_SECS, m_PrematureCountDown, m_PrematureCountDownTimer, MINUTE, ChatHandler::PSendSysMessage(), and sBattlegroundMgr.

Referenced by Update().

◆ _ProcessResurrect()

void Battleground::_ProcessResurrect ( uint32 diff )

inlineprotected

{
    // *********************************************************
    // ***        BATTLEGROUND RESURRECTION SYSTEM           ***
    // *********************************************************
    // this should be handled by spell system
 
    _reviveEvents.Update(diff);
 
    m_LastResurrectTime += diff;
    if (m_LastResurrectTime >= RESURRECTION_INTERVAL)
    {
        if (GetReviveQueueSize())
        {
            for (std::map<ObjectGuid, GuidVector>::iterator itr = m_ReviveQueue.begin(); itr != m_ReviveQueue.end(); ++itr)
            {
                Creature* sh = nullptr;
                for (ObjectGuid const& guid : itr->second)
                {
                    Player* player = ObjectAccessor::FindPlayer(guid);
                    if (!player)
                        continue;
 
                    if (!sh && player->IsInWorld())
                    {
                        sh = player->GetMap()->GetCreature(itr->first);
                        // only for visual effect
                        if (sh)
                            // Spirit Heal, effect 117
                            sh->CastSpell(sh, SPELL_SPIRIT_HEAL, true);
                    }
 
                    // Resurrection visual
                    player->CastSpell(player, SPELL_RESURRECTION_VISUAL, true);
                    m_ResurrectQueue.push_back(guid);
                }
 
                itr->second.clear();
            }
 
            m_ReviveQueue.clear();
            m_LastResurrectTime = 0;
        }
        else
            // queue is clear and time passed, just update last resurrection time
            m_LastResurrectTime = 0;
    }
    else if (m_LastResurrectTime > 500)    // Resurrect players only half a second later, to see spirit heal effect on NPC
    {
        for (ObjectGuid const& guid : m_ResurrectQueue)
        {
            Player* player = ObjectAccessor::FindPlayer(guid);
            if (!player)
                continue;
            player->ResurrectPlayer(1.0f);
            player->CastSpell(player, 6962, true);
            player->CastSpell(player, SPELL_SPIRIT_HEAL_MANA, true);
            player->SpawnCorpseBones(false);
        }
        m_ResurrectQueue.clear();
    }
}

References _reviveEvents, Unit::CastSpell(), ObjectAccessor::FindPlayer(), Map::GetCreature(), WorldObject::GetMap(), GetReviveQueueSize(), Object::IsInWorld(), m_LastResurrectTime, m_ResurrectQueue, m_ReviveQueue, RESURRECTION_INTERVAL, Player::ResurrectPlayer(), Player::SpawnCorpseBones(), SPELL_RESURRECTION_VISUAL, SPELL_SPIRIT_HEAL, SPELL_SPIRIT_HEAL_MANA, and EventProcessor::Update().

Referenced by Update().

◆ AddCreature()

Creature * Battleground::AddCreature	(	uint32	entry,
		uint32	type,
		float	x,
		float	y,
		float	z,
		float	o,
		uint32	respawntime = `0`,
		MotionTransport *	transport = `nullptr`
	)

{
    // If the assert is called, means that BgCreatures must be resized!
    ASSERT(type < BgCreatures.size());
 
    Map* map = FindBgMap();
    if (!map)
        return nullptr;
 
    if (transport)
    {
        transport->CalculatePassengerPosition(x, y, z, &o);
        if (Creature* creature = transport->SummonCreature(entry, x, y, z, o, TEMPSUMMON_MANUAL_DESPAWN))
        {
            transport->AddPassenger(creature, true);
            BgCreatures[type] = creature->GetGUID();
            return creature;
        }
 
        return nullptr;
    }
 
    Creature* creature = new Creature();
    if (!creature->Create(map->GenerateLowGuid<HighGuid::Unit>(), map, PHASEMASK_NORMAL, entry, 0, x, y, z, o))
    {
        LOG_ERROR("bg.battleground", "Battleground::AddCreature: cannot create creature (entry: {}) for BG (map: {}, instance id: {})!",
                       entry, m_MapId, m_InstanceID);
        delete creature;
        return nullptr;
    }
 
    creature->SetHomePosition(x, y, z, o);
 
    CreatureTemplate const* cinfo = sObjectMgr->GetCreatureTemplate(entry);
    if (!cinfo)
    {
        LOG_ERROR("bg.battleground", "Battleground::AddCreature: creature template (entry: {}) does not exist for BG (map: {}, instance id: {})!",
                       entry, m_MapId, m_InstanceID);
        delete creature;
        return nullptr;
    }
    // Force using DB speeds
    creature->SetSpeed(MOVE_WALK,  cinfo->speed_walk);
    creature->SetSpeed(MOVE_RUN,   cinfo->speed_run);
 
    if (!map->AddToMap(creature))
    {
        delete creature;
        return nullptr;
    }
 
    BgCreatures[type] = creature->GetGUID();
 
    if (respawntime)
        creature->SetRespawnDelay(respawntime);
 
    // Xinef: Set PVP state for vehicles, should be for all creatures in bg?
    if (creature->IsVehicle())
        creature->SetPvP(true);
 
    return creature;
}

References MotionTransport::AddPassenger(), Map::AddToMap(), ASSERT, BgCreatures, Transport::CalculatePassengerPosition(), Creature::Create(), FindBgMap(), Map::GenerateLowGuid(), Object::GetGUID(), Unit::IsVehicle(), LOG_ERROR, m_InstanceID, m_MapId, MOVE_RUN, MOVE_WALK, PHASEMASK_NORMAL, Creature::SetHomePosition(), Unit::SetPvP(), Creature::SetRespawnDelay(), Unit::SetSpeed(), sObjectMgr, CreatureTemplate::speed_run, CreatureTemplate::speed_walk, WorldObject::SummonCreature(), TEMPSUMMON_MANUAL_DESPAWN, and Unit.

Referenced by BattlegroundAV::AddAVCreature(), AddSpiritGuide(), BattlegroundSA::CaptureGraveyard(), BattlegroundEY::EventTeamCapturedPoint(), BattlegroundIC::HandleCapturedNodes(), BattlegroundAB::NodeOccupied(), BattlegroundAV::PopulateNode(), BattlegroundSA::ResetObjs(), BattlegroundDS::SetupBattleground(), and BattlegroundIC::SetupBattleground().

◆ AddObject()

bool Battleground::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`
	)

{
    // If the assert is called, means that BgObjects must be resized!
    ASSERT(type < BgObjects.size());
 
    Map* map = FindBgMap();
    if (!map)
        return false;
    // Must be created this way, adding to godatamap would add it to the base map of the instance
    // and when loading it (in go::LoadFromDB()), a new guid would be assigned to the object, and a new object would be created
    // So we must create it specific for this instance
    GameObject* go = sObjectMgr->IsGameObjectStaticTransport(entry) ? new StaticTransport() : new GameObject();
    if (!go->Create(map->GenerateLowGuid<HighGuid::GameObject>(), entry, GetBgMap(),
                    PHASEMASK_NORMAL, x, y, z, o, G3D::Quat(rotation0, rotation1, rotation2, rotation3), 100, goState))
    {
        LOG_ERROR("sql.sql", "Battleground::AddObject: cannot create gameobject (entry: {}) for BG (map: {}, instance id: {})!",
                         entry, m_MapId, m_InstanceID);
        LOG_ERROR("bg.battleground", "Battleground::AddObject: cannot create gameobject (entry: {}) for BG (map: {}, instance id: {})!",
                       entry, m_MapId, m_InstanceID);
        delete go;
        return false;
    }
    /*
        ObjectGuid::LowType spawnId = go->GetSpawnId();
 
        // without this, UseButtonOrDoor caused the crash, since it tried to get go info from godata
        // iirc that was changed, so adding to go data map is no longer required if that was the only function using godata from GameObject without checking if it existed
        GameObjectData& data = sObjectMgr->NewGOData(spawnId);
 
        data.id             = entry;
        data.mapid          = GetMapId();
        data.posX           = x;
        data.posY           = y;
        data.posZ           = z;
        data.orientation    = o;
        data.rotation0      = rotation0;
        data.rotation1      = rotation1;
        data.rotation2      = rotation2;
        data.rotation3      = rotation3;
        data.spawntimesecs  = respawnTime;
        data.spawnMask      = 1;
        data.animprogress   = 100;
        data.go_state       = 1;
    */
    // Add to world, so it can be later looked up from HashMapHolder
    if (!map->AddToMap(go))
    {
        delete go;
        return false;
    }
    BgObjects[type] = go->GetGUID();
    return true;
}

References Map::AddToMap(), ASSERT, BgObjects, GameObject::Create(), FindBgMap(), GameObject, Map::GenerateLowGuid(), GetBgMap(), Object::GetGUID(), LOG_ERROR, m_InstanceID, m_MapId, PHASEMASK_NORMAL, and sObjectMgr.

◆ AddOrSetPlayerToCorrectBgGroup()

void Battleground::AddOrSetPlayerToCorrectBgGroup	(	Player *	player,
		TeamId	teamId
	)

{
    if (player->GetGroup() && (player->GetGroup()->isBGGroup() || player->GetGroup()->isBFGroup()))
    {
        LOG_INFO("misc", "Battleground::AddOrSetPlayerToCorrectBgGroup - player is already in {} group!", (player->GetGroup()->isBGGroup() ? "BG" : "BF"));
        return;
    }
 
    ObjectGuid playerGuid = player->GetGUID();
    Group* group = GetBgRaid(teamId);
    if (!group)                                      // first player joined
    {
        group = new Group;
        SetBgRaid(teamId, group);
        group->Create(player);
        sGroupMgr->AddGroup(group);
    }
    else if (group->IsMember(playerGuid))
    {
        uint8 subgroup = group->GetMemberGroup(playerGuid);
        player->SetBattlegroundOrBattlefieldRaid(group, subgroup);
    }
    else
    {
        group->AddMember(player);
 
        if (Group* originalGroup = player->GetOriginalGroup())
            if (originalGroup->IsLeader(playerGuid))
            {
                group->ChangeLeader(playerGuid);
                group->SendUpdate();
            }
    }
}

References Group::AddMember(), Group::ChangeLeader(), Group::Create(), GetBgRaid(), Player::GetGroup(), Object::GetGUID(), Group::GetMemberGroup(), Player::GetOriginalGroup(), Group::isBFGroup(), Group::isBGGroup(), Group::IsMember(), LOG_INFO, Group::SendUpdate(), Player::SetBattlegroundOrBattlefieldRaid(), SetBgRaid(), and sGroupMgr.

Referenced by AddPlayer().

◆ AddPlayer()

void Battleground::AddPlayer ( Player * player )

virtual

Reimplemented in Arena, BattlegroundAB, BattlegroundAV, BattlegroundEY, BattlegroundIC, BattlegroundSA, and BattlegroundWS.

{
    // remove afk from player
    if (player->HasPlayerFlag(PLAYER_FLAGS_AFK))
        player->ToggleAFK();
 
    sScriptMgr->OnBattlegroundBeforeAddPlayer(this, player);
 
    // score struct must be created in inherited class
 
    ObjectGuid guid = player->GetGUID();
    TeamId teamId = player->GetBgTeamId();
 
    // Add to list/maps
    m_Players[guid] = player;
 
    UpdatePlayersCountByTeam(teamId, false);                  // +1 player
 
    WorldPacket data;
    sBattlegroundMgr->BuildPlayerJoinedBattlegroundPacket(&data, player);
    SendPacketToTeam(teamId, &data, player, false);
 
    player->RemoveAurasByType(SPELL_AURA_MOUNTED);
 
    // add arena specific auras
    if (isArena())
    {
        // restore pets health before remove
        if (Pet* pet = player->GetPet())
            if (pet->IsAlive())
                pet->SetHealth(pet->GetMaxHealth());
 
        player->RemoveArenaEnchantments(TEMP_ENCHANTMENT_SLOT);
        player->DestroyConjuredItems(true);
        player->UnsummonPetTemporaryIfAny();
 
        if (GetStatus() == STATUS_WAIT_JOIN)                 // not started yet
        {
            player->CastSpell(player, SPELL_ARENA_PREPARATION, true);
            player->ResetAllPowers();
        }
    }
    else
    {
        if (GetStatus() == STATUS_WAIT_JOIN)                 // not started yet
            player->CastSpell(player, SPELL_PREPARATION, true);   // reduces all mana cost of spells.
    }
 
    // Xinef: reset all map criterias on map enter
    player->ResetAchievementCriteria(ACHIEVEMENT_CRITERIA_CONDITION_BG_MAP, GetMapId(), true);
 
    // setup BG group membership
    PlayerAddedToBGCheckIfBGIsRunning(player);
    AddOrSetPlayerToCorrectBgGroup(player, teamId);
 
    sScriptMgr->OnBattlegroundAddPlayer(this, player);
 
    // Log
    LOG_DEBUG("bg.battleground", "BATTLEGROUND: Player {} joined the battle.", player->GetName());
}

References ACHIEVEMENT_CRITERIA_CONDITION_BG_MAP, AddOrSetPlayerToCorrectBgGroup(), Unit::CastSpell(), Player::DestroyConjuredItems(), Player::GetBgTeamId(), Object::GetGUID(), GetMapId(), WorldObject::GetName(), Player::GetPet(), GetStatus(), Player::HasPlayerFlag(), isArena(), LOG_DEBUG, m_Players, PLAYER_FLAGS_AFK, PlayerAddedToBGCheckIfBGIsRunning(), Player::RemoveArenaEnchantments(), Unit::RemoveAurasByType(), Player::ResetAchievementCriteria(), Player::ResetAllPowers(), sBattlegroundMgr, SendPacketToTeam(), SPELL_ARENA_PREPARATION, SPELL_AURA_MOUNTED, SPELL_PREPARATION, sScriptMgr, STATUS_WAIT_JOIN, TEMP_ENCHANTMENT_SLOT, Player::ToggleAFK(), Player::UnsummonPetTemporaryIfAny(), and UpdatePlayersCountByTeam().

Referenced by Arena::AddPlayer(), BattlegroundAB::AddPlayer(), BattlegroundAV::AddPlayer(), BattlegroundEY::AddPlayer(), BattlegroundIC::AddPlayer(), BattlegroundSA::AddPlayer(), and BattlegroundWS::AddPlayer().

◆ AddPlayerToResurrectQueue()

void Battleground::AddPlayerToResurrectQueue	(	ObjectGuid	npc_guid,
		ObjectGuid	player_guid
	)

{
    m_ReviveQueue[npc_guid].push_back(player_guid);
 
    Player* player = ObjectAccessor::FindPlayer(player_guid);
    if (!player)
        return;
 
    player->CastSpell(player, SPELL_WAITING_FOR_RESURRECT, true);
}

References Unit::CastSpell(), ObjectAccessor::FindPlayer(), m_ReviveQueue, and SPELL_WAITING_FOR_RESURRECT.

Referenced by WorldSession::HandleAreaSpiritHealerQueueOpcode(), and WorldSession::HandleGossipHelloOpcode().

◆ AddSpectator()

void Battleground::AddSpectator ( Player * p )

inline

396{ m_Spectators.insert(p); }

References m_Spectators.

◆ AddSpiritGuide()

bool Battleground::AddSpiritGuide	(	uint32	type,
		float	x,
		float	y,
		float	z,
		float	o,
		TeamId	teamId
	)

Todo:: : Fix display here

{
    uint32 entry = (teamId == TEAM_ALLIANCE) ? BG_CREATURE_ENTRY_A_SPIRITGUIDE : BG_CREATURE_ENTRY_H_SPIRITGUIDE;
 
    if (Creature* creature = AddCreature(entry, type, x, y, z, o))
    {
        creature->setDeathState(DeathState::Dead);
        creature->SetGuidValue(UNIT_FIELD_CHANNEL_OBJECT, creature->GetGUID());
        // aura
        // creature->SetVisibleAura(0, SPELL_SPIRIT_HEAL_CHANNEL);
        // casting visual effect
        creature->SetUInt32Value(UNIT_CHANNEL_SPELL, SPELL_SPIRIT_HEAL_CHANNEL);
        // correct cast speed
        creature->SetFloatValue(UNIT_MOD_CAST_SPEED, 1.0f);
        //creature->CastSpell(creature, SPELL_SPIRIT_HEAL_CHANNEL, true);
        return true;
    }
    LOG_ERROR("bg.battleground", "Battleground::AddSpiritGuide: cannot create spirit guide (type: {}, entry: {}) for BG (map: {}, instance id: {})!",
                   type, entry, m_MapId, m_InstanceID);
    EndNow();
    return false;
}

References AddCreature(), BG_CREATURE_ENTRY_A_SPIRITGUIDE, BG_CREATURE_ENTRY_H_SPIRITGUIDE, Dead, EndNow(), LOG_ERROR, m_InstanceID, m_MapId, SPELL_SPIRIT_HEAL_CHANNEL, TEAM_ALLIANCE, UNIT_CHANNEL_SPELL, UNIT_FIELD_CHANNEL_OBJECT, and UNIT_MOD_CAST_SPEED.

Referenced by BattlegroundSA::CaptureGraveyard(), BattlegroundEY::EventTeamCapturedPoint(), BattlegroundIC::HandleCapturedNodes(), BattlegroundAB::NodeOccupied(), BattlegroundAV::PopulateNode(), BattlegroundSA::ResetObjs(), BattlegroundAB::SetupBattleground(), BattlegroundAV::SetupBattleground(), BattlegroundEY::SetupBattleground(), BattlegroundIC::SetupBattleground(), and BattlegroundWS::SetupBattleground().

◆ AddToBeTeleported()

void Battleground::AddToBeTeleported	(	ObjectGuid	spectator,
		ObjectGuid	participant
	)

inline

400{ m_ToBeTeleported[spectator] = participant; }

References m_ToBeTeleported.

Referenced by ArenaSpectator::HandleSpectatorSpectateCommand().

◆ AddToBGFreeSlotQueue()

void Battleground::AddToBGFreeSlotQueue ( )

{
    if (!_InBGFreeSlotQueue && isBattleground())
    {
        sBattlegroundMgr->AddToBGFreeSlotQueue(m_RealTypeID, this);
        _InBGFreeSlotQueue = true;
    }
}

References _InBGFreeSlotQueue, isBattleground(), m_RealTypeID, and sBattlegroundMgr.

Referenced by RemovePlayerAtLeave(), and StartBattleground().

◆ AllNodesConrolledByTeam()

virtual bool Battleground::AllNodesConrolledByTeam ( TeamId ) const

inlinevirtual

Reimplemented in BattlegroundAB, BattlegroundEY, and BattlegroundIC.

314{ return false; }

Referenced by achievement_bg_control_all_nodes::OnCheck().

◆ BlockMovement()

void Battleground::BlockMovement ( Player * player )

{
    player->SetClientControl(player, 0);                          // movement disabled NOTE: the effect will be automatically removed by client when the player is teleported from the battleground, so no need to send with uint8(1) in RemovePlayerAtLeave()
}

References Player::SetClientControl().

Referenced by EndBattleground(), and PlayerAddedToBGCheckIfBGIsRunning().

◆ BroadcastWorker()

template<class Do >

void Battleground::BroadcastWorker ( Do & _do )

{
    for (BattlegroundPlayerMap::const_iterator itr = m_Players.begin(); itr != m_Players.end(); ++itr)
        _do(itr->second);
}

References m_Players.

Referenced by SendBroadcastText().

◆ BuildPvPLogDataPacket()

void Battleground::BuildPvPLogDataPacket ( WorldPacket & data )

{
    uint8 type = (isArena() ? 1 : 0);
 
    data.Initialize(MSG_PVP_LOG_DATA, 1 + 1 + 4 + 40 * GetPlayerScores()->size());
    data << uint8(type); // type (battleground = 0 / arena = 1)
 
    if (type) // arena
    {
        for (uint8 i = 0; i < PVP_TEAMS_COUNT; ++i)
            _arenaTeamScores[i].BuildRatingInfoBlock(data);
 
        for (uint8 i = 0; i < PVP_TEAMS_COUNT; ++i)
            _arenaTeamScores[i].BuildTeamInfoBlock(data);
    }
 
    if (GetStatus() == STATUS_WAIT_LEAVE)
    {
        data << uint8(1);                      // bg ended
        data << uint8(GetWinner());            // who win
    }
    else
        data << uint8(0);                      // bg not ended
 
    data << uint32(GetPlayerScores()->size());
 
    for (auto const& score : PlayerScores)
        score.second->AppendToPacket(data);
}

References _arenaTeamScores, GetPlayerScores(), GetStatus(), GetWinner(), WorldPacket::Initialize(), isArena(), MSG_PVP_LOG_DATA, PlayerScores, PVP_TEAMS_COUNT, and STATUS_WAIT_LEAVE.

Referenced by EndBattleground(), WorldSession::HandlePVPLogDataOpcode(), and PlayerAddedToBGCheckIfBGIsRunning().

◆ CastSpellOnTeam()

void Battleground::CastSpellOnTeam	(	uint32	spellId,
		TeamId	teamId
	)

{
    for (BattlegroundPlayerMap::const_iterator itr = m_Players.begin(); itr != m_Players.end(); ++itr)
        if (itr->second->GetBgTeamId() == teamId)
            itr->second->CastSpell(itr->second, spellId, true);
}

References m_Players.

Referenced by BattlegroundIC::HandleCapturedNodes(), BattlegroundAV::HandleKillUnit(), BattlegroundAB::NodeOccupied(), and BattlegroundAV::PostUpdateImpl().

◆ CheckWinConditions()

virtual void Battleground::CheckWinConditions ( )

inlinevirtual

Reimplemented in Arena.

498{ }

Referenced by _ProcessJoin().

◆ DecreaseInvitedCount()

void Battleground::DecreaseInvitedCount ( TeamId teamId )

inline

386{ if (m_BgInvitedPlayers[teamId]) --m_BgInvitedPlayers[teamId]; }

References m_BgInvitedPlayers.

Referenced by RemovePlayerAtLeave().

◆ DelCreature()

bool Battleground::DelCreature ( uint32 type )

{
    if (!BgCreatures[type])
        return true;
 
    if (Creature* creature = GetBgMap()->GetCreature(BgCreatures[type]))
    {
        creature->AddObjectToRemoveList();
        BgCreatures[type].Clear();
        return true;
    }
 
    LOG_ERROR("bg.battleground", "Battleground::DelCreature: creature (type: {}, {}) not found for BG (map: {}, instance id: {})!",
                   type, BgCreatures[type].ToString(), m_MapId, m_InstanceID);
 
    BgCreatures[type].Clear();
    return false;
}

References WorldObject::AddObjectToRemoveList(), BgCreatures, GetBgMap(), LOG_ERROR, m_InstanceID, and m_MapId.

Referenced by BattlegroundSA::CaptureGraveyard(), BattlegroundAV::ChangeMineOwner(), BattlegroundAV::DePopulateNode(), BattlegroundAV::EventPlayerAssaultsPoint(), BattlegroundIC::EventPlayerClickedOnFlag(), BattlegroundAV::EventPlayerDestroyedPoint(), BattlegroundEY::EventTeamLostPoint(), BattlegroundIC::HandleContestedNodes(), BattlegroundAV::HandleKillUnit(), BattlegroundAB::NodeDeoccupied(), BattlegroundAV::PopulateNode(), BattlegroundAV::ResetBGSubclass(), BattlegroundSA::ResetObjs(), and ~Battleground().

◆ DelObject()

bool Battleground::DelObject ( uint32 type )

{
    if (!BgObjects[type])
        return true;
 
    if (GameObject* obj = GetBgMap()->GetGameObject(BgObjects[type]))
    {
        obj->SetRespawnTime(0);                                 // not save respawn time
        obj->Delete();
        BgObjects[type].Clear();
        return true;
    }
 
    LOG_ERROR("bg.battleground", "Battleground::DelObject: gameobject (type: {}, {}) not found for BG (map: {}, instance id: {})!",
                   type, BgObjects[type].ToString(), m_MapId, m_InstanceID);
 
    BgObjects[type].Clear();
    return false;
}

References BgObjects, GetBgMap(), LOG_ERROR, m_InstanceID, and m_MapId.

Referenced by _ProcessJoin(), BattlegroundSA::CaptureGraveyard(), BattlegroundSA::DestroyGate(), BattlegroundIC::EventPlayerClickedOnFlag(), BattlegroundIC::HandleContestedNodes(), BattlegroundIC::PostUpdateImpl(), BattlegroundSA::ResetObjs(), and ~Battleground().

◆ DestroyGate()

virtual void Battleground::DestroyGate	(	Player *	,
		GameObject *
	)

inlinevirtual

Reimplemented in BattlegroundIC, and BattlegroundSA.

311{}

◆ DoAction()

virtual void Battleground::DoAction	(	uint32	,
		ObjectGuid
	)

inlinevirtual

Reimplemented in BattlegroundIC.

520{}

◆ DoorClose()

void Battleground::DoorClose ( uint32 type )

{
    if (GameObject* obj = GetBgMap()->GetGameObject(BgObjects[type]))
    {
        // If doors are open, close it
        if (obj->getLootState() == GO_ACTIVATED && obj->GetGoState() != GO_STATE_READY)
        {
            obj->SetLootState(GO_READY);
            obj->SetGoState(GO_STATE_READY);
        }
    }
    else
        LOG_ERROR("bg.battleground", "Battleground::DoorClose: door gameobject (type: {}, {}) not found for BG (map: {}, instance id: {})!",
                       type, BgObjects[type].ToString(), m_MapId, m_InstanceID);
}

References BgObjects, GetBgMap(), GO_ACTIVATED, GO_READY, GO_STATE_READY, LOG_ERROR, m_InstanceID, and m_MapId.

Referenced by BattlegroundDS::PostUpdateImpl(), BattlegroundRV::PostUpdateImpl(), BattlegroundAB::StartingEventCloseDoors(), BattlegroundAV::StartingEventCloseDoors(), and BattlegroundWS::StartingEventCloseDoors().

◆ DoorOpen()

void Battleground::DoorOpen ( uint32 type )

{
    if (GameObject* obj = GetBgMap()->GetGameObject(BgObjects[type]))
    {
        obj->SetLootState(GO_ACTIVATED);
        obj->SetGoState(GO_STATE_ACTIVE);
    }
    else
        LOG_ERROR("bg.battleground", "Battleground::DoorOpen: door gameobject (type: {}, {}) not found for BG (map: {}, instance id: {})!",
                       type, BgObjects[type].ToString(), m_MapId, m_InstanceID);
}

References BgObjects, GetBgMap(), GO_ACTIVATED, GO_STATE_ACTIVE, LOG_ERROR, m_InstanceID, and m_MapId.

◆ EndBattleground() [1/2]

void Battleground::EndBattleground ( PvPTeamId winnerTeamId )

{
    // xinef: if this is true, it means that endbattleground is called second time
    // skip to avoid double rating reduce / add
    // can bug out due to multithreading ?
    // set as fast as possible
    if (GetStatus() == STATUS_WAIT_LEAVE)
        return;
 
    RemoveFromBGFreeSlotQueue();
    SetStatus(STATUS_WAIT_LEAVE);
    SetWinner(winnerTeamId);
 
    if (winnerTeamId == PVP_TEAM_ALLIANCE)
    {
        if (isBattleground())
            SendBroadcastText(BG_TEXT_ALLIANCE_WINS, CHAT_MSG_BG_SYSTEM_NEUTRAL);
 
        PlaySoundToAll(SOUND_ALLIANCE_WINS); // alliance wins sound
    }
    else if (winnerTeamId == PVP_TEAM_HORDE)
    {
        if (isBattleground())
            SendBroadcastText(BG_TEXT_HORDE_WINS, CHAT_MSG_BG_SYSTEM_NEUTRAL);
 
        PlaySoundToAll(SOUND_HORDE_WINS); // horde wins sound
    }
 
    CharacterDatabasePreparedStatement* stmt = nullptr;
    uint64 battlegroundId = 1;
    if (isBattleground() && sWorld->getBoolConfig(CONFIG_BATTLEGROUND_STORE_STATISTICS_ENABLE))
    {
        stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_PVPSTATS_MAXID);
        PreparedQueryResult result = CharacterDatabase.Query(stmt);
 
        if (result)
        {
            Field* fields = result->Fetch();
            battlegroundId = fields[0].Get<uint64>() + 1;
        }
 
        stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_PVPSTATS_BATTLEGROUND);
        stmt->SetData(0, battlegroundId);
        stmt->SetData(1, GetWinner());
        stmt->SetData(2, GetUniqueBracketId());
        stmt->SetData(3, GetBgTypeID(true));
        CharacterDatabase.Execute(stmt);
    }
 
    //we must set it this way, because end time is sent in packet!
    m_EndTime = TIME_TO_AUTOREMOVE;
 
    WorldPacket pvpLogData;
    BuildPvPLogDataPacket(pvpLogData);
 
    for (auto const& [playerGuid, player] : m_Players)
    {
        TeamId bgTeamId = player->GetBgTeamId();
 
        // should remove spirit of redemption
        if (player->HasSpiritOfRedemptionAura())
            player->RemoveAurasByType(SPELL_AURA_MOD_SHAPESHIFT);
 
        if (!player->IsAlive())
        {
            player->ResurrectPlayer(1.0f);
            player->SpawnCorpseBones();
        }
        else
        {
            //needed cause else in av some creatures will kill the players at the end
            player->CombatStop();
            player->getHostileRefMgr().deleteReferences();
        }
 
        uint32 winner_kills = player->GetRandomWinner() ? sWorld->getIntConfig(CONFIG_BG_REWARD_WINNER_HONOR_LAST) : sWorld->getIntConfig(CONFIG_BG_REWARD_WINNER_HONOR_FIRST);
        uint32 loser_kills = player->GetRandomWinner() ? sWorld->getIntConfig(CONFIG_BG_REWARD_LOSER_HONOR_LAST) : sWorld->getIntConfig(CONFIG_BG_REWARD_LOSER_HONOR_FIRST);
        uint32 winner_arena = player->GetRandomWinner() ? sWorld->getIntConfig(CONFIG_BG_REWARD_WINNER_ARENA_LAST) : sWorld->getIntConfig(CONFIG_BG_REWARD_WINNER_ARENA_FIRST);
 
        // Reward winner team
        if (bgTeamId == GetTeamId(winnerTeamId))
        {
            if (IsRandom() || BattlegroundMgr::IsBGWeekend(GetBgTypeID(true)))
            {
                UpdatePlayerScore(player, SCORE_BONUS_HONOR, GetBonusHonorFromKill(winner_kills));
 
                // Xinef: check player level and not bracket level if (CanAwardArenaPoints())
                if (player->GetLevel() >= sWorld->getIntConfig(CONFIG_DAILY_RBG_MIN_LEVEL_AP_REWARD))
                    player->ModifyArenaPoints(winner_arena);
 
                if (!player->GetRandomWinner())
                    player->SetRandomWinner(true);
            }
 
            player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_WIN_BG, player->GetMapId());
        }
        else
        {
            if (IsRandom() || BattlegroundMgr::IsBGWeekend(GetBgTypeID(true)))
                UpdatePlayerScore(player, SCORE_BONUS_HONOR, GetBonusHonorFromKill(loser_kills));
        }
 
        sScriptMgr->OnBattlegroundEndReward(this, player, GetTeamId(winnerTeamId));
 
        player->ResetAllPowers();
        player->CombatStopWithPets(true);
 
        BlockMovement(player);
 
        player->GetSession()->SendPacket(&pvpLogData);
 
        if (isBattleground() && sWorld->getBoolConfig(CONFIG_BATTLEGROUND_STORE_STATISTICS_ENABLE))
        {
            stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_PVPSTATS_PLAYER);
            auto const& score = PlayerScores.find(player->GetGUID().GetCounter());
 
            stmt->SetData(0, battlegroundId);
            stmt->SetData(1, player->GetGUID().GetCounter());
            stmt->SetData(2, bgTeamId == GetTeamId(winnerTeamId));
            stmt->SetData(3, score->second->GetKillingBlows());
            stmt->SetData(4, score->second->GetDeaths());
            stmt->SetData(5, score->second->GetHonorableKills());
            stmt->SetData(6, score->second->GetBonusHonor());
            stmt->SetData(7, score->second->GetDamageDone());
            stmt->SetData(8, score->second->GetHealingDone());
            stmt->SetData(9, score->second->GetAttr1());
            stmt->SetData(10, score->second->GetAttr2());
            stmt->SetData(11, score->second->GetAttr3());
            stmt->SetData(12, score->second->GetAttr4());
            stmt->SetData(13, score->second->GetAttr5());
 
            CharacterDatabase.Execute(stmt);
        }
 
        WorldPacket data;
        sBattlegroundMgr->BuildBattlegroundStatusPacket(&data, this, player->GetCurrentBattlegroundQueueSlot(), STATUS_IN_PROGRESS, TIME_TO_AUTOREMOVE, GetStartTime(), GetArenaType(), player->GetBgTeamId());
        player->GetSession()->SendPacket(&data);
 
        player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_BATTLEGROUND, player->GetMapId());
    }
 
    if (IsEventActive(EVENT_SPIRIT_OF_COMPETITION) && isBattleground())
        SpiritOfCompetitionEvent(winnerTeamId);
 
    sScriptMgr->OnBattlegroundEnd(this, GetTeamId(winnerTeamId));
}

References ACHIEVEMENT_CRITERIA_TYPE_COMPLETE_BATTLEGROUND, ACHIEVEMENT_CRITERIA_TYPE_WIN_BG, BG_TEXT_ALLIANCE_WINS, BG_TEXT_HORDE_WINS, BlockMovement(), BuildPvPLogDataPacket(), CHAR_INS_PVPSTATS_BATTLEGROUND, CHAR_INS_PVPSTATS_PLAYER, CHAR_SEL_PVPSTATS_MAXID, CharacterDatabase, CHAT_MSG_BG_SYSTEM_NEUTRAL, CONFIG_BATTLEGROUND_STORE_STATISTICS_ENABLE, CONFIG_BG_REWARD_LOSER_HONOR_FIRST, CONFIG_BG_REWARD_LOSER_HONOR_LAST, CONFIG_BG_REWARD_WINNER_ARENA_FIRST, CONFIG_BG_REWARD_WINNER_ARENA_LAST, CONFIG_BG_REWARD_WINNER_HONOR_FIRST, CONFIG_BG_REWARD_WINNER_HONOR_LAST, CONFIG_DAILY_RBG_MIN_LEVEL_AP_REWARD, EVENT_SPIRIT_OF_COMPETITION, Field::Get(), GetArenaType(), GetBgTypeID(), GetBonusHonorFromKill(), GetStartTime(), GetStatus(), GetTeamId(), GetUniqueBracketId(), GetWinner(), isBattleground(), BattlegroundMgr::IsBGWeekend(), IsEventActive(), IsRandom(), m_EndTime, m_Players, PlayerScores, PlaySoundToAll(), PVP_TEAM_ALLIANCE, PVP_TEAM_HORDE, RemoveFromBGFreeSlotQueue(), sBattlegroundMgr, SCORE_BONUS_HONOR, SendBroadcastText(), PreparedStatementBase::SetData(), SetStatus(), SetWinner(), SOUND_ALLIANCE_WINS, SOUND_HORDE_WINS, SPELL_AURA_MOD_SHAPESHIFT, sScriptMgr, STATUS_IN_PROGRESS, STATUS_WAIT_LEAVE, sWorld, TIME_TO_AUTOREMOVE, and UpdatePlayerScore().

Referenced by _ProcessProgress(), EndBattleground(), Arena::EndBattleground(), BattlegroundAB::EndBattleground(), BattlegroundAV::EndBattleground(), BattlegroundEY::EndBattleground(), BattlegroundSA::EndBattleground(), BattlegroundWS::EndBattleground(), BattlegroundIC::HandleKillPlayer(), BattlegroundIC::HandleKillUnit(), and Update().

◆ EndBattleground() [2/2]

virtual void Battleground::EndBattleground ( TeamId winnerTeamId )

inlinevirtual

Deprecated:: need delete

Reimplemented in Arena, BattlegroundAB, BattlegroundAV, BattlegroundEY, BattlegroundSA, and BattlegroundWS.

    {
        EndBattleground(GetPvPTeamId(winnerTeamId));
    }

References EndBattleground(), and GetPvPTeamId().

◆ EndNow()

void Battleground::EndNow ( )

protected

{
    RemoveFromBGFreeSlotQueue();
    SetStatus(STATUS_WAIT_LEAVE);
    SetEndTime(0);
}

References RemoveFromBGFreeSlotQueue(), SetEndTime(), SetStatus(), and STATUS_WAIT_LEAVE.

Referenced by _ProcessJoin(), and AddSpiritGuide().

◆ EventPlayerClickedOnFlag()

virtual void Battleground::EventPlayerClickedOnFlag	(	Player *	,
		GameObject *
	)

inlinevirtual

Reimplemented in BattlegroundEY, BattlegroundWS, BattlegroundIC, BattlegroundAB, BattlegroundAV, and BattlegroundSA.

515{}

Referenced by GameObject::Use().

◆ EventPlayerDamagedGO()

virtual void Battleground::EventPlayerDamagedGO	(	Player *	,
		GameObject *	,
		uint32
	)

inlinevirtual

Reimplemented in BattlegroundIC, and BattlegroundSA.

516{}

◆ EventPlayerDroppedFlag()

virtual void Battleground::EventPlayerDroppedFlag ( Player * )

inlinevirtual

Reimplemented in BattlegroundEY, and BattlegroundWS.

514{}

◆ EventPlayerUsedGO()

virtual void Battleground::EventPlayerUsedGO	(	Player *	,
		GameObject *
	)

inlinevirtual

Reimplemented in BattlegroundSA.

517{}

◆ FillInitialWorldStates()

virtual void Battleground::FillInitialWorldStates ( WorldPackets::WorldState::InitWorldStates & )

inlinevirtual

Reimplemented in Arena, BattlegroundAB, BattlegroundAV, BattlegroundBE, BattlegroundDS, BattlegroundEY, BattlegroundIC, BattlegroundNA, BattlegroundRL, BattlegroundRV, BattlegroundSA, and BattlegroundWS.

451{ }

Referenced by Player::SendInitWorldStates().

◆ FindBgMap()

BattlegroundMap * Battleground::FindBgMap ( ) const

inline

441{ return m_Map; }

References m_Map.

Referenced by _ProcessJoin(), AddCreature(), AddObject(), BattlegroundWS::CheckFlagKeeperInArea(), Player::GetBattleground(), HandleTriggerBuff(), BattlegroundWS::PostUpdateImpl(), BattlegroundWS::RemoveAssaultAuras(), BattlegroundEY::RespawnFlagAfterDrop(), and SpawnBGObject().

◆ GetAlivePlayersCountByTeam()

uint32 Battleground::GetAlivePlayersCountByTeam ( TeamId teamId ) const

{
    uint32 count = 0;
    for (BattlegroundPlayerMap::const_iterator itr = m_Players.begin(); itr != m_Players.end(); ++itr)
        if (itr->second->IsAlive() && !itr->second->HasByteFlag(UNIT_FIELD_BYTES_2, 3, FORM_SPIRITOFREDEMPTION) && itr->second->GetBgTeamId() == teamId)
            ++count;
 
    return count;
}

References FORM_SPIRITOFREDEMPTION, m_Players, and UNIT_FIELD_BYTES_2.

Referenced by Arena::CheckWinConditions(), Arena::EndBattleground(), Arena::FillInitialWorldStates(), and Arena::UpdateArenaWorldState().

◆ GetArenaMatchmakerRating()

uint32 Battleground::GetArenaMatchmakerRating ( TeamId teamId ) const

inline

504{ return m_ArenaTeamMMR[teamId]; }

References m_ArenaTeamMMR.

Referenced by Arena::EndBattleground(), and Arena::RemovePlayerAtLeave().

◆ GetArenaTeamIdForTeam()

uint32 Battleground::GetArenaTeamIdForTeam ( TeamId teamId ) const

inline

502{ return m_ArenaTeamIds[teamId]; }

References m_ArenaTeamIds.

Referenced by Arena::EndBattleground(), and Arena::RemovePlayerAtLeave().

◆ GetArenaType()

uint8 Battleground::GetArenaType ( ) const

inline

348{ return m_ArenaType; }

References m_ArenaType.

Referenced by _ProcessJoin(), EndBattleground(), Arena::EndBattleground(), WorldSession::HandleBattleFieldPortOpcode(), misc_commandscript::HandleSkirmishCommand(), achievement_arena_by_type::OnCheck(), PlayerAddedToBGCheckIfBGIsRunning(), ReadyMarkerClicked(), RemovePlayerAtLeave(), and AchievementMgr::UpdateAchievementCriteria().

◆ GetBGCreature()

Creature * Battleground::GetBGCreature ( uint32 type )

{
    Creature* creature = GetBgMap()->GetCreature(BgCreatures[type]);
    if (!creature)
        LOG_ERROR("bg.battleground", "Battleground::GetBGCreature: creature (type: {}, {}) not found for BG (map: {}, instance id: {})!",
                       type, BgCreatures[type].ToString(), m_MapId, m_InstanceID);
    return creature;
}

References BgCreatures, GetBgMap(), Map::GetCreature(), LOG_ERROR, m_InstanceID, and m_MapId.

Referenced by BattlegroundSA::CaptureGraveyard(), BattlegroundAV::ChangeMineOwner(), BattlegroundSA::DemolisherStartState(), BattlegroundAV::EventPlayerAssaultsPoint(), BattlegroundAV::EventPlayerDefendsPoint(), BattlegroundAV::EventPlayerDestroyedPoint(), BattlegroundIC::HandleCapturedNodes(), BattlegroundAV::HandleKillUnit(), BattlegroundSA::OverrideGunFaction(), BattlegroundAV::PostUpdateImpl(), BattlegroundDS::PostUpdateImpl(), BattlegroundIC::PostUpdateImpl(), BattlegroundIC::SetupBattleground(), BattlegroundIC::TurnBosses(), and BattlegroundSA::UpdateDemolisherSpawns().

◆ GetBgMap()

BattlegroundMap * Battleground::GetBgMap ( ) const

inline

◆ GetBGObject()

GameObject * Battleground::GetBGObject ( uint32 type )

{
    GameObject* obj = GetBgMap()->GetGameObject(BgObjects[type]);
    if (!obj)
        LOG_ERROR("bg.battleground", "Battleground::GetBGObject: gameobject (type: {}, {}) not found for BG (map: {}, instance id: {})!",
                       type, BgObjects[type].ToString(), m_MapId, m_InstanceID);
    return obj;
}

References BgObjects, GetBgMap(), Map::GetGameObject(), LOG_ERROR, m_InstanceID, and m_MapId.

Referenced by BattlegroundSA::DemolisherStartState(), BattlegroundIC::DestroyGate(), BattlegroundSA::DestroyGate(), BattlegroundIC::EventPlayerClickedOnFlag(), BattlegroundSA::EventPlayerDamagedGO(), BattlegroundIC::HandleCapturedNodes(), BattlegroundIC::PostUpdateImpl(), BattlegroundRV::PostUpdateImpl(), BattlegroundSA::ResetObjs(), BattlegroundSA::SendTransportInit(), BattlegroundSA::SendTransportsRemove(), BattlegroundIC::SetupBattleground(), BattlegroundRV::SetupBattleground(), BattlegroundIC::StartingEventOpenDoors(), BattlegroundSA::StartShips(), BattlegroundSA::UpdateObjectInteractionFlags(), and BattlegroundEY::UpdatePointsState().

◆ GetBgRaid()

Group * Battleground::GetBgRaid ( TeamId teamId ) const

inline

482{ return m_BgRaids[teamId]; }

References m_BgRaids.

Referenced by AddOrSetPlayerToCorrectBgGroup(), RemovePlayerAtLeave(), and Group::~Group().

◆ GetBgTypeID()

BattlegroundTypeId Battleground::GetBgTypeID ( bool GetRandom = false ) const

inline

320{ return GetRandom ? m_RandomTypeID : m_RealTypeID; }

References m_RandomTypeID, and m_RealTypeID.

Referenced by _ProcessJoin(), BattlegroundMgr::AddBattleground(), BattlegroundQueue::BattlegroundQueueUpdate(), BattlegroundMgr::BuildBattlegroundStatusPacket(), BGSpamProtect::CanAnnounce(), Group::CanJoinBattlegroundQueue(), EndBattleground(), BattlegroundAV::EndBattleground(), GetTeamScore(), WorldSession::HandleBattleFieldPortOpcode(), WorldSession::HandleBattlemasterJoinArena(), WorldSession::HandleBattlemasterJoinOpcode(), misc_commandscript::HandleSkirmishCommand(), BattlegroundQueue::InviteGroupToBG(), SpellArea::IsFitToRequirements(), achievement_resilient_victory::OnCheck(), achievement_bg_ic_resource_glut::OnCheck(), achievement_everything_counts::OnCheck(), achievement_bg_av_perfection::OnCheck(), achievement_sa_defense_of_the_ancients::OnCheck(), achievement_not_even_a_scratch::OnCheck(), achievement_save_the_day::OnCheck(), RemovePlayerAtLeave(), Player::SendInitWorldStates(), BattlegroundAB::SetupBattleground(), BattlegroundAV::SetupBattleground(), BattlegroundEY::SetupBattleground(), BattlegroundWS::SetupBattleground(), ToBattlegroundAB(), ToBattlegroundAB(), ToBattlegroundAV(), ToBattlegroundAV(), ToBattlegroundBE(), ToBattlegroundBE(), ToBattlegroundDS(), ToBattlegroundDS(), ToBattlegroundEY(), ToBattlegroundEY(), ToBattlegroundIC(), ToBattlegroundIC(), ToBattlegroundNA(), ToBattlegroundNA(), ToBattlegroundRL(), ToBattlegroundRL(), ToBattlegroundRV(), ToBattlegroundRV(), ToBattlegroundSA(), ToBattlegroundSA(), ToBattlegroundWS(), ToBattlegroundWS(), GameObject::Use(), and ~Battleground().

◆ GetBonusHonorFromKill()

uint32 Battleground::GetBonusHonorFromKill ( uint32 kills ) const

{
    //variable kills means how many honorable kills you scored (so we need kills * honor_for_one_kill)
    uint32 maxLevel = std::min<uint32>(GetMaxLevel(), 80U);
    return Acore::Honor::hk_honor_at_level(maxLevel, float(kills));
}

References GetMaxLevel(), and Acore::Honor::hk_honor_at_level().

Referenced by BattlegroundEY::AddPoints(), BattlegroundSA::DestroyGate(), EndBattleground(), BattlegroundAB::EndBattleground(), BattlegroundAV::EndBattleground(), BattlegroundEY::EndBattleground(), BattlegroundSA::EndBattleground(), BattlegroundWS::EndBattleground(), BattlegroundWS::EventPlayerCapturedFlag(), BattlegroundAV::EventPlayerDestroyedPoint(), BattlegroundAV::HandleKillUnit(), and BattlegroundAB::PostUpdateImpl().

◆ GetBracketId()

BattlegroundBracketId Battleground::GetBracketId ( ) const

inline

321{ return m_BracketId; }

Battleground::m_BracketId

BattlegroundBracketId m_BracketId

Definition Battleground.h:661

References m_BracketId.

Referenced by BattlegroundQueue::BattlegroundQueueUpdate(), BGQueueRemoveEvent::Execute(), misc_commandscript::HandleSkirmishCommand(), RemovePlayerAtLeave(), and BattlegroundMgr::Update().

◆ GetClientInstanceID()

uint32 Battleground::GetClientInstanceID ( ) const

inline

324{ return m_ClientInstanceID; }

References m_ClientInstanceID.

Referenced by BattlegroundMgr::BuildBattlegroundStatusPacket(), and BattlegroundMgr::Update().

◆ GetClosestGraveyard()

GraveyardStruct const * Battleground::GetClosestGraveyard ( Player * player )

virtual

Reimplemented in BattlegroundAB, BattlegroundAV, BattlegroundEY, BattlegroundIC, BattlegroundSA, and BattlegroundWS.

{
    return sGraveyard->GetClosestGraveyard(player, player->GetBgTeamId());
}

References Player::GetBgTeamId(), and sGraveyard.

Referenced by RelocateDeadPlayers().

◆ GetEndTime()

uint32 Battleground::GetEndTime ( ) const

inline

326{ return m_EndTime; }

References m_EndTime.

Referenced by PlayerAddedToBGCheckIfBGIsRunning().

◆ GetFlagPickerGUID()

virtual ObjectGuid Battleground::GetFlagPickerGUID ( TeamId = TEAM_NEUTRAL ) const

inlinevirtual

Reimplemented in BattlegroundWS, and BattlegroundEY.

564{ return ObjectGuid::Empty; }

ObjectGuid::Empty

static ObjectGuid const Empty

Definition ObjectGuid.h:120

References ObjectGuid::Empty.

Referenced by WorldSession::HandleBattlegroundPlayerPositionsOpcode().

◆ GetFreeSlotsForTeam()

uint32 Battleground::GetFreeSlotsForTeam ( TeamId teamId ) const

{
    if (!(GetStatus() == STATUS_IN_PROGRESS || GetStatus() == STATUS_WAIT_JOIN))
        return 0;
 
    // if CONFIG_BATTLEGROUND_INVITATION_TYPE == BG_QUEUE_INVITATION_TYPE_NO_BALANCE, invite everyone unless the BG is full
    if (sWorld->getIntConfig(CONFIG_BATTLEGROUND_INVITATION_TYPE) == BG_QUEUE_INVITATION_TYPE_NO_BALANCE)
        return (GetInvitedCount(teamId) < GetMaxPlayersPerTeam()) ? GetMaxPlayersPerTeam() - GetInvitedCount(teamId) : 0;
 
    // if BG is already started or CONFIG_BATTLEGROUND_INVITATION_TYPE != BG_QUEUE_INVITATION_TYPE_NO_BALANCE, do not allow to join too many players of one faction
    uint32 thisTeamInvitedCount = teamId == TEAM_ALLIANCE ? GetInvitedCount(TEAM_ALLIANCE) : GetInvitedCount(TEAM_HORDE);
    uint32 thisTeamPlayersCount = teamId == TEAM_ALLIANCE ? GetPlayersCountByTeam(TEAM_ALLIANCE) : GetPlayersCountByTeam(TEAM_HORDE);
    uint32 otherTeamInvitedCount = teamId == TEAM_ALLIANCE ? GetInvitedCount(TEAM_HORDE) : GetInvitedCount(TEAM_ALLIANCE);
    uint32 otherTeamPlayersCount = teamId == TEAM_ALLIANCE ? GetPlayersCountByTeam(TEAM_HORDE) : GetPlayersCountByTeam(TEAM_ALLIANCE);
 
    // difference based on ppl invited (not necessarily entered battle)
    // default: allow 0
    uint32 diff = 0;
    uint32 maxPlayersPerTeam = GetMaxPlayersPerTeam();
    uint32 minPlayersPerTeam = GetMinPlayersPerTeam();
 
    // allow join one person if the sides are equal (to fill up bg to minPlayerPerTeam)
    if (otherTeamInvitedCount == thisTeamInvitedCount)
        diff = 1;
    else if (otherTeamInvitedCount > thisTeamInvitedCount) // allow join more ppl if the other side has more players
        diff = otherTeamInvitedCount - thisTeamInvitedCount;
 
    // difference based on max players per team (don't allow inviting more)
    uint32 diff2 = (thisTeamInvitedCount < maxPlayersPerTeam) ? maxPlayersPerTeam - thisTeamInvitedCount : 0;
 
    // difference based on players who already entered
    // default: allow 0
    uint32 diff3 = 0;
 
    // allow join one person if the sides are equal (to fill up bg minPlayerPerTeam)
    if (otherTeamPlayersCount == thisTeamPlayersCount)
        diff3 = 1;
    else if (otherTeamPlayersCount > thisTeamPlayersCount) // allow join more ppl if the other side has more players
        diff3 = otherTeamPlayersCount - thisTeamPlayersCount;
    else if (thisTeamInvitedCount <= minPlayersPerTeam) // or other side has less than minPlayersPerTeam
        diff3 = minPlayersPerTeam - thisTeamInvitedCount + 1;
 
    // return the minimum of the 3 differences
    // min of diff, diff2 and diff3
    return std::min({ diff, diff2, diff3 });
}

References BG_QUEUE_INVITATION_TYPE_NO_BALANCE, CONFIG_BATTLEGROUND_INVITATION_TYPE, GetInvitedCount(), GetMaxPlayersPerTeam(), GetMinPlayersPerTeam(), GetPlayersCountByTeam(), GetStatus(), STATUS_IN_PROGRESS, STATUS_WAIT_JOIN, sWorld, TEAM_ALLIANCE, and TEAM_HORDE.

Referenced by BattlegroundQueue::FillPlayersToBG(), GetMaxFreeSlots(), and HasFreeSlots().

◆ GetInstanceID()

uint32 Battleground::GetInstanceID ( ) const

inline

322{ return m_InstanceID; }

References m_InstanceID.

Referenced by BattlegroundMgr::AddBattleground(), WorldSession::HandleBattleFieldPortOpcode(), misc_commandscript::HandleSkirmishCommand(), BattlegroundQueue::InviteGroupToBG(), and ~Battleground().

◆ GetInvitedCount()

uint32 Battleground::GetInvitedCount ( TeamId teamId ) const

inline

388{ return m_BgInvitedPlayers[teamId]; }

References m_BgInvitedPlayers.

Referenced by GetFreeSlotsForTeam(), and Update().

◆ GetLastResurrectTime()

uint32 Battleground::GetLastResurrectTime ( ) const

inline

327{ return m_LastResurrectTime; }

References m_LastResurrectTime.

Referenced by BattlegroundMgr::SendAreaSpiritHealerQueryOpcode().

◆ GetMapId()

uint32 Battleground::GetMapId ( ) const

inline

436{ return m_MapId; }

References m_MapId.

Referenced by _CheckSafePositions(), AddPlayer(), BattlegroundQueue::BattlegroundQueueAnnouncerUpdate(), BattlegroundQueue::BattlegroundQueueUpdate(), BattlegroundMgr::BuildBattlegroundStatusPacket(), Group::CanJoinBattlegroundQueue(), BattlegroundSA::CaptureGraveyard(), MapInstanced::CreateBattleground(), BattlegroundIC::DoAction(), Arena::EndBattleground(), WorldSession::HandleBattleFieldPortOpcode(), WorldSession::HandleBattlefieldStatusOpcode(), WorldSession::HandleBattlemasterJoinArena(), WorldSession::HandleBattlemasterJoinOpcode(), misc_commandscript::HandleSkirmishCommand(), RelocateDeadPlayers(), and RemovePlayerAtLeave().

◆ GetMaxFreeSlots()

uint32 Battleground::GetMaxFreeSlots ( ) const

{
    return std::max<uint32>(GetFreeSlotsForTeam(TEAM_ALLIANCE), GetFreeSlotsForTeam(TEAM_HORDE));
}

References GetFreeSlotsForTeam(), TEAM_ALLIANCE, and TEAM_HORDE.

◆ GetMaxLevel()

uint32 Battleground::GetMaxLevel ( ) const

inline

330{ return m_LevelMax; }

References m_LevelMax.

Referenced by _ProcessJoin(), BattlegroundMgr::BuildBattlegroundStatusPacket(), Player::GetBGAccessByLevel(), GetBonusHonorFromKill(), GetUniqueBracketId(), WorldSession::HandleBattleFieldPortOpcode(), and isMaxLevel().

◆ GetMaxPlayersPerTeam()

uint32 Battleground::GetMaxPlayersPerTeam ( ) const

inline

340{ return m_MaxPlayersPerTeam; }

References m_MaxPlayersPerTeam.

Referenced by BattlegroundQueue::BattlegroundQueueUpdate(), GetFreeSlotsForTeam(), and WorldSession::HandleBattlemasterJoinOpcode().

◆ GetMinLevel()

uint32 Battleground::GetMinLevel ( ) const

inline

329{ return m_LevelMin; }

References m_LevelMin.

Referenced by _ProcessJoin(), BattlegroundMgr::BuildBattlegroundStatusPacket(), MapInstanced::CreateBattleground(), and isMaxLevel().

◆ GetMinPlayersPerTeam()

uint32 Battleground::GetMinPlayersPerTeam ( ) const

inline

    {
        auto lowLevelsOverride = sWorld->getIntConfig(CONFIG_BATTLEGROUND_OVERRIDE_LOWLEVELS_MINPLAYERS);
        return (lowLevelsOverride && !isTemplate() && !isMaxLevel() && !isArena()) ? lowLevelsOverride : m_MinPlayersPerTeam;
    }

References CONFIG_BATTLEGROUND_OVERRIDE_LOWLEVELS_MINPLAYERS, isArena(), isMaxLevel(), isTemplate(), m_MinPlayersPerTeam, and sWorld.

Referenced by Group::CanJoinBattlegroundQueue(), GetFreeSlotsForTeam(), GetMinPlayersPerTeam(), GetPrematureWinner(), WorldSession::HandleBattlemasterJoinOpcode(), and Update().

◆ GetName()

std::string Battleground::GetName ( ) const

inline

319{ return m_Name; }

Battleground::m_Name

std::string m_Name

Definition Battleground.h:672

References m_Name.

Referenced by _ProcessJoin(), BattlegroundQueue::BattlegroundQueueAnnouncerUpdate(), BattlegroundQueue::SendJoinMessageArenaQueue(), BattlegroundQueue::SendMessageBGQueue(), and ~Battleground().

◆ GetObjectType()

int32 Battleground::GetObjectType ( ObjectGuid guid )

{
    for (uint32 i = 0; i < BgObjects.size(); ++i)
        if (BgObjects[i] == guid)
            return i;
 
    LOG_ERROR("bg.battleground", "Battleground::GetObjectType: player used gameobject ({}) which is not in internal data for BG (map: {}, instance id: {}), cheating?",
                   guid.ToString(), m_MapId, m_InstanceID);
 
    return -1;
}

References BgObjects, LOG_ERROR, m_InstanceID, m_MapId, and ObjectGuid::ToString().

Referenced by BattlegroundAV::EventPlayerClickedOnFlag().

◆ GetOtherTeamId()

TeamId Battleground::GetOtherTeamId ( TeamId teamId )

static

{
    return teamId != TEAM_NEUTRAL ? (teamId == TEAM_ALLIANCE ? TEAM_HORDE : TEAM_ALLIANCE) : TEAM_NEUTRAL;
}

References TEAM_ALLIANCE, TEAM_HORDE, and TEAM_NEUTRAL.

Referenced by Arena::EndBattleground(), BattlegroundWS::EventPlayerCapturedFlag(), BattlegroundWS::EventPlayerDroppedFlag(), BattlegroundIC::HandleCapturedNodes(), BattlegroundAB::PostUpdateImpl(), BattlegroundSA::PostUpdateImpl(), Arena::RemovePlayerAtLeave(), BattlegroundSA::ResetObjs(), and BattlegroundAV::UpdateScore().

◆ GetPlayers()

BattlegroundPlayerMap const & Battleground::GetPlayers ( ) const

inline

409{ return m_Players; }

References m_Players.

Referenced by _CheckSafePositions(), _ProcessJoin(), BattlegroundAB::ApplyPhaseMask(), Arena::EndBattleground(), BattlegroundSA::EventPlayerUsedGO(), ArenaSpectator::HandleResetCommand(), Player::NeedSendSpectatorData(), BattlegroundSA::PostUpdateImpl(), BattlegroundSA::ResetObjs(), BattlegroundDS::StartingEventOpenDoors(), BattlegroundSA::StartShips(), StartTimedAchievement(), BattlegroundSA::TeleportPlayers(), and BattlegroundEY::UpdatePointsState().

◆ GetPlayerScores()

BattlegroundScoreMap const * Battleground::GetPlayerScores ( ) const

inline

418{ return &PlayerScores; }

References PlayerScores.

Referenced by BuildPvPLogDataPacket().

◆ GetPlayerScoresSize()

std::size_t Battleground::GetPlayerScoresSize ( ) const

inline

419{ return PlayerScores.size(); }

References PlayerScores.

◆ GetPlayersCountByTeam()

uint32 Battleground::GetPlayersCountByTeam ( TeamId teamId ) const

inline

488{ return m_PlayersCount[teamId]; }

References m_PlayersCount.

Referenced by Arena::CheckWinConditions(), GetFreeSlotsForTeam(), GetPrematureWinner(), and Update().

◆ GetPlayersSize()

uint32 Battleground::GetPlayersSize ( ) const

inline

410{ return m_Players.size(); }

References m_Players.

Referenced by HandleTriggerBuff(), and Update().

◆ GetPrematureWinner()

TeamId Battleground::GetPrematureWinner ( )

virtual

Reimplemented in BattlegroundAB, BattlegroundAV, BattlegroundEY, and BattlegroundWS.

{
    if (GetPlayersCountByTeam(TEAM_ALLIANCE) >= GetMinPlayersPerTeam())
        return TEAM_ALLIANCE;
    else if (GetPlayersCountByTeam(TEAM_HORDE) >= GetMinPlayersPerTeam())
        return TEAM_HORDE;
 
    return TEAM_NEUTRAL;
}

References GetMinPlayersPerTeam(), GetPlayersCountByTeam(), TEAM_ALLIANCE, TEAM_HORDE, and TEAM_NEUTRAL.

Referenced by _ProcessProgress(), BattlegroundAB::GetPrematureWinner(), BattlegroundAV::GetPrematureWinner(), BattlegroundEY::GetPrematureWinner(), and BattlegroundWS::GetPrematureWinner().

◆ GetRealRepFactionForPlayer()

uint32 Battleground::GetRealRepFactionForPlayer	(	uint32	factionId,
		Player *	player
	)

{
    if (player)
    {
        // if the bg team is not the original team, reverse reputation
        if (player->GetBgTeamId() != player->GetTeamId(true))
        {
            switch (factionId)
            {
                case BG_REP_AB_ALLIANCE:
                    return BG_REP_AB_HORDE;
                case BG_REP_AB_HORDE:
                    return BG_REP_AB_ALLIANCE;
                case BG_REP_AV_ALLIANCE:
                    return BG_REP_AV_HORDE;
                case BG_REP_AV_HORDE:
                    return BG_REP_AV_ALLIANCE;
                case BG_REP_WS_ALLIANCE:
                    return BG_REP_WS_HORDE;
                case BG_REP_WS_HORDE:
                    return BG_REP_WS_ALLIANCE;
            }
        }
    }
 
    return factionId;
}

References BG_REP_AB_ALLIANCE, BG_REP_AB_HORDE, BG_REP_AV_ALLIANCE, BG_REP_AV_HORDE, BG_REP_WS_ALLIANCE, BG_REP_WS_HORDE, Player::GetBgTeamId(), and Player::GetTeamId().

Referenced by RewardReputationToTeam().

◆ GetReviveQueueSize()

uint32 Battleground::GetReviveQueueSize ( ) const

inline

421{ return m_ReviveQueue.size(); }

References m_ReviveQueue.

Referenced by _ProcessResurrect().

◆ GetScriptId()

uint32 Battleground::GetScriptId ( ) const

inline

350{ return ScriptId; }

References ScriptId.

◆ GetSpectators()

const SpectatorList & Battleground::GetSpectators ( ) const

inline

399{ return m_Spectators; }

References m_Spectators.

◆ GetStartDelayTime()

int32 Battleground::GetStartDelayTime ( ) const

inline

347{ return m_StartDelayTime; }

References m_StartDelayTime.

Referenced by _ProcessJoin(), Arena::EndBattleground(), and ReadyMarkerClicked().

◆ GetStartMaxDist()

float Battleground::GetStartMaxDist ( ) const

inline

447{ return m_StartMaxDist; }

References m_StartMaxDist.

Referenced by _CheckSafePositions().

◆ GetStartTime()

uint32 Battleground::GetStartTime ( ) const

inline

325{ return m_StartTime; }

References m_StartTime.

Referenced by _ProcessJoin(), EndBattleground(), Arena::EndBattleground(), BattlegroundWS::GetMatchTime(), WorldSession::HandleBattleFieldPortOpcode(), ArenaSpectator::HandleResetCommand(), misc_commandscript::HandleSkirmishCommand(), PlayerAddedToBGCheckIfBGIsRunning(), BattlegroundWS::PostUpdateImpl(), Player::ReportedAfkBy(), and Update().

◆ GetStatus()

BattlegroundStatus Battleground::GetStatus ( ) const

inline

323{ return m_Status; }

References m_Status.

Referenced by _ProcessJoin(), AddPlayer(), BattlegroundQueue::BattlegroundQueueUpdate(), BuildPvPLogDataPacket(), BattlegroundWS::CheckFlagKeeperInArea(), MapInstanced::CreateInstanceForPlayer(), EndBattleground(), Arena::EndBattleground(), BattlegroundAV::EventPlayerAssaultsPoint(), BattlegroundWS::EventPlayerCapturedFlag(), BattlegroundEY::EventPlayerClickedOnFlag(), BattlegroundWS::EventPlayerClickedOnFlag(), BattlegroundIC::EventPlayerClickedOnFlag(), BattlegroundAB::EventPlayerClickedOnFlag(), BattlegroundAV::EventPlayerClickedOnFlag(), BattlegroundAV::EventPlayerDefendsPoint(), BattlegroundEY::EventPlayerDroppedFlag(), BattlegroundWS::EventPlayerDroppedFlag(), BGQueueRemoveEvent::Execute(), BattlegroundAV::FillInitialWorldStates(), BattlegroundWS::FillInitialWorldStates(), BattlegroundWS::GetClosestGraveyard(), GetFreeSlotsForTeam(), BattlegroundAB::HandleAreaTrigger(), BattlegroundAV::HandleAreaTrigger(), BattlegroundBE::HandleAreaTrigger(), BattlegroundDS::HandleAreaTrigger(), BattlegroundEY::HandleAreaTrigger(), BattlegroundIC::HandleAreaTrigger(), BattlegroundNA::HandleAreaTrigger(), BattlegroundRL::HandleAreaTrigger(), BattlegroundRV::HandleAreaTrigger(), BattlegroundSA::HandleAreaTrigger(), BattlegroundWS::HandleAreaTrigger(), WorldSession::HandleBattleFieldPortOpcode(), Arena::HandleKillPlayer(), BattlegroundAV::HandleKillPlayer(), BattlegroundEY::HandleKillPlayer(), BattlegroundIC::HandleKillPlayer(), BattlegroundWS::HandleKillPlayer(), BattlegroundAV::HandleKillUnit(), BattlegroundIC::HandleKillUnit(), BattlegroundAV::HandleQuestComplete(), ArenaSpectator::HandleResetCommand(), ArenaSpectator::HandleSpectatorSpectateCommand(), ArenaSpectator::HandleSpectatorWatchCommand(), HandleTriggerBuff(), HasFreeSlots(), Player::LeaveBattleground(), Player::NeedSendSpectatorData(), PlayerAddedToBGCheckIfBGIsRunning(), BattlegroundAB::PostUpdateImpl(), BattlegroundAV::PostUpdateImpl(), BattlegroundDS::PostUpdateImpl(), BattlegroundEY::PostUpdateImpl(), BattlegroundIC::PostUpdateImpl(), BattlegroundRV::PostUpdateImpl(), BattlegroundSA::PostUpdateImpl(), BattlegroundWS::PostUpdateImpl(), ReadyMarkerClicked(), Arena::RemovePlayer(), RemovePlayerAtLeave(), Arena::RemovePlayerAtLeave(), Player::ReportedAfkBy(), BattlegroundWS::RespawnFlagAfterDrop(), and Update().

◆ GetTeamScore()

uint32 Battleground::GetTeamScore ( TeamId teamId ) const

{
    if (teamId == TEAM_ALLIANCE || teamId == TEAM_HORDE)
        return m_TeamScores[teamId];
 
    LOG_ERROR("bg.battleground", "GetTeamScore with wrong Team {} for BG {}", teamId, GetBgTypeID());
    return 0;
}

References GetBgTypeID(), LOG_ERROR, m_TeamScores, TEAM_ALLIANCE, and TEAM_HORDE.

Referenced by BattlegroundWS::EventPlayerCapturedFlag(), BattlegroundEY::FillInitialWorldStates(), BattlegroundWS::FillInitialWorldStates(), BattlegroundAV::GetPrematureWinner(), BattlegroundEY::GetPrematureWinner(), BattlegroundWS::GetPrematureWinner(), AchievementCriteriaData::Meets(), and BattlegroundWS::PostUpdateImpl().

◆ GetTeamStartPosition()

Position const * Battleground::GetTeamStartPosition ( TeamId teamId ) const

{
    ASSERT(teamId < TEAM_NEUTRAL);
    return &_startPosition[teamId];
}

References _startPosition, ASSERT, and TEAM_NEUTRAL.

Referenced by _CheckSafePositions().

◆ GetUniqueBracketId()

uint8 Battleground::GetUniqueBracketId ( ) const

{
    return GetMaxLevel() / 10;
}

References GetMaxLevel().

Referenced by EndBattleground().

◆ GetWinner()

PvPTeamId Battleground::GetWinner ( ) const

inline

349{ return m_WinnerId; }

References m_WinnerId.

Referenced by BuildPvPLogDataPacket(), EndBattleground(), and AchievementCriteriaData::Meets().

◆ HandleAreaTrigger()

virtual void Battleground::HandleAreaTrigger	(	Player *	,
		uint32
	)

inlinevirtual

Reimplemented in BattlegroundAB, BattlegroundAV, BattlegroundBE, BattlegroundDS, BattlegroundEY, BattlegroundIC, BattlegroundNA, BattlegroundRL, BattlegroundRV, BattlegroundSA, and BattlegroundWS.

508{}

◆ HandleKillPlayer()

void Battleground::HandleKillPlayer	(	Player *	player,
		Player *	killer
	)

virtual

Reimplemented in Arena, BattlegroundAV, BattlegroundEY, BattlegroundIC, and BattlegroundWS.

{
    // Keep in mind that for arena this will have to be changed a bit
 
    // Add +1 deaths
    UpdatePlayerScore(victim, SCORE_DEATHS, 1);
    // Add +1 kills to group and +1 killing_blows to killer
    if (killer)
    {
        // Don't reward credit for killing ourselves, like fall damage of hellfire (warlock)
        if (killer == victim)
            return;
 
        UpdatePlayerScore(killer, SCORE_HONORABLE_KILLS, 1);
        UpdatePlayerScore(killer, SCORE_KILLING_BLOWS, 1);
 
        for (BattlegroundPlayerMap::const_iterator itr = m_Players.begin(); itr != m_Players.end(); ++itr)
        {
            Player* creditedPlayer = itr->second;
            if (creditedPlayer == killer)
                continue;
 
            if (creditedPlayer->GetBgTeamId() == killer->GetBgTeamId() && (creditedPlayer == killer || creditedPlayer->IsAtGroupRewardDistance(victim)))
                UpdatePlayerScore(creditedPlayer, SCORE_HONORABLE_KILLS, 1);
        }
    }
 
    if (!isArena())
    {
        // To be able to remove insignia -- ONLY IN Battlegrounds
        victim->SetUnitFlag(UNIT_FLAG_SKINNABLE);
        RewardXPAtKill(killer, victim);
    }
}

References Player::GetBgTeamId(), isArena(), Player::IsAtGroupRewardDistance(), m_Players, RewardXPAtKill(), SCORE_DEATHS, SCORE_HONORABLE_KILLS, SCORE_KILLING_BLOWS, Unit::SetUnitFlag(), UNIT_FLAG_SKINNABLE, and UpdatePlayerScore().

Referenced by Arena::HandleKillPlayer(), BattlegroundAV::HandleKillPlayer(), BattlegroundEY::HandleKillPlayer(), BattlegroundIC::HandleKillPlayer(), and BattlegroundWS::HandleKillPlayer().

◆ HandleKillUnit()

virtual void Battleground::HandleKillUnit	(	Creature *	,
		Player *
	)

inlinevirtual

Reimplemented in BattlegroundSA, BattlegroundAV, and BattlegroundIC.

511{ }

◆ HandlePlayerResurrect()

virtual void Battleground::HandlePlayerResurrect ( Player * )

inlinevirtual

Reimplemented in BattlegroundIC.

522{}

◆ HandlePlayerUnderMap()

virtual bool Battleground::HandlePlayerUnderMap ( Player * )

inlinevirtual

Reimplemented in BattlegroundBE, BattlegroundDS, BattlegroundNA, BattlegroundRL, and BattlegroundRV.

553{ return false; }

Referenced by WorldSession::HandleMovementOpcodes().

◆ HandleTriggerBuff()

void Battleground::HandleTriggerBuff ( GameObject * gameObject )

{
    // Xinef: crash fix?
    if (GetStatus() != STATUS_IN_PROGRESS || !GetPlayersSize() || BgObjects.empty())
        return;
 
    uint32 index = 0;
    for (; index < BgObjects.size() && BgObjects[index] != gameObject->GetGUID(); ++index);
    if (BgObjects[index] != gameObject->GetGUID())
    {
        return;
    }
 
    if (m_BuffChange)
    {
        uint8 buff = urand(0, 2);
        if (gameObject->GetEntry() != Buff_Entries[buff])
        {
            SpawnBGObject(index, RESPAWN_ONE_DAY);
            for (uint8 currBuffTypeIndex = 0; currBuffTypeIndex < 3; ++currBuffTypeIndex)
                if (gameObject->GetEntry() == Buff_Entries[currBuffTypeIndex])
                {
                    index -= currBuffTypeIndex;
                    index += buff;
                }
        }
    }
 
    uint32 respawnTime = SPEED_BUFF_RESPAWN_TIME;
    if (Map* map = FindBgMap())
    {
        if (GameObject* obj = map->GetGameObject(BgObjects[index]))
        {
            switch (obj->GetEntry())
            {
                case BG_OBJECTID_REGENBUFF_ENTRY:
                    respawnTime = RESTORATION_BUFF_RESPAWN_TIME;
                    break;
                case BG_OBJECTID_BERSERKERBUFF_ENTRY:
                    respawnTime = BERSERKING_BUFF_RESPAWN_TIME;
                    break;
                default:
                    break;
            }
        }
    }
 
    SpawnBGObject(index, respawnTime);
}

References BERSERKING_BUFF_RESPAWN_TIME, BG_OBJECTID_BERSERKERBUFF_ENTRY, BG_OBJECTID_REGENBUFF_ENTRY, BgObjects, Buff_Entries, FindBgMap(), Object::GetEntry(), Object::GetGUID(), GetPlayersSize(), GetStatus(), m_BuffChange, RESPAWN_ONE_DAY, RESTORATION_BUFF_RESPAWN_TIME, SpawnBGObject(), SPEED_BUFF_RESPAWN_TIME, STATUS_IN_PROGRESS, and urand().

◆ HasFreeSlots()

bool Battleground::HasFreeSlots ( ) const

{
    if (GetStatus() != STATUS_WAIT_JOIN && GetStatus() != STATUS_IN_PROGRESS)
        return false;
    for (uint8 i = 0; i < PVP_TEAMS_COUNT; ++i)
        if (GetFreeSlotsForTeam((TeamId)i) > 0)
            return true;
    return false;
}

References GetFreeSlotsForTeam(), GetStatus(), PVP_TEAMS_COUNT, STATUS_IN_PROGRESS, and STATUS_WAIT_JOIN.

Referenced by BattlegroundQueue::BattlegroundQueueUpdate().

◆ HaveSpectators()

bool Battleground::HaveSpectators ( )

inline

398{ return !m_Spectators.empty(); }

References m_Spectators.

Referenced by Player::NeedSendSpectatorData().

◆ IncreaseInvitedCount()

void Battleground::IncreaseInvitedCount ( TeamId teamId )

inline

387{ ++m_BgInvitedPlayers[teamId]; }

References m_BgInvitedPlayers.

Referenced by BattlegroundQueue::InviteGroupToBG().

◆ Init()

void Battleground::Init ( )

virtual

Reimplemented in BattlegroundAB, BattlegroundEY, BattlegroundRV, BattlegroundSA, and BattlegroundWS.

{
    SetWinner(PVP_TEAM_NEUTRAL);
    SetStatus(STATUS_WAIT_QUEUE);
    SetStartTime(0);
    SetEndTime(0);
    SetLastResurrectTime(0);
 
    m_Events = 0;
 
    if (m_BgInvitedPlayers[TEAM_ALLIANCE] > 0 || m_BgInvitedPlayers[TEAM_HORDE] > 0)
    {
        LOG_ERROR("bg.battleground", "Battleground::Reset: one of the counters is not 0 (alliance: {}, horde: {}) for BG (map: {}, instance id: {})!", m_BgInvitedPlayers[TEAM_ALLIANCE], m_BgInvitedPlayers[TEAM_HORDE], m_MapId, m_InstanceID);
        ABORT();
    }
 
    m_BgInvitedPlayers[TEAM_ALLIANCE] = 0;
    m_BgInvitedPlayers[TEAM_HORDE] = 0;
    _InBGFreeSlotQueue = false;
 
    m_Players.clear();
 
    for (auto const& itr : PlayerScores)
        delete itr.second;
 
    PlayerScores.clear();
 
    for (auto& itr : _arenaTeamScores)
        itr.Reset();
 
    ResetBGSubclass();
}

References _arenaTeamScores, _InBGFreeSlotQueue, ABORT, LOG_ERROR, m_BgInvitedPlayers, m_Events, m_InstanceID, m_MapId, m_Players, PlayerScores, PVP_TEAM_NEUTRAL, ResetBGSubclass(), SetEndTime(), SetLastResurrectTime(), SetStartTime(), SetStatus(), SetWinner(), STATUS_WAIT_QUEUE, TEAM_ALLIANCE, and TEAM_HORDE.

Referenced by BattlegroundMgr::CreateNewBattleground(), BattlegroundAB::Init(), BattlegroundEY::Init(), BattlegroundRV::Init(), BattlegroundSA::Init(), and BattlegroundWS::Init().

◆ isArena()

bool Battleground::isArena ( ) const

inline

◆ isBattleground()

bool Battleground::isBattleground ( ) const

inline

405{ return !m_IsArena; }

References m_IsArena.

Referenced by AddToBGFreeSlotQueue(), BattlegroundQueue::BattlegroundQueueUpdate(), BattlegroundQueue::CheckNormalMatch(), EndBattleground(), BGQueueRemoveEvent::Execute(), WorldSession::HandleBattleFieldPortOpcode(), Player::LeaveBattleground(), RemovePlayerAtLeave(), and UpdatePlayerScore().

◆ isMaxLevel()

bool Battleground::isMaxLevel ( ) const

inline

    {
        // NOTE: this only works when the BG is not a template but the real BG
        auto maxPlayerLevel = sWorld->getIntConfig(CONFIG_MAX_PLAYER_LEVEL);
        return GetMinLevel() <= maxPlayerLevel && maxPlayerLevel <= GetMaxLevel();
    }

References CONFIG_MAX_PLAYER_LEVEL, GetMaxLevel(), GetMinLevel(), and sWorld.

Referenced by GetMinPlayersPerTeam().

◆ IsPlayerInBattleground()

bool Battleground::IsPlayerInBattleground ( ObjectGuid guid ) const

{
    BattlegroundPlayerMap::const_iterator itr = m_Players.find(guid);
    if (itr != m_Players.end())
        return true;
    return false;
}

References m_Players.

Referenced by ArenaSpectator::HandleSpectatorWatchCommand().

◆ IsRandom()

bool Battleground::IsRandom ( )

inline

356{ return m_IsRandom; }

References m_IsRandom.

Referenced by EndBattleground().

◆ isRated()

bool Battleground::isRated ( ) const

inline

406{ return m_IsRated; }

References m_IsRated.

Referenced by BattlegroundQueue::BattlegroundQueueUpdate(), BattlegroundMgr::BuildBattlegroundStatusPacket(), Group::CanJoinBattlegroundQueue(), Arena::EndBattleground(), BGQueueInviteEvent::Execute(), WorldSession::HandleBattlefieldStatusOpcode(), BattlegroundQueue::InviteGroupToBG(), and Arena::RemovePlayerAtLeave().

◆ isTemplate()

bool Battleground::isTemplate ( ) const

inline

332{ return m_IsTemplate; }

References m_IsTemplate.

Referenced by GetMinPlayersPerTeam(), and GetMinPlayersPerTeam().

◆ ModifyStartDelayTime()

void Battleground::ModifyStartDelayTime ( int32 diff )

inline

377{ m_StartDelayTime -= diff; }

References m_StartDelayTime.

Referenced by _ProcessJoin().

◆ PlayerAddedToBGCheckIfBGIsRunning()

void Battleground::PlayerAddedToBGCheckIfBGIsRunning ( Player * player )

protected

{
    if (GetStatus() != STATUS_WAIT_LEAVE)
        return;
 
    WorldPacket data;
    BlockMovement(player);
 
    BuildPvPLogDataPacket(data);
    player->GetSession()->SendPacket(&data);
 
    sBattlegroundMgr->BuildBattlegroundStatusPacket(&data, this, player->GetCurrentBattlegroundQueueSlot(), STATUS_IN_PROGRESS, GetEndTime(), GetStartTime(), GetArenaType(), player->GetBgTeamId());
    player->GetSession()->SendPacket(&data);
}

References BlockMovement(), BuildPvPLogDataPacket(), GetArenaType(), Player::GetBgTeamId(), Player::GetCurrentBattlegroundQueueSlot(), GetEndTime(), Player::GetSession(), GetStartTime(), GetStatus(), sBattlegroundMgr, WorldSession::SendPacket(), STATUS_IN_PROGRESS, and STATUS_WAIT_LEAVE.

Referenced by AddPlayer().

◆ PlaySoundToAll()

void Battleground::PlaySoundToAll ( uint32 soundId )

{
    SendPacketToAll(WorldPackets::Misc::Playsound(soundID).Write());
}

References SendPacketToAll().

Referenced by _ProcessJoin(), BattlegroundAV::ChangeMineOwner(), EndBattleground(), BattlegroundWS::EventPlayerCapturedFlag(), BattlegroundEY::EventPlayerCapturedFlag(), BattlegroundEY::EventPlayerClickedOnFlag(), BattlegroundWS::EventPlayerClickedOnFlag(), BattlegroundAB::EventPlayerClickedOnFlag(), BattlegroundAB::PostUpdateImpl(), BattlegroundWS::PostUpdateImpl(), BattlegroundEY::RespawnFlag(), BattlegroundWS::RespawnFlagAfterDrop(), and BattlegroundAV::UpdateScore().

◆ PostUpdateImpl()

virtual void Battleground::PostUpdateImpl ( uint32 )

inlineprivatevirtual

Post-update hook.

Will be called after battleground update has passed. May be used to implement custom update effects in subclasses.

Parameters

diff	a time difference between two worldserver update loops in milliseconds.

See also: Update(), PreUpdateImpl().

Reimplemented in BattlegroundAB, BattlegroundAV, BattlegroundDS, BattlegroundEY, BattlegroundIC, BattlegroundRV, BattlegroundSA, and BattlegroundWS.

702{ }

Referenced by Update().

◆ PreUpdateImpl()

virtual bool Battleground::PreUpdateImpl ( uint32 )

inlineprivatevirtual

Pre-update hook.

Will be called before battleground update is started. Depending on the result of this call actual update body may be skipped.

Parameters

diff	a time difference between two worldserver update loops in milliseconds.

Returns: true if update must be performed, false otherwise.

See also: Update(), PostUpdateImpl().

689{ return true; }

Referenced by Update().

◆ ReadyMarkerClicked()

void Battleground::ReadyMarkerClicked ( Player * p )

{
    if (!isArena() || GetStatus() >= STATUS_IN_PROGRESS || GetStartDelayTime() <= BG_START_DELAY_15S || (m_Events & BG_STARTING_EVENT_3) || p->IsSpectator())
        return;
    readyMarkerClickedSet.insert(p->GetGUID());
    uint32 count = readyMarkerClickedSet.size();
    uint32 req = ArenaTeam::GetReqPlayersForType(GetArenaType());
    ChatHandler(p->GetSession()).SendNotification("You are marked as ready {}/{}", count, req);
    if (count == req)
    {
        m_Events |= BG_STARTING_EVENT_2;
        m_StartTime += GetStartDelayTime() - BG_START_DELAY_15S;
        SetStartDelayTime(BG_START_DELAY_15S);
    }
}

References BG_START_DELAY_15S, BG_STARTING_EVENT_2, BG_STARTING_EVENT_3, GetArenaType(), Object::GetGUID(), ArenaTeam::GetReqPlayersForType(), Player::GetSession(), GetStartDelayTime(), GetStatus(), isArena(), Player::IsSpectator(), m_Events, m_StartTime, readyMarkerClickedSet, ChatHandler::SendNotification(), SetStartDelayTime(), and STATUS_IN_PROGRESS.

◆ RelocateDeadPlayers()

void Battleground::RelocateDeadPlayers ( ObjectGuid queueIndex )

Relocate all players in ReviveQueue to the closest graveyard.

{
    // Those who are waiting to resurrect at this node are taken to the closest own node's graveyard
    GuidVector& ghostList = m_ReviveQueue[queueIndex];
    if (!ghostList.empty())
    {
        GraveyardStruct const* closestGrave = nullptr;
        for (ObjectGuid const& guid : ghostList)
        {
            Player* player = ObjectAccessor::FindPlayer(guid);
            if (!player)
                continue;
 
            if (!closestGrave)
                closestGrave = GetClosestGraveyard(player);
 
            if (closestGrave)
                player->TeleportTo(GetMapId(), closestGrave->x, closestGrave->y, closestGrave->z, player->GetOrientation());
        }
 
        ghostList.clear();
    }
}

References ObjectAccessor::FindPlayer(), GetClosestGraveyard(), GetMapId(), Position::GetOrientation(), m_ReviveQueue, Player::TeleportTo(), GraveyardStruct::x, GraveyardStruct::y, and GraveyardStruct::z.

Referenced by BattlegroundAV::EventPlayerAssaultsPoint(), BattlegroundIC::EventPlayerClickedOnFlag(), BattlegroundEY::EventTeamLostPoint(), and BattlegroundAB::NodeDeoccupied().

◆ RemoveAuraOnTeam()

void Battleground::RemoveAuraOnTeam	(	uint32	spellId,
		TeamId	teamId
	)

{
    for (BattlegroundPlayerMap::const_iterator itr = m_Players.begin(); itr != m_Players.end(); ++itr)
        if (itr->second->GetBgTeamId() == teamId)
            itr->second->RemoveAura(spellId);
}

References m_Players.

Referenced by BattlegroundIC::HandleCapturedNodes().

◆ RemoveFromBGFreeSlotQueue()

void Battleground::RemoveFromBGFreeSlotQueue ( )

{
    if (_InBGFreeSlotQueue)
    {
        sBattlegroundMgr->RemoveFromBGFreeSlotQueue(m_RealTypeID, m_InstanceID);
        _InBGFreeSlotQueue = false;
    }
}

References _InBGFreeSlotQueue, m_InstanceID, m_RealTypeID, and sBattlegroundMgr.

Referenced by BattlegroundQueue::BattlegroundQueueUpdate(), EndBattleground(), EndNow(), and ~Battleground().

◆ RemovePlayer()

virtual void Battleground::RemovePlayer ( Player * )

inlineprotectedvirtual

Reimplemented in Arena, BattlegroundAB, BattlegroundAV, BattlegroundEY, BattlegroundIC, BattlegroundSA, and BattlegroundWS.

623{}

Referenced by RemovePlayerAtLeave().

◆ RemovePlayerAtLeave()

void Battleground::RemovePlayerAtLeave ( Player * player )

virtual

Reimplemented in Arena.

{
    TeamId teamId = player->GetBgTeamId();
 
    // check if the player was a participant of the match, or only entered through gm command
    bool participant = false;
    BattlegroundPlayerMap::iterator itr = m_Players.find(player->GetGUID());
    if (itr != m_Players.end())
    {
        UpdatePlayersCountByTeam(teamId, true); // -1 player
        m_Players.erase(itr);
        participant = true;
    }
 
    // delete player score if exists
    auto const& itr2 = PlayerScores.find(player->GetGUID().GetCounter());
    if (itr2 != PlayerScores.end())
    {
        delete itr2->second;
        PlayerScores.erase(itr2);
    }
 
    RemovePlayerFromResurrectQueue(player);
 
    // resurrect on exit
    if (!player->IsAlive())
    {
        player->ResurrectPlayer(1.0f);
        player->SpawnCorpseBones();
    }
 
    player->RemoveAurasByType(SPELL_AURA_MOUNTED);
 
    // GetStatus might be changed in RemovePlayer - define it here
    BattlegroundStatus status = GetStatus();
 
    // BG subclass specific code
    RemovePlayer(player);
 
    // should remove spirit of redemption
    if (player->HasSpiritOfRedemptionAura())
        player->RemoveAurasByType(SPELL_AURA_MOD_SHAPESHIFT);
 
    // if the player was a match participant
    if (participant)
    {
        player->ClearAfkReports();
 
        WorldPacket data;
        sBattlegroundMgr->BuildBattlegroundStatusPacket(&data, this, player->GetCurrentBattlegroundQueueSlot(), STATUS_NONE, 0, 0, 0, TEAM_NEUTRAL);
        player->GetSession()->SendPacket(&data);
 
        BattlegroundQueueTypeId bgQueueTypeId = BattlegroundMgr::BGQueueTypeId(GetBgTypeID(), GetArenaType());
 
        // this call is important, because player, when joins to battleground, this method is not called, so it must be called when leaving bg
        player->RemoveBattlegroundQueueId(bgQueueTypeId);
 
        // remove from raid group if player is member
        if (Group* group = GetBgRaid(teamId))
            if (group->IsMember(player->GetGUID()))
                if (!group->RemoveMember(player->GetGUID())) // group was disbanded
                    SetBgRaid(teamId, nullptr);
 
        // let others know
        sBattlegroundMgr->BuildPlayerLeftBattlegroundPacket(&data, player->GetGUID());
        SendPacketToTeam(teamId, &data, player, false);
 
        // cast deserter
        if (isBattleground() && !player->IsGameMaster() && sWorld->getBoolConfig(CONFIG_BATTLEGROUND_CAST_DESERTER))
            if (status == STATUS_IN_PROGRESS || status == STATUS_WAIT_JOIN)
                player->ScheduleDelayedOperation(DELAYED_SPELL_CAST_DESERTER);
 
        DecreaseInvitedCount(teamId);
 
        //we should update battleground queue, but only if bg isn't ending
        if (isBattleground() && GetStatus() < STATUS_WAIT_LEAVE)
        {
            BattlegroundTypeId bgTypeId = GetBgTypeID();
            BattlegroundQueueTypeId bgQueueTypeId = BattlegroundMgr::BGQueueTypeId(GetBgTypeID(), GetArenaType());
 
            // a player has left the battleground, so there are free slots -> add to queue
            AddToBGFreeSlotQueue();
            sBattlegroundMgr->ScheduleQueueUpdate(0, 0, bgQueueTypeId, bgTypeId, GetBracketId());
        }
    }
 
    player->SetBattlegroundId(0, BATTLEGROUND_TYPE_NONE, PLAYER_MAX_BATTLEGROUND_QUEUES, false, false, TEAM_NEUTRAL);
 
    // Xinef: remove all criterias on bg leave
    player->ResetAchievementCriteria(ACHIEVEMENT_CRITERIA_CONDITION_BG_MAP, GetMapId(), true);
 
    sScriptMgr->OnBattlegroundRemovePlayerAtLeave(this, player);
}

References ACHIEVEMENT_CRITERIA_CONDITION_BG_MAP, AddToBGFreeSlotQueue(), BATTLEGROUND_TYPE_NONE, BattlegroundMgr::BGQueueTypeId(), Player::ClearAfkReports(), CONFIG_BATTLEGROUND_CAST_DESERTER, DecreaseInvitedCount(), DELAYED_SPELL_CAST_DESERTER, GetArenaType(), GetBgRaid(), Player::GetBgTeamId(), GetBgTypeID(), GetBracketId(), ObjectGuid::GetCounter(), Player::GetCurrentBattlegroundQueueSlot(), Object::GetGUID(), GetMapId(), Player::GetSession(), GetStatus(), Unit::HasSpiritOfRedemptionAura(), Unit::IsAlive(), isBattleground(), Player::IsGameMaster(), m_Players, PLAYER_MAX_BATTLEGROUND_QUEUES, PlayerScores, Unit::RemoveAurasByType(), Player::RemoveBattlegroundQueueId(), RemovePlayer(), RemovePlayerFromResurrectQueue(), Player::ResetAchievementCriteria(), Player::ResurrectPlayer(), sBattlegroundMgr, Player::ScheduleDelayedOperation(), WorldSession::SendPacket(), SendPacketToTeam(), Player::SetBattlegroundId(), SetBgRaid(), Player::SpawnCorpseBones(), SPELL_AURA_MOD_SHAPESHIFT, SPELL_AURA_MOUNTED, sScriptMgr, STATUS_IN_PROGRESS, STATUS_NONE, STATUS_WAIT_JOIN, STATUS_WAIT_LEAVE, sWorld, TEAM_NEUTRAL, and UpdatePlayersCountByTeam().

Referenced by Arena::RemovePlayerAtLeave().

◆ RemovePlayerFromResurrectQueue()

void Battleground::RemovePlayerFromResurrectQueue ( Player * player )

{
    for (std::map<ObjectGuid, GuidVector>::iterator itr = m_ReviveQueue.begin(); itr != m_ReviveQueue.end(); ++itr)
        for (GuidVector::iterator itr2 = itr->second.begin(); itr2 != itr->second.end(); ++itr2)
            if (*itr2 == player->GetGUID())
            {
                itr->second.erase(itr2);
                player->RemoveAurasDueToSpell(SPELL_WAITING_FOR_RESURRECT);
                return;
            }
}

References Object::GetGUID(), m_ReviveQueue, Unit::RemoveAurasDueToSpell(), and SPELL_WAITING_FOR_RESURRECT.

Referenced by RemovePlayerAtLeave().

◆ RemoveSpectator()

void Battleground::RemoveSpectator ( Player * p )

inline

397{ m_Spectators.erase(p); }

References m_Spectators.

◆ RemoveToBeTeleported()

void Battleground::RemoveToBeTeleported ( ObjectGuid spectator )

inline

401{ ToBeTeleportedMap::iterator itr = m_ToBeTeleported.find(spectator); if (itr != m_ToBeTeleported.end()) m_ToBeTeleported.erase(itr); }

References m_ToBeTeleported.

◆ ResetBGSubclass()

virtual void Battleground::ResetBGSubclass ( )

inlinevirtual

Reimplemented in BattlegroundAV.

309{ } // must be implemented in BG subclass

Referenced by Init().

◆ RewardHonorToTeam()

void Battleground::RewardHonorToTeam	(	uint32	honor,
		TeamId	teamId
	)

{
    for (BattlegroundPlayerMap::const_iterator itr = m_Players.begin(); itr != m_Players.end(); ++itr)
        if (itr->second->GetBgTeamId() == teamId)
            UpdatePlayerScore(itr->second, SCORE_BONUS_HONOR, honor);
}

References m_Players, SCORE_BONUS_HONOR, and UpdatePlayerScore().

Referenced by BattlegroundEY::AddPoints(), BattlegroundAB::EndBattleground(), BattlegroundAV::EndBattleground(), BattlegroundEY::EndBattleground(), BattlegroundSA::EndBattleground(), BattlegroundWS::EndBattleground(), BattlegroundWS::EventPlayerCapturedFlag(), BattlegroundAV::EventPlayerDestroyedPoint(), BattlegroundAV::HandleKillUnit(), BattlegroundIC::HandleKillUnit(), BattlegroundAB::PostUpdateImpl(), and BattlegroundIC::PostUpdateImpl().

◆ RewardReputationToTeam()

void Battleground::RewardReputationToTeam	(	uint32	factionId,
		uint32	reputation,
		TeamId	teamId
	)

{
    for (BattlegroundPlayerMap::const_iterator itr = m_Players.begin(); itr != m_Players.end(); ++itr)
        if (itr->second->GetBgTeamId() == teamId)
        {
            uint32 realFactionId = GetRealRepFactionForPlayer(factionId, itr->second);
 
            float repGain = static_cast<float>(reputation);
            AddPct(repGain, itr->second->GetTotalAuraModifier(SPELL_AURA_MOD_REPUTATION_GAIN));
            AddPct(repGain, itr->second->GetTotalAuraModifierByMiscValue(SPELL_AURA_MOD_FACTION_REPUTATION_GAIN, realFactionId));
            if (FactionEntry const* factionEntry = sFactionStore.LookupEntry(realFactionId))
                itr->second->GetReputationMgr().ModifyReputation(factionEntry, repGain);
        }
}

References AddPct(), GetRealRepFactionForPlayer(), m_Players, sFactionStore, SPELL_AURA_MOD_FACTION_REPUTATION_GAIN, and SPELL_AURA_MOD_REPUTATION_GAIN.

Referenced by BattlegroundAV::EndBattleground(), BattlegroundWS::EventPlayerCapturedFlag(), BattlegroundAV::EventPlayerDestroyedPoint(), BattlegroundAV::HandleKillUnit(), BattlegroundAV::HandleQuestComplete(), and BattlegroundAB::PostUpdateImpl().

◆ RewardXPAtKill()

void Battleground::RewardXPAtKill	(	Player *	killer,
		Player *	victim
	)

{
    if (sWorld->getBoolConfig(CONFIG_BG_XP_FOR_KILL) && killer && victim)
        killer->RewardPlayerAndGroupAtKill(victim, true);
}

References CONFIG_BG_XP_FOR_KILL, Player::RewardPlayerAndGroupAtKill(), and sWorld.

Referenced by HandleKillPlayer().

◆ SendBroadcastText()

void Battleground::SendBroadcastText	(	uint32	id,
		ChatMsg	msgType,
		WorldObject const *	target = `nullptr`
	)

{
    if (!sObjectMgr->GetBroadcastText(id))
    {
        LOG_ERROR("bg.battleground", "Battleground::SendBroadcastText: `broadcast_text` (ID: {}) was not found", id);
        return;
    }
 
    Acore::BroadcastTextBuilder builder(nullptr, msgType, id, GENDER_MALE, target);
    Acore::LocalizedPacketDo<Acore::BroadcastTextBuilder> localizer(builder);
    BroadcastWorker(localizer);
}

References BroadcastWorker(), GENDER_MALE, LOG_ERROR, and sObjectMgr.

◆ SendChatMessage()

void Battleground::SendChatMessage	(	Creature *	source,
		uint8	textId,
		WorldObject *	target = `nullptr`
	)

{
    sCreatureTextMgr->SendChat(source, textId, target);
}

References sCreatureTextMgr.

◆ SendPacketToAll()

void Battleground::SendPacketToAll ( WorldPacket const * packet )

{
    for (BattlegroundPlayerMap::const_iterator itr = m_Players.begin(); itr != m_Players.end(); ++itr)
        itr->second->GetSession()->SendPacket(packet);
}

References m_Players.

Referenced by PlaySoundToAll(), and UpdateWorldState().

◆ SendPacketToTeam()

void Battleground::SendPacketToTeam	(	TeamId	teamId,
		WorldPacket const *	packet,
		Player *	sender = `nullptr`,
		bool	self = `true`
	)

{
    for (BattlegroundPlayerMap::const_iterator itr = m_Players.begin(); itr != m_Players.end(); ++itr)
        if (itr->second->GetBgTeamId() == teamId && (self || sender != itr->second))
            itr->second->GetSession()->SendPacket(packet);
}

References m_Players.

Referenced by AddPlayer(), and RemovePlayerAtLeave().

◆ SetArenaMatchmakerRating()

void Battleground::SetArenaMatchmakerRating	(	TeamId	teamId,
		uint32	MMR
	)

inline

503{ m_ArenaTeamMMR[teamId] = MMR; }

References m_ArenaTeamMMR.

Referenced by BattlegroundQueue::BattlegroundQueueUpdate(), and Arena::EndBattleground().

◆ SetArenaorBGType()

void Battleground::SetArenaorBGType ( bool _isArena )

inline

372{ m_IsArena = _isArena; }

References m_IsArena.

Referenced by BattlegroundMgr::CreateBattleground().

◆ SetArenaTeamIdForTeam()

void Battleground::SetArenaTeamIdForTeam	(	TeamId	teamId,
		uint32	ArenaTeamId
	)

inline

501{ m_ArenaTeamIds[teamId] = ArenaTeamId; }

References m_ArenaTeamIds.

Referenced by BattlegroundQueue::InviteGroupToBG().

◆ SetArenaType()

void Battleground::SetArenaType ( uint8 type )

inline

371{ m_ArenaType = type; }

References m_ArenaType.

Referenced by BattlegroundMgr::CreateNewBattleground().

◆ SetBgMap()

void Battleground::SetBgMap ( BattlegroundMap * map )

inline

439{ m_Map = map; }

References m_Map.

Referenced by MapInstanced::CreateBattleground(), and BattlegroundMap::~BattlegroundMap().

◆ SetBgRaid()

void Battleground::SetBgRaid	(	TeamId	teamId,
		Group *	bg_raid
	)

{
    Group*& old_raid = m_BgRaids[teamId];
    if (old_raid)
        old_raid->SetBattlegroundGroup(nullptr);
    if (bg_raid)
        bg_raid->SetBattlegroundGroup(this);
    old_raid = bg_raid;
}

References m_BgRaids, and Group::SetBattlegroundGroup().

Referenced by AddOrSetPlayerToCorrectBgGroup(), Arena::AddPlayer(), RemovePlayerAtLeave(), and Group::~Group().

◆ SetBgTypeID()

void Battleground::SetBgTypeID ( BattlegroundTypeId TypeID )

inline

360{ m_RealTypeID = TypeID; }

TypeID

Definition ObjectGuid.h:31

References m_RealTypeID.

Referenced by BattlegroundMgr::CreateBattleground(), and BattlegroundMgr::CreateNewBattleground().

◆ SetBracket()

void Battleground::SetBracket ( PvPDifficultyEntry const * bracketEntry )

{
    m_IsTemplate = false;
    m_BracketId = bracketEntry->GetBracketId();
    SetLevelRange(bracketEntry->minLevel, bracketEntry->maxLevel);
}

References PvPDifficultyEntry::GetBracketId(), m_BracketId, m_IsTemplate, PvPDifficultyEntry::maxLevel, PvPDifficultyEntry::minLevel, and SetLevelRange().

Referenced by BattlegroundMgr::CreateNewBattleground().

◆ SetClientInstanceID()

void Battleground::SetClientInstanceID ( uint32 InstanceID )

inline

365{ m_ClientInstanceID = InstanceID; }

References m_ClientInstanceID.

Referenced by BattlegroundMgr::CreateNewBattleground().

◆ SetDroppedFlagGUID()

virtual void Battleground::SetDroppedFlagGUID	(	ObjectGuid	,
		TeamId	= `TEAM_NEUTRAL`
	)

inlinevirtual

Reimplemented in BattlegroundWS, and BattlegroundEY.

565{}

◆ SetEndTime()

void Battleground::SetEndTime ( uint32 Time )

inline

367{ m_EndTime = Time; }

References m_EndTime.

Referenced by EndNow(), and Init().

◆ SetHoliday()

void Battleground::SetHoliday ( bool is_holiday )

{
    m_HonorMode = is_holiday ? BG_HOLIDAY : BG_NORMAL;
}

References BG_HOLIDAY, BG_NORMAL, and m_HonorMode.

◆ SetInstanceID()

void Battleground::SetInstanceID ( uint32 InstanceID )

inline

363{ m_InstanceID = InstanceID; }

References m_InstanceID.

Referenced by BattlegroundMgr::CreateBattleground(), and BattlegroundMgr::CreateNewBattleground().

◆ SetLastResurrectTime()

void Battleground::SetLastResurrectTime ( uint32 Time )

inline

368{ m_LastResurrectTime = Time; }

References m_LastResurrectTime.

Referenced by Init(), and StartBattleground().

◆ SetLevelRange()

void Battleground::SetLevelRange	(	uint32	min,
		uint32	max
	)

inline

369{ m_LevelMin = min; m_LevelMax = max; }

References m_LevelMax, and m_LevelMin.

Referenced by BattlegroundMgr::CreateBattleground(), and SetBracket().

◆ SetMapId()

void Battleground::SetMapId ( uint32 MapID )

inline

435{ m_MapId = MapID; }

References m_MapId.

Referenced by BattlegroundMgr::CreateBattleground().

◆ SetMaxPlayersPerTeam()

void Battleground::SetMaxPlayersPerTeam ( uint32 MaxPlayers )

inline

380{ m_MaxPlayersPerTeam = MaxPlayers; }

References m_MaxPlayersPerTeam.

Referenced by BattlegroundMgr::CreateBattleground(), and BattlegroundMgr::CreateNewBattleground().

◆ SetMinPlayersPerTeam()

void Battleground::SetMinPlayersPerTeam ( uint32 MinPlayers )

inline

381{ m_MinPlayersPerTeam = MinPlayers; }

References m_MinPlayersPerTeam.

Referenced by BattlegroundMgr::CreateBattleground().

◆ SetName()

void Battleground::SetName ( std::string_view name )

inline

359{ m_Name = std::string(name); }

References m_Name.

Referenced by BattlegroundMgr::CreateBattleground().

◆ SetRandom()

void Battleground::SetRandom ( bool isRandom )

inline

375{ m_IsRandom = isRandom; }

References m_IsRandom.

Referenced by BattlegroundMgr::CreateBattleground(), and BattlegroundMgr::CreateNewBattleground().

◆ SetRandomTypeID()

void Battleground::SetRandomTypeID ( BattlegroundTypeId TypeID )

inline

361{ m_RandomTypeID = TypeID; }

References m_RandomTypeID.

Referenced by BattlegroundMgr::CreateNewBattleground().

◆ SetRated()

void Battleground::SetRated ( bool state )

inline

370{ m_IsRated = state; }

References m_IsRated.

Referenced by BattlegroundMgr::CreateNewBattleground(), and WorldSession::HandleBattlemasterJoinArena().

◆ SetScriptId()

void Battleground::SetScriptId ( uint32 scriptId )

inline

374{ ScriptId = scriptId; }

References ScriptId.

Referenced by BattlegroundMgr::CreateBattleground().

◆ SetStartDelayTime()

void Battleground::SetStartDelayTime ( int32 Time )

inline

378{ m_StartDelayTime = Time; }

References m_StartDelayTime.

Referenced by _ProcessJoin(), and ReadyMarkerClicked().

◆ SetStartMaxDist()

void Battleground::SetStartMaxDist ( float startMaxDist )

inline

446{ m_StartMaxDist = startMaxDist; }

References m_StartMaxDist.

Referenced by BattlegroundMgr::CreateBattleground().

◆ SetStartTime()

void Battleground::SetStartTime ( uint32 Time )

inline

366{ m_StartTime = Time; }

References m_StartTime.

Referenced by Init(), and StartBattleground().

◆ SetStatus()

void Battleground::SetStatus ( BattlegroundStatus Status )

inline

364{ m_Status = Status; }

References m_Status.

Referenced by _ProcessJoin(), BattlegroundMgr::CreateNewBattleground(), EndBattleground(), EndNow(), Init(), BattlegroundSA::PostUpdateImpl(), and BattlegroundSA::ResetObjs().

◆ SetTeamStartPosition()

void Battleground::SetTeamStartPosition	(	TeamId	teamId,
		Position const &	pos
	)

{
    ASSERT(teamId < TEAM_NEUTRAL);
    _startPosition[teamId] = pos;
}

References _startPosition, ASSERT, and TEAM_NEUTRAL.

Referenced by BattlegroundMgr::CreateBattleground().

◆ SetupBattleground()

virtual bool Battleground::SetupBattleground ( )

inlinevirtual

Reimplemented in BattlegroundAB, BattlegroundAV, BattlegroundBE, BattlegroundDS, BattlegroundEY, BattlegroundIC, BattlegroundNA, BattlegroundRL, BattlegroundRV, BattlegroundSA, and BattlegroundWS.

    {
        return true;
    }

Referenced by _ProcessJoin().

◆ SetWinner()

void Battleground::SetWinner ( PvPTeamId winner )

inline

373{ m_WinnerId = winner; }

References m_WinnerId.

Referenced by EndBattleground(), and Init().

◆ SpawnBGObject()

void Battleground::SpawnBGObject	(	uint32	type,
		uint32	respawntime,
		uint32	forceRespawnDelay = `0`
	)

{
    if (Map* map = FindBgMap())
        if (GameObject* obj = map->GetGameObject(BgObjects[type]))
        {
            if (respawntime)
                obj->SetLootState(GO_JUST_DEACTIVATED);
            else if (obj->getLootState() == GO_JUST_DEACTIVATED)
                // Change state from GO_JUST_DEACTIVATED to GO_READY in case battleground is starting again
                obj->SetLootState(GO_READY);
            obj->SetRespawnTime(respawntime);
            map->AddToMap(obj);
 
            if (forceRespawnDelay)
            {
                obj->SetRespawnDelay(forceRespawnDelay);
            }
        }
}

References BgObjects, FindBgMap(), GO_JUST_DEACTIVATED, GO_READY, and Creature::SetRespawnTime().

◆ SpectatorsSendPacket()

void Battleground::SpectatorsSendPacket ( WorldPacket & data )

{
    for (SpectatorList::const_iterator itr = m_Spectators.begin(); itr != m_Spectators.end(); ++itr)
        (*itr)->GetSession()->SendPacket(&data);
}

References m_Spectators.

◆ SpiritOfCompetitionEvent()

void Battleground::SpiritOfCompetitionEvent ( PvPTeamId winnerTeamId ) const

{
    bool isDraw = winnerTeamId == PVP_TEAM_NEUTRAL;
 
    std::vector<Player*> filteredPlayers;
    GetBgMap()->DoForAllPlayers([&](Player* player)
        {
            // Reward all eligible players the participant reward
            if (player->GetQuestStatus(QUEST_FLAG_PARTICIPANT) != QUEST_STATUS_REWARDED)
                player->CastSpell(player, SPELL_SPIRIT_OF_COMPETITION_PARTICIPANT, true);
 
            // Collect players of the winning team who has yet to recieve the winner reward
            if (!isDraw && player->GetBgTeamId() == GetTeamId(winnerTeamId) &&
                player->GetQuestStatus(QUEST_FLAG_WINNER) != QUEST_STATUS_REWARDED)
                    filteredPlayers.push_back(player);
        });
 
    // Randomly select one player from winners team to recieve the reward, if any eligible
    if (!filteredPlayers.empty())
    {
        Player* wPlayer = filteredPlayers[rand() % filteredPlayers.size()];
        wPlayer->CastSpell(wPlayer, SPELL_SPIRIT_OF_COMPETITION_WINNER, true);
    }
}

References Unit::CastSpell(), Map::DoForAllPlayers(), GetBgMap(), Player::GetBgTeamId(), Player::GetQuestStatus(), GetTeamId(), PVP_TEAM_NEUTRAL, QUEST_FLAG_PARTICIPANT, QUEST_FLAG_WINNER, QUEST_STATUS_REWARDED, SPELL_SPIRIT_OF_COMPETITION_PARTICIPANT, and SPELL_SPIRIT_OF_COMPETITION_WINNER.

◆ StartBattleground()

void Battleground::StartBattleground ( )

{
    SetStartTime(0);
    SetLastResurrectTime(0);
 
    // add BG to free slot queue
    AddToBGFreeSlotQueue();
 
    // add bg to update list
    // this must be done here, because we need to have already invited some players when first Battleground::Update() method is executed
    sBattlegroundMgr->AddBattleground(this);
 
    if (m_IsRated)
        LOG_DEBUG("bg.arena", "Arena match type: {} for Team1Id: {} - Team2Id: {} started.", m_ArenaType, m_ArenaTeamIds[TEAM_ALLIANCE], m_ArenaTeamIds[TEAM_HORDE]);
}

References AddToBGFreeSlotQueue(), LOG_DEBUG, m_ArenaTeamIds, m_ArenaType, m_IsRated, sBattlegroundMgr, SetLastResurrectTime(), SetStartTime(), TEAM_ALLIANCE, and TEAM_HORDE.

Referenced by BattlegroundQueue::BattlegroundQueueUpdate(), and misc_commandscript::HandleSkirmishCommand().

◆ StartingEventCloseDoors()

virtual void Battleground::StartingEventCloseDoors ( )

inlinevirtual

Reimplemented in BattlegroundAB, BattlegroundAV, BattlegroundBE, BattlegroundDS, BattlegroundEY, BattlegroundIC, BattlegroundNA, BattlegroundRL, BattlegroundSA, and BattlegroundWS.

307{ }

Referenced by _ProcessJoin().

◆ StartingEventOpenDoors()

virtual void Battleground::StartingEventOpenDoors ( )

inlinevirtual

Reimplemented in BattlegroundAB, BattlegroundAV, BattlegroundBE, BattlegroundDS, BattlegroundEY, BattlegroundIC, BattlegroundNA, BattlegroundRL, BattlegroundRV, BattlegroundSA, and BattlegroundWS.

308{ }

Referenced by _ProcessJoin().

◆ StartTimedAchievement()

void Battleground::StartTimedAchievement	(	AchievementCriteriaTimedTypes	type,
		uint32	entry
	)

{
    for (BattlegroundPlayerMap::const_iterator itr = GetPlayers().begin(); itr != GetPlayers().end(); ++itr)
        itr->second->StartTimedAchievement(type, entry);
}

References GetPlayers().

Referenced by BattlegroundSA::PostUpdateImpl(), BattlegroundAB::StartingEventOpenDoors(), BattlegroundAV::StartingEventOpenDoors(), BattlegroundEY::StartingEventOpenDoors(), and BattlegroundWS::StartingEventOpenDoors().

◆ ToBattlegroundAB() [1/2]

BattlegroundAB * Battleground::ToBattlegroundAB ( )

inline

579{ if (GetBgTypeID(true) == BATTLEGROUND_AB) return reinterpret_cast<BattlegroundAB*>(this); else return nullptr; }

BATTLEGROUND_AB

@ BATTLEGROUND_AB

Definition SharedDefines.h:3738

BattlegroundAB

Definition BattlegroundAB.h:251

References BATTLEGROUND_AB, and GetBgTypeID().

Referenced by achievement_resilient_victory::OnCheck().

◆ ToBattlegroundAB() [2/2]

BattlegroundAB const * Battleground::ToBattlegroundAB ( ) const

inline

580{ if (GetBgTypeID(true) == BATTLEGROUND_AB) return reinterpret_cast<const BattlegroundAB*>(this); else return nullptr; }

References BATTLEGROUND_AB, and GetBgTypeID().

◆ ToBattlegroundAV() [1/2]

BattlegroundAV * Battleground::ToBattlegroundAV ( )

inline

573{ if (GetBgTypeID(true) == BATTLEGROUND_AV) return reinterpret_cast<BattlegroundAV*>(this); else return nullptr; }

BATTLEGROUND_AV

@ BATTLEGROUND_AV

Definition SharedDefines.h:3736

BattlegroundAV

Definition BattlegroundAV.h:1758

References BATTLEGROUND_AV, and GetBgTypeID().

Referenced by achievement_everything_counts::OnCheck(), and achievement_bg_av_perfection::OnCheck().

◆ ToBattlegroundAV() [2/2]

BattlegroundAV const * Battleground::ToBattlegroundAV ( ) const

inline

574{ if (GetBgTypeID(true) == BATTLEGROUND_AV) return reinterpret_cast<const BattlegroundAV*>(this); else return nullptr; }

References BATTLEGROUND_AV, and GetBgTypeID().

◆ ToBattlegroundBE() [1/2]

BattlegroundBE * Battleground::ToBattlegroundBE ( )

inline

585{ if (GetBgTypeID(true) == BATTLEGROUND_BE) return reinterpret_cast<BattlegroundBE*>(this); else return nullptr; }

BattlegroundBE

Definition BattlegroundBE.h:47

References BATTLEGROUND_BE, and GetBgTypeID().

◆ ToBattlegroundBE() [2/2]

BattlegroundBE const * Battleground::ToBattlegroundBE ( ) const

inline

586{ if (GetBgTypeID(true) == BATTLEGROUND_BE) return reinterpret_cast<const BattlegroundBE*>(this); else return nullptr; }

References BATTLEGROUND_BE, and GetBgTypeID().

◆ ToBattlegroundDS() [1/2]

BattlegroundDS * Battleground::ToBattlegroundDS ( )

inline

597{ if (GetBgTypeID(true) == BATTLEGROUND_DS) return reinterpret_cast<BattlegroundDS*>(this); else return nullptr; }

BattlegroundDS

Definition BattlegroundDS.h:94

References BATTLEGROUND_DS, and GetBgTypeID().

◆ ToBattlegroundDS() [2/2]

BattlegroundDS const * Battleground::ToBattlegroundDS ( ) const

inline

598{ if (GetBgTypeID(true) == BATTLEGROUND_DS) return reinterpret_cast<const BattlegroundDS*>(this); else return nullptr; }

References BATTLEGROUND_DS, and GetBgTypeID().

◆ ToBattlegroundEY() [1/2]

BattlegroundEY * Battleground::ToBattlegroundEY ( )

inline

588{ if (GetBgTypeID(true) == BATTLEGROUND_EY) return reinterpret_cast<BattlegroundEY*>(this); else return nullptr; }

BATTLEGROUND_EY

@ BATTLEGROUND_EY

Definition SharedDefines.h:3742

BattlegroundEY

Definition BattlegroundEY.h:353

References BATTLEGROUND_EY, and GetBgTypeID().

◆ ToBattlegroundEY() [2/2]

BattlegroundEY const * Battleground::ToBattlegroundEY ( ) const

inline

589{ if (GetBgTypeID(true) == BATTLEGROUND_EY) return reinterpret_cast<const BattlegroundEY*>(this); else return nullptr; }

References BATTLEGROUND_EY, and GetBgTypeID().

◆ ToBattlegroundIC() [1/2]

BattlegroundIC * Battleground::ToBattlegroundIC ( )

inline

603{ if (GetBgTypeID(true) == BATTLEGROUND_IC) return reinterpret_cast<BattlegroundIC*>(this); else return nullptr; }

BATTLEGROUND_IC

@ BATTLEGROUND_IC

Definition SharedDefines.h:3747

BattlegroundIC

Definition BattlegroundIC.h:891

References BATTLEGROUND_IC, and GetBgTypeID().

Referenced by SpellArea::IsFitToRequirements(), and achievement_bg_ic_resource_glut::OnCheck().

◆ ToBattlegroundIC() [2/2]

BattlegroundIC const * Battleground::ToBattlegroundIC ( ) const

inline

604{ if (GetBgTypeID(true) == BATTLEGROUND_IC) return reinterpret_cast<const BattlegroundIC*>(this); else return nullptr; }

References BATTLEGROUND_IC, and GetBgTypeID().

◆ ToBattlegroundNA() [1/2]

BattlegroundNA * Battleground::ToBattlegroundNA ( )

inline

582{ if (GetBgTypeID(true) == BATTLEGROUND_NA) return reinterpret_cast<BattlegroundNA*>(this); else return nullptr; }

BattlegroundNA

Definition BattlegroundNA.h:47

References BATTLEGROUND_NA, and GetBgTypeID().

◆ ToBattlegroundNA() [2/2]

BattlegroundNA const * Battleground::ToBattlegroundNA ( ) const

inline

583{ if (GetBgTypeID(true) == BATTLEGROUND_NA) return reinterpret_cast<const BattlegroundNA*>(this); else return nullptr; }

References BATTLEGROUND_NA, and GetBgTypeID().

◆ ToBattlegroundRL() [1/2]

BattlegroundRL * Battleground::ToBattlegroundRL ( )

inline

591{ if (GetBgTypeID(true) == BATTLEGROUND_RL) return reinterpret_cast<BattlegroundRL*>(this); else return nullptr; }

BattlegroundRL

Definition BattlegroundRL.h:43

References BATTLEGROUND_RL, and GetBgTypeID().

◆ ToBattlegroundRL() [2/2]

BattlegroundRL const * Battleground::ToBattlegroundRL ( ) const

inline

592{ if (GetBgTypeID(true) == BATTLEGROUND_RL) return reinterpret_cast<const BattlegroundRL*>(this); else return nullptr; }

References BATTLEGROUND_RL, and GetBgTypeID().

◆ ToBattlegroundRV() [1/2]

BattlegroundRV * Battleground::ToBattlegroundRV ( )

inline

600{ if (GetBgTypeID(true) == BATTLEGROUND_RV) return reinterpret_cast<BattlegroundRV*>(this); else return nullptr; }

BattlegroundRV

Definition BattlegroundRV.h:82

References BATTLEGROUND_RV, and GetBgTypeID().

◆ ToBattlegroundRV() [2/2]

BattlegroundRV const * Battleground::ToBattlegroundRV ( ) const

inline

601{ if (GetBgTypeID(true) == BATTLEGROUND_RV) return reinterpret_cast<const BattlegroundRV*>(this); else return nullptr; }

References BATTLEGROUND_RV, and GetBgTypeID().

◆ ToBattlegroundSA() [1/2]

BattlegroundSA * Battleground::ToBattlegroundSA ( )

inline

594{ if (GetBgTypeID(true) == BATTLEGROUND_SA) return reinterpret_cast<BattlegroundSA*>(this); else return nullptr; }

BattlegroundSA

Class for manage Strand of Ancient battleground.

Definition BattlegroundSA.h:428

References BATTLEGROUND_SA, and GetBgTypeID().

Referenced by achievement_sa_defense_of_the_ancients::OnCheck(), and achievement_not_even_a_scratch::OnCheck().

◆ ToBattlegroundSA() [2/2]

BattlegroundSA const * Battleground::ToBattlegroundSA ( ) const

inline

595{ if (GetBgTypeID(true) == BATTLEGROUND_SA) return reinterpret_cast<const BattlegroundSA*>(this); else return nullptr; }

References BATTLEGROUND_SA, and GetBgTypeID().

◆ ToBattlegroundWS() [1/2]

BattlegroundWS * Battleground::ToBattlegroundWS ( )

inline

576{ if (GetBgTypeID(true) == BATTLEGROUND_WS) return reinterpret_cast<BattlegroundWS*>(this); else return nullptr; }

BATTLEGROUND_WS

@ BATTLEGROUND_WS

Definition SharedDefines.h:3737

BattlegroundWS

Definition BattlegroundWS.h:209

References BATTLEGROUND_WS, and GetBgTypeID().

Referenced by achievement_save_the_day::OnCheck().

◆ ToBattlegroundWS() [2/2]

BattlegroundWS const * Battleground::ToBattlegroundWS ( ) const

inline

577{ if (GetBgTypeID(true) == BATTLEGROUND_WS) return reinterpret_cast<const BattlegroundWS*>(this); else return nullptr; }

References BATTLEGROUND_WS, and GetBgTypeID().

◆ ToBeDeleted()

bool Battleground::ToBeDeleted ( ) const

inline

559{ return m_SetDeleteThis; }

References m_SetDeleteThis.

Referenced by BattlegroundMgr::Update().

◆ Update()

void Battleground::Update ( uint32 diff )

{
    // pussywizard:
    m_UpdateTimer += diff;
    if (m_UpdateTimer < BATTLEGROUND_UPDATE_INTERVAL)
        return;
 
    diff = BATTLEGROUND_UPDATE_INTERVAL; // just change diff value, no need to replace variable name in many places
    m_UpdateTimer -= BATTLEGROUND_UPDATE_INTERVAL;
 
    if (!PreUpdateImpl(diff))
        return;
 
    if (!GetPlayersSize())
    {
        //BG is empty
        // if there are no players invited, delete BG
        // this will delete arena or bg object, where any player entered
        // [[   but if you use battleground object again (more battles possible to be played on 1 instance)
        //      then this condition should be removed and code:
        //      if (!GetInvitedCount(TEAM_HORDE) && !GetInvitedCount(TEAM_ALLIANCE))
        //          AddToFreeBGObjectsQueue(); // not yet implemented
        //      should be used instead of current
        // ]]
        // Battleground Template instance cannot be updated, because it would be deleted
        if (!GetInvitedCount(TEAM_HORDE) && !GetInvitedCount(TEAM_ALLIANCE))
        {
            m_SetDeleteThis = true;
        }
 
        return;
    }
 
    switch (GetStatus())
    {
        case STATUS_WAIT_JOIN:
            if (GetPlayersSize())
            {
                _ProcessJoin(diff);
                _CheckSafePositions(diff);
            }
            break;
        case STATUS_IN_PROGRESS:
            if (isArena())
            {
                if (GetStartTime() >= 46 * MINUTE * IN_MILLISECONDS) // pussywizard: 1min startup + 45min allowed duration
                {
                    EndBattleground(PVP_TEAM_NEUTRAL);
                    return;
                }
            }
            else
            {
                _ProcessResurrect(diff);
                if (sBattlegroundMgr->GetPrematureFinishTime() && (GetPlayersCountByTeam(TEAM_ALLIANCE) < GetMinPlayersPerTeam() || GetPlayersCountByTeam(TEAM_HORDE) < GetMinPlayersPerTeam()))
                    _ProcessProgress(diff);
                else if (m_PrematureCountDown)
                    m_PrematureCountDown = false;
            }
            break;
        case STATUS_WAIT_LEAVE:
            _ProcessLeave(diff);
            break;
        default:
            break;
    }
 
    // Update start time and reset stats timer
    m_StartTime += diff;
    m_ResetStatTimer += diff;
 
    PostUpdateImpl(diff);
 
    sScriptMgr->OnBattlegroundUpdate(this, diff);
}

References _CheckSafePositions(), _ProcessJoin(), _ProcessLeave(), _ProcessProgress(), _ProcessResurrect(), BATTLEGROUND_UPDATE_INTERVAL, EndBattleground(), GetInvitedCount(), GetMinPlayersPerTeam(), GetPlayersCountByTeam(), GetPlayersSize(), GetStartTime(), GetStatus(), IN_MILLISECONDS, isArena(), m_PrematureCountDown, m_ResetStatTimer, m_SetDeleteThis, m_StartTime, m_UpdateTimer, MINUTE, PostUpdateImpl(), PreUpdateImpl(), PVP_TEAM_NEUTRAL, sBattlegroundMgr, sScriptMgr, STATUS_IN_PROGRESS, STATUS_WAIT_JOIN, STATUS_WAIT_LEAVE, TEAM_ALLIANCE, and TEAM_HORDE.

Referenced by BattlegroundMgr::Update().

◆ UpdatePlayerScore()

bool Battleground::UpdatePlayerScore	(	Player *	player,
		uint32	type,
		uint32	value,
		bool	doAddHonor = `true`
	)

virtual

Reimplemented in BattlegroundAB, BattlegroundAV, BattlegroundEY, BattlegroundIC, and BattlegroundWS.

{
    auto const& itr = PlayerScores.find(player->GetGUID().GetCounter());
    if (itr == PlayerScores.end()) // player not found...
        return false;
 
    if (type == SCORE_BONUS_HONOR && doAddHonor && isBattleground())
        player->RewardHonor(nullptr, 1, value); // RewardHonor calls UpdatePlayerScore with doAddHonor = false
    else
        itr->second->UpdateScore(type, value);
 
    return true;
}

References ObjectGuid::GetCounter(), Object::GetGUID(), isBattleground(), PlayerScores, Player::RewardHonor(), and SCORE_BONUS_HONOR.

Referenced by BattlegroundSA::DestroyGate(), EndBattleground(), HandleKillPlayer(), BattlegroundSA::HandleKillUnit(), RewardHonorToTeam(), BattlegroundAB::UpdatePlayerScore(), BattlegroundAV::UpdatePlayerScore(), BattlegroundEY::UpdatePlayerScore(), BattlegroundIC::UpdatePlayerScore(), and BattlegroundWS::UpdatePlayerScore().

◆ UpdatePlayersCountByTeam()

void Battleground::UpdatePlayersCountByTeam	(	TeamId	teamId,
		bool	remove
	)

inline

    {
        if (remove)
            --m_PlayersCount[teamId];
        else
            ++m_PlayersCount[teamId];
    }

References m_PlayersCount.

Referenced by AddPlayer(), and RemovePlayerAtLeave().

◆ UpdateWorldState()

void Battleground::UpdateWorldState	(	uint32	variable,
		uint32	value
	)

{
    WorldPackets::WorldState::UpdateWorldState worldstate;
    worldstate.VariableID = variable;
    worldstate.Value = value;
    SendPacketToAll(worldstate.Write());
}

References SendPacketToAll(), WorldPackets::WorldState::UpdateWorldState::Value, WorldPackets::WorldState::UpdateWorldState::VariableID, and WorldPackets::WorldState::UpdateWorldState::Write().

Referenced by BattlegroundEY::AddPoints(), BattlegroundSA::CaptureGraveyard(), BattlegroundIC::DestroyGate(), BattlegroundSA::DestroyGate(), BattlegroundWS::EventPlayerCapturedFlag(), BattlegroundEY::EventPlayerClickedOnFlag(), BattlegroundSA::EventPlayerDamagedGO(), BattlegroundIC::HandleKillPlayer(), BattlegroundAB::PostUpdateImpl(), BattlegroundIC::PostUpdateImpl(), BattlegroundWS::PostUpdateImpl(), BattlegroundSA::ResetObjs(), BattlegroundEY::RespawnFlag(), BattlegroundAV::SendMineWorldStates(), BattlegroundAB::SendNodeUpdate(), BattlegroundSA::SendTime(), BattlegroundAV::StartingEventOpenDoors(), BattlegroundWS::StartingEventOpenDoors(), BattlegroundSA::ToggleTimer(), Arena::UpdateArenaWorldState(), BattlegroundWS::UpdateFlagState(), BattlegroundAV::UpdateNodeWorldState(), BattlegroundIC::UpdateNodeWorldState(), BattlegroundEY::UpdatePointsCount(), BattlegroundEY::UpdatePointsIcons(), and BattlegroundAV::UpdateScore().

◆ YellToAll()

void Battleground::YellToAll	(	Creature *	creature,
		const char *	text,
		uint32	language
	)

{
    for (BattlegroundPlayerMap::const_iterator itr = m_Players.begin(); itr != m_Players.end(); ++itr)
    {
        WorldPacket data;
        ChatHandler::BuildChatPacket(data, CHAT_MSG_MONSTER_YELL, Language(language), creature, itr->second, text);
        itr->second->SendDirectMessage(&data);
    }
}

References ChatHandler::BuildChatPacket(), CHAT_MSG_MONSTER_YELL, and m_Players.

Referenced by BattlegroundAV::ChangeMineOwner(), and BattlegroundAV::PostUpdateImpl().

Member Data Documentation

◆ _arenaTeamScores

ArenaTeamScore Battleground::_arenaTeamScores[PVP_TEAMS_COUNT]

protected

Referenced by BuildPvPLogDataPacket(), Arena::EndBattleground(), and Init().

◆ _InBGFreeSlotQueue

bool Battleground::_InBGFreeSlotQueue { false }

private

663{ false }; // used to make sure that BG is only once inserted into the BattlegroundMgr.BGFreeSlotQueue[bgTypeId] deque

Referenced by AddToBGFreeSlotQueue(), Init(), and RemoveFromBGFreeSlotQueue().

◆ _reviveEvents

EventProcessor Battleground::_reviveEvents

protected

Referenced by _ProcessResurrect(), BattlegroundAV::EventPlayerAssaultsPoint(), BattlegroundIC::EventPlayerClickedOnFlag(), BattlegroundEY::EventTeamLostPoint(), BattlegroundAB::NodeDeoccupied(), and ~Battleground().

◆ _startPosition

std::array<Position, PVP_TEAMS_COUNT> Battleground::_startPosition

private

Referenced by GetTeamStartPosition(), and SetTeamStartPosition().

◆ ArenaLogEntries

ArenaLogEntryDataMap Battleground::ArenaLogEntries

Referenced by Arena::EndBattleground(), and BattlegroundQueue::InviteGroupToBG().

◆ BgCreatures

BGCreatures Battleground::BgCreatures

Referenced by AddCreature(), BattlegroundAB::BattlegroundAB(), BattlegroundAV::BattlegroundAV(), BattlegroundDS::BattlegroundDS(), BattlegroundEY::BattlegroundEY(), BattlegroundIC::BattlegroundIC(), BattlegroundSA::BattlegroundSA(), BattlegroundWS::BattlegroundWS(), BattlegroundSA::CaptureGraveyard(), BattlegroundAV::ChangeMineOwner(), DelCreature(), BattlegroundSA::DemolisherStartState(), BattlegroundAV::DePopulateNode(), BattlegroundAV::EventPlayerAssaultsPoint(), BattlegroundIC::EventPlayerClickedOnFlag(), BattlegroundAV::EventPlayerDestroyedPoint(), BattlegroundEY::EventTeamCapturedPoint(), BattlegroundEY::EventTeamLostPoint(), GetBGCreature(), BattlegroundIC::HandleCapturedNodes(), BattlegroundAB::NodeDeoccupied(), BattlegroundAB::NodeOccupied(), BattlegroundSA::OverrideGunFaction(), BattlegroundAV::PopulateNode(), BattlegroundIC::PostUpdateImpl(), BattlegroundAV::ResetBGSubclass(), BattlegroundAB::SetupBattleground(), BattlegroundEY::SetupBattleground(), BattlegroundWS::SetupBattleground(), BattlegroundSA::UpdateDemolisherSpawns(), and ~Battleground().

◆ BgObjects

BGObjects Battleground::BgObjects

Referenced by AddObject(), BattlegroundAB::BattlegroundAB(), BattlegroundAV::BattlegroundAV(), BattlegroundBE::BattlegroundBE(), BattlegroundDS::BattlegroundDS(), BattlegroundEY::BattlegroundEY(), BattlegroundIC::BattlegroundIC(), BattlegroundNA::BattlegroundNA(), BattlegroundRL::BattlegroundRL(), BattlegroundRV::BattlegroundRV(), BattlegroundSA::BattlegroundSA(), BattlegroundWS::BattlegroundWS(), DelObject(), DoorClose(), DoorOpen(), BattlegroundWS::EventPlayerClickedOnFlag(), GetBGObject(), GetObjectType(), BattlegroundRV::GetPillarAtPosition(), HandleTriggerBuff(), BattlegroundSA::SendTransportInit(), BattlegroundSA::SendTransportsRemove(), BattlegroundAB::SetupBattleground(), BattlegroundEY::SetupBattleground(), BattlegroundWS::SetupBattleground(), SpawnBGObject(), BattlegroundDS::StartingEventOpenDoors(), BattlegroundRV::UpdatePillars(), and ~Battleground().

◆ m_ArenaTeamIds

uint32 Battleground::m_ArenaTeamIds[PVP_TEAMS_COUNT]

private

Referenced by Battleground(), GetArenaTeamIdForTeam(), SetArenaTeamIdForTeam(), and StartBattleground().

◆ m_ArenaTeamMMR

uint32 Battleground::m_ArenaTeamMMR[PVP_TEAMS_COUNT]

private

Referenced by Battleground(), GetArenaMatchmakerRating(), and SetArenaMatchmakerRating().

◆ m_ArenaType

uint8 Battleground::m_ArenaType

private

Referenced by Battleground(), GetArenaType(), SetArenaType(), and StartBattleground().

◆ m_BgInvitedPlayers

uint32 Battleground::m_BgInvitedPlayers[PVP_TEAMS_COUNT]

private

Referenced by Battleground(), DecreaseInvitedCount(), GetInvitedCount(), IncreaseInvitedCount(), and Init().

◆ m_BgRaids

Group* Battleground::m_BgRaids[PVP_TEAMS_COUNT]

private

Referenced by Battleground(), GetBgRaid(), and SetBgRaid().

◆ m_BracketId

BattlegroundBracketId Battleground::m_BracketId { BG_BRACKET_ID_FIRST }

private

661{ BG_BRACKET_ID_FIRST };

BG_BRACKET_ID_FIRST

@ BG_BRACKET_ID_FIRST

Definition DBCEnums.h:47

Referenced by GetBracketId(), and SetBracket().

◆ m_BuffChange

bool Battleground::m_BuffChange

protected

Referenced by Battleground(), BattlegroundAB::BattlegroundAB(), BattlegroundEY::BattlegroundEY(), and HandleTriggerBuff().

◆ m_ClientInstanceID

uint32 Battleground::m_ClientInstanceID

private

Referenced by Battleground(), GetClientInstanceID(), and SetClientInstanceID().

◆ m_EndTime

int32 Battleground::m_EndTime

private

Referenced by _ProcessLeave(), Battleground(), EndBattleground(), GetEndTime(), and SetEndTime().

◆ m_Events

uint8 Battleground::m_Events

protected

Referenced by _ProcessJoin(), Battleground(), Init(), and ReadyMarkerClicked().

◆ m_HonorMode

BGHonorMode Battleground::m_HonorMode

protected

Referenced by Battleground(), and SetHoliday().

◆ m_InstanceID

uint32 Battleground::m_InstanceID

private

Referenced by _ProcessJoin(), AddCreature(), AddObject(), AddSpiritGuide(), Battleground(), DelCreature(), DelObject(), DoorClose(), DoorOpen(), GetBGCreature(), GetBGObject(), GetInstanceID(), GetObjectType(), Init(), RemoveFromBGFreeSlotQueue(), and SetInstanceID().

◆ m_IsArena

bool Battleground::m_IsArena

private

Referenced by Battleground(), isArena(), isBattleground(), and SetArenaorBGType().

◆ m_IsRandom

bool Battleground::m_IsRandom

protected

Referenced by Battleground(), IsRandom(), and SetRandom().

◆ m_IsRated

bool Battleground::m_IsRated

private

Referenced by Battleground(), isRated(), SetRated(), and StartBattleground().

◆ m_IsTemplate

bool Battleground::m_IsTemplate

private

Referenced by Battleground(), isTemplate(), and SetBracket().

◆ m_LastResurrectTime

uint32 Battleground::m_LastResurrectTime

private

Referenced by _ProcessResurrect(), Battleground(), GetLastResurrectTime(), and SetLastResurrectTime().

◆ m_LevelMax

uint32 Battleground::m_LevelMax

private

Referenced by Battleground(), GetMaxLevel(), and SetLevelRange().

◆ m_LevelMin

uint32 Battleground::m_LevelMin

private

Referenced by Battleground(), GetMinLevel(), and SetLevelRange().

◆ m_Map

BattlegroundMap* Battleground::m_Map

private

Referenced by Battleground(), FindBgMap(), GetBgMap(), SetBgMap(), and ~Battleground().

◆ m_MapId

uint32 Battleground::m_MapId

private

Referenced by _ProcessJoin(), AddCreature(), AddObject(), AddSpiritGuide(), Battleground(), DelCreature(), DelObject(), DoorClose(), DoorOpen(), GetBGCreature(), GetBGObject(), GetMapId(), GetObjectType(), Init(), and SetMapId().

◆ m_MaxPlayersPerTeam

uint32 Battleground::m_MaxPlayersPerTeam

private

Referenced by Battleground(), GetMaxPlayersPerTeam(), and SetMaxPlayersPerTeam().

◆ m_MinPlayersPerTeam

uint32 Battleground::m_MinPlayersPerTeam

private

Referenced by Battleground(), GetMinPlayersPerTeam(), and SetMinPlayersPerTeam().

◆ m_Name

std::string Battleground::m_Name {}

private

672{};

Referenced by GetName(), and SetName().

◆ m_OfflineQueue

GuidDeque Battleground::m_OfflineQueue

private

◆ m_Players

◆ m_PlayersCount

uint32 Battleground::m_PlayersCount[PVP_TEAMS_COUNT]

private

Referenced by Battleground(), GetPlayersCountByTeam(), and UpdatePlayersCountByTeam().

◆ m_PrematureCountDown

bool Battleground::m_PrematureCountDown

private

Referenced by _ProcessProgress(), Battleground(), and Update().

◆ m_PrematureCountDownTimer

uint32 Battleground::m_PrematureCountDownTimer

private

Referenced by _ProcessProgress(), and Battleground().

◆ m_RandomTypeID

BattlegroundTypeId Battleground::m_RandomTypeID

private

Referenced by Battleground(), GetBgTypeID(), and SetRandomTypeID().

◆ m_RealTypeID

BattlegroundTypeId Battleground::m_RealTypeID

private

Referenced by AddToBGFreeSlotQueue(), Battleground(), GetBgTypeID(), RemoveFromBGFreeSlotQueue(), and SetBgTypeID().

◆ m_ResetStatTimer

uint32 Battleground::m_ResetStatTimer

private

Referenced by _ProcessJoin(), Battleground(), and Update().

◆ m_ResurrectQueue

GuidVector Battleground::m_ResurrectQueue

private

Referenced by _ProcessResurrect().

◆ m_ReviveQueue

std::map<ObjectGuid, GuidVector> Battleground::m_ReviveQueue

protected

Referenced by _ProcessResurrect(), AddPlayerToResurrectQueue(), BattlegroundSA::CaptureGraveyard(), GetReviveQueueSize(), RelocateDeadPlayers(), and RemovePlayerFromResurrectQueue().

◆ m_SetDeleteThis

bool Battleground::m_SetDeleteThis

private

Referenced by Battleground(), ToBeDeleted(), and Update().

◆ m_SetupCompleted

bool Battleground::m_SetupCompleted

protected

Referenced by _ProcessJoin(), and Battleground().

◆ m_Spectators

SpectatorList Battleground::m_Spectators

private

Referenced by _ProcessJoin(), AddSpectator(), GetSpectators(), HaveSpectators(), RemoveSpectator(), and SpectatorsSendPacket().

◆ m_StartDelayTime

int32 Battleground::m_StartDelayTime

private

Referenced by Battleground(), GetStartDelayTime(), ModifyStartDelayTime(), and SetStartDelayTime().

◆ m_StartMaxDist

float Battleground::m_StartMaxDist

private

Referenced by Battleground(), GetStartMaxDist(), and SetStartMaxDist().

◆ m_StartTime

uint32 Battleground::m_StartTime

private

Referenced by Battleground(), GetStartTime(), ReadyMarkerClicked(), SetStartTime(), and Update().

◆ m_Status

BattlegroundStatus Battleground::m_Status

private

Referenced by Battleground(), GetStatus(), and SetStatus().

◆ m_TeamScores

int32 Battleground::m_TeamScores[PVP_TEAMS_COUNT]

protected

Referenced by BattlegroundEY::AddPoints(), Battleground(), BattlegroundAB::FillInitialWorldStates(), GetTeamScore(), and BattlegroundAB::PostUpdateImpl().

◆ m_ToBeTeleported

ToBeTeleportedMap Battleground::m_ToBeTeleported

private

Referenced by _ProcessJoin(), AddToBeTeleported(), and RemoveToBeTeleported().

◆ m_UpdateTimer

uint32 Battleground::m_UpdateTimer

protected

Referenced by Battleground(), and Update().

◆ m_ValidStartPositionTimer

uint32 Battleground::m_ValidStartPositionTimer

private

Referenced by _CheckSafePositions(), and Battleground().

◆ m_WinnerId

PvPTeamId Battleground::m_WinnerId

private

Referenced by Battleground(), GetWinner(), and SetWinner().

◆ PlayerScores

BattlegroundScoreMap Battleground::PlayerScores

protected

Referenced by Arena::AddPlayer(), BattlegroundAB::AddPlayer(), BattlegroundAV::AddPlayer(), BattlegroundEY::AddPlayer(), BattlegroundIC::AddPlayer(), BattlegroundSA::AddPlayer(), BattlegroundWS::AddPlayer(), BuildPvPLogDataPacket(), EndBattleground(), Arena::EndBattleground(), GetPlayerScores(), GetPlayerScoresSize(), Init(), RemovePlayerAtLeave(), UpdatePlayerScore(), and ~Battleground().

◆ readyMarkerClickedSet

GuidSet Battleground::readyMarkerClickedSet

Referenced by ReadyMarkerClicked().

◆ ScriptId

uint32 Battleground::ScriptId

private

Referenced by Battleground(), GetScriptId(), and SetScriptId().

◆ StartDelayTimes

BattlegroundStartTimeIntervals Battleground::StartDelayTimes[BG_STARTING_EVENT_COUNT]

protected

Referenced by _ProcessJoin(), Arena::Arena(), and Battleground().

◆ StartMessageIds

uint32 Battleground::StartMessageIds[BG_STARTING_EVENT_COUNT]

protected

Referenced by _ProcessJoin(), Arena::Arena(), Battleground(), BattlegroundAV::BattlegroundAV(), BattlegroundSA::BattlegroundSA(), and BattlegroundWS::BattlegroundWS().

The documentation for this class was generated from the following files:

azerothcore-wotlk/src/server/game/Battlegrounds/Battleground.h
azerothcore-wotlk/src/server/game/Battlegrounds/Battleground.cpp

Protected Attributes
bool	m_SetupCompleted

BattlegroundScoreMap	PlayerScores

BattlegroundPlayerMap	m_Players

std::map< ObjectGuid, GuidVector >	m_ReviveQueue

uint8	m_Events

BattlegroundStartTimeIntervals	StartDelayTimes [BG_STARTING_EVENT_COUNT]

uint32	StartMessageIds [BG_STARTING_EVENT_COUNT]

bool	m_BuffChange

bool	m_IsRandom

BGHonorMode	m_HonorMode

int32	m_TeamScores [PVP_TEAMS_COUNT]

ArenaTeamScore	_arenaTeamScores [PVP_TEAMS_COUNT]

uint32	m_UpdateTimer

EventProcessor	_reviveEvents

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ ArenaLogEntryDataMap

◆ BattlegroundPlayerMap

◆ BattlegroundScoreMap

◆ BGCreatures

◆ BGObjects

◆ SpectatorList

◆ ToBeTeleportedMap

Constructor & Destructor Documentation

◆ Battleground()

◆ ~Battleground()

Member Function Documentation

◆ _CheckSafePositions()

◆ _ProcessJoin()

◆ _ProcessLeave()

◆ _ProcessProgress()

◆ _ProcessResurrect()

◆ AddCreature()

◆ AddObject()

◆ AddOrSetPlayerToCorrectBgGroup()

◆ AddPlayer()

◆ AddPlayerToResurrectQueue()

◆ AddSpectator()

◆ AddSpiritGuide()

◆ AddToBeTeleported()

◆ AddToBGFreeSlotQueue()

◆ AllNodesConrolledByTeam()

◆ BlockMovement()

◆ BroadcastWorker()

◆ BuildPvPLogDataPacket()

◆ CastSpellOnTeam()

◆ CheckWinConditions()

◆ DecreaseInvitedCount()

◆ DelCreature()

◆ DelObject()

◆ DestroyGate()

◆ DoAction()

◆ DoorClose()

◆ DoorOpen()

◆ EndBattleground() [1/2]

◆ EndBattleground() [2/2]

◆ EndNow()

◆ EventPlayerClickedOnFlag()

◆ EventPlayerDamagedGO()

◆ EventPlayerDroppedFlag()

◆ EventPlayerUsedGO()

◆ FillInitialWorldStates()

◆ FindBgMap()

◆ GetAlivePlayersCountByTeam()

◆ GetArenaMatchmakerRating()

◆ GetArenaTeamIdForTeam()

◆ GetArenaType()

◆ GetBGCreature()

◆ GetBgMap()

◆ GetBGObject()

◆ GetBgRaid()

◆ GetBgTypeID()

◆ GetBonusHonorFromKill()

◆ GetBracketId()

◆ GetClientInstanceID()

◆ GetClosestGraveyard()

◆ GetEndTime()

◆ GetFlagPickerGUID()

◆ GetFreeSlotsForTeam()

◆ GetInstanceID()

◆ GetInvitedCount()

◆ GetLastResurrectTime()

◆ GetMapId()

◆ GetMaxFreeSlots()

◆ GetMaxLevel()

◆ GetMaxPlayersPerTeam()