Battlefield Class Reference

#include "Battlefield.h"

Inheritance diagram for Battlefield:

Public Types
using	BfCapturePointVector = std::vector< BfCapturePoint * >
	Vector of capture points belonging to this battlefield.

Public Member Functions
	Battlefield ()
	Constructor.
	~Battlefield () override
	Destructor.
virtual bool	SetupBattlefield ()
	Call this to init the Battlefield.
void	SendUpdateWorldState (uint32 field, uint32 value)
	Update data of a worldstate to all players present in zone.
virtual bool	Update (uint32 diff)
	Called every time for update bf data and time.
void	InvitePlayersInZoneToQueue ()
	Invite all players in zone to join the queue, called x minutes before battle start in Update()
void	InvitePlayersInQueueToWar ()
	Invite all players in queue to join battle on battle start.
void	InvitePlayersInZoneToWar ()
	Invite all players in zone to join battle on battle start.
virtual void	HandleKill (Player *, Unit *)
	Called when a Unit is killed in battlefield zone.
uint32	GetTypeId () const
uint32	GetZoneId () const
void	TeamApplyBuff (TeamId team, uint32 spellId, uint32 spellId2=0)
bool	IsWarTime () const
	Return true if battle is started, false if battle is not started.
void	ToggleBattlefield (bool enable)
	Enable or Disable battlefield.
bool	IsEnabled () const
	Return if battlefield is enabled.
void	KickPlayerFromBattlefield (ObjectGuid guid)
	Kick player from battlefield and teleport him to kick-point location.
void	HandlePlayerEnterZone (Player *player, uint32 zone)
	Called when player (player) enters the zone.
void	HandlePlayerLeaveZone (Player *player, uint32 zone)
	Called when player (player) leaves the zone.
uint64	GetData64 (uint32 dataId) const override
void	SetData64 (uint32 dataId, uint64 value) override
uint32	GetData (uint32 dataId) const override
void	SetData (uint32 dataId, uint32 value) override
virtual void	UpdateData (uint32 index, int32 pad)
TeamId	GetDefenderTeam () const
TeamId	GetAttackerTeam () const
TeamId	GetOtherTeam (TeamId team) const
void	SetDefenderTeam (TeamId team)
Group *	GetFreeBfRaid (TeamId teamId)
	Find a not full battlefield group, if there is no, create one.
Group *	GetGroupPlayer (ObjectGuid guid, TeamId teamId)
	Return battlefield group where player is.
bool	AddOrSetPlayerToCorrectBfGroup (Player *player)
	Force player to join a battlefield group.
void	TryRejoinAfterLogout (Player *player)
GraveyardStruct const *	GetClosestGraveyard (Player *player)
virtual void	AddPlayerToResurrectQueue (ObjectGuid npcGuid, ObjectGuid playerGuid)
void	RemovePlayerFromResurrectQueue (ObjectGuid playerGuid)
void	SetGraveyardNumber (uint32 number)
BfGraveyard *	GetGraveyardById (uint32 id) const
Creature *	SpawnCreature (uint32 entry, float x, float y, float z, float o, TeamId teamId)
Creature *	SpawnCreature (uint32 entry, Position pos, TeamId teamId)
GameObject *	SpawnGameObject (uint32 entry, float x, float y, float z, float o)
Creature *	GetCreature (ObjectGuid const &guid)
GameObject *	GetGameObject (ObjectGuid const &guid)
virtual void	OnBattleStart ()
	Called on start.
virtual void	OnBattleEnd (bool)
	Called at the end of battle.
virtual void	OnStartGrouping ()
	Called x minutes before battle start when players in zone are invited to join queue.
virtual void	OnPlayerJoinWar (Player *)
	Called when a player accepts to join the battle.
virtual void	OnPlayerLeaveWar (Player *)
	Called when a player leaves the battle.
virtual void	OnPlayerLeaveZone (Player *)
	Called when a player leaves the battlefield zone.
virtual void	OnPlayerEnterZone (Player *)
	Called when a player enters the battlefield zone.
void	SendWarning (uint8 id, WorldObject const *target=nullptr)
void	PlayerAcceptInviteToQueue (Player *player)
void	PlayerAcceptInviteToWar (Player *player)
uint32	GetBattleId () const
void	AskToLeaveQueue (Player *player)
void	PlayerAskToLeave (Player *player)
virtual void	SendInitWorldStatesToAll ()=0
	Send all worldstate data to all players in zone.
virtual void	FillInitialWorldStates (WorldPackets::WorldState::InitWorldStates &)=0
virtual void	SendUpdateWorldStates (Player *player=nullptr)=0
bool	CanFlyIn () const
	Return if we can use mount in battlefield.
void	SendAreaSpiritHealerQueryOpcode (Player *player, ObjectGuid const &guid)
void	StartBattle ()
void	EndBattle (bool endByTimer)
void	HideNpc (Creature *creature)
void	ShowNpc (Creature *creature, bool aggressive)
GraveyardVect const &	GetGraveyardVector () const
uint32	GetTimer () const
void	SetTimer (uint32 timer)
uint32	GetPlayersInWarCount (TeamId teamId) const
uint32	GetPlayersInZoneCount (TeamId teamId) const
uint32	GetMaxPlayersPerTeam () const
bool	HasWarVacancy (TeamId teamId) const
	Returns true if there is still room for another player on the given team in the active war.
GuidUnorderedSet const &	GetPlayersQueueSet (TeamId teamId) const
	Returns the set of players waiting in the pre-battle queue (per team, read-only).
PlayerTimerMap const &	GetInvitedPlayersMap (TeamId teamId) const
GuidUnorderedSet const &	GetPlayersInWarSet (TeamId teamId) const
	Returns the set of players actively fighting in the war (per team, read-only).
bool	IsPlayerInBattlefield (ObjectGuid guid) const
void	DoPlaySoundToAll (uint32 soundId)
void	InvitePlayerToQueue (Player *player)
void	InvitePlayerToWar (Player *player)
void	InitStalker (uint32 entry, float x, float y, float z, float o)
Public Member Functions inherited from ZoneScript
	ZoneScript ()
virtual	~ZoneScript ()
virtual uint32	GetCreatureEntry (ObjectGuid::LowType, CreatureData const *data)
virtual uint32	GetGameObjectEntry (ObjectGuid::LowType, uint32 entry)
virtual void	OnCreatureCreate (Creature *)
virtual void	OnCreatureRemove (Creature *)
virtual void	OnGameObjectCreate (GameObject *)
virtual void	OnGameObjectRemove (GameObject *)
virtual void	OnUnitDeath (Unit *)
virtual void	OnCreatureEvade (Creature *)
virtual ObjectGuid	GetGuidData (uint32) const
virtual void	SetGuidData (uint32, ObjectGuid)
virtual void	ProcessEvent (WorldObject *, uint32)

Protected Member Functions
void	KickAfkPlayers ()
virtual void	SendRemoveWorldStates (Player *)
void	BroadcastPacketToZone (WorldPacket const *data) const
void	BroadcastPacketToQueue (WorldPacket const *data) const
void	BroadcastPacketToWar (WorldPacket const *data) const
void	AddCapturePoint (BfCapturePoint *cp)
void	RegisterZone (uint32 zoneId)
bool	HasPlayer (Player *player) const
void	TeamCastSpell (TeamId team, int32 spellId)
bool	IsPlayerInWarOrInvited (Player *player) const
	Returns true if the player is already tracked as actively in the war or invited to join it.
void	RemovePlayerFromTracking (ObjectGuid playerGuid, bool removeFromQueue=true)
template<typename Func >
void	ForEachPlayerInZone (Func &&fn) const
template<typename Func >
void	ForEachPlayerInQueue (Func &&fn) const
template<typename Func >
void	ForEachPlayerInWar (Func &&fn) const
template<typename Func >
void	ForEachPlayerInWar (TeamId team, Func &&fn) const

Protected Attributes
ObjectGuid	StalkerGuid
uint32	Timer
bool	Enabled
bool	Active
TeamId	DefenderTeam
BfCapturePointVector	CapturePoints
GuidUnorderedSet	Players [PVP_TEAMS_COUNT]
GuidUnorderedSet	PlayersInQueue [PVP_TEAMS_COUNT]
GuidUnorderedSet	PlayersInWar [PVP_TEAMS_COUNT]
PlayerTimerMap	InvitedPlayers [PVP_TEAMS_COUNT]
PlayerTimerMap	PlayersWillBeKick [PVP_TEAMS_COUNT]
PlayerTimerMap	LogoutGracePlayers [PVP_TEAMS_COUNT]
uint32	TypeId
uint32	BattleId
uint32	ZoneId
uint32	MapId
Map *	BfMap
uint32	MaxPlayer
uint32	MinPlayer
uint32	MinLevel
uint32	BattleTime
uint32	NoWarBattleTime
uint32	RestartAfterCrash
uint32	TimeForAcceptInvite
WorldLocation	KickPosition
GraveyardVect	GraveyardList
uint32	StartGroupingTimer
bool	StartGrouping
TaskScheduler	_scheduler
GuidUnorderedSet	Groups [PVP_TEAMS_COUNT]
std::vector< uint64 >	Data64
std::vector< uint32 >	Data32

Static Protected Attributes
static constexpr uint32	LOGOUT_GRACE_SECONDS = 120

Friends
class	BattlefieldMgr

Detailed Description

Member Typedef Documentation

BfCapturePointVector

using Battlefield::BfCapturePointVector = std::vector<BfCapturePoint*>

Vector of capture points belonging to this battlefield.

Constructor & Destructor Documentation

Battlefield()

Battlefield::Battlefield

(

)

Constructor.

Todo:

: this import is not necessary for compilation and marked as unused by the IDE

                         :
    Timer(0),
    Enabled(true),
    Active(false),
    DefenderTeam(TEAM_NEUTRAL),
    TypeId(0),
    BattleId(0),
    ZoneId(0),
    MapId(0),
    BfMap(nullptr),
    MaxPlayer(0),
    MinPlayer(0),
    MinLevel(0),
    BattleTime(0),
    NoWarBattleTime(0),
    RestartAfterCrash(0),
    TimeForAcceptInvite(20),
    StartGroupingTimer(0),
    StartGrouping(false)
{
}

~Battlefield()

Battlefield::~Battlefield ( )

override

Destructor.

{
    for (BfCapturePoint* cp : CapturePoints)
        delete cp;
 
    for (BfGraveyard* gy : GraveyardList)
        delete gy;
 
    CapturePoints.clear();
}

References CapturePoints, and GraveyardList.

Member Function Documentation

AddCapturePoint()

void Battlefield::AddCapturePoint ( BfCapturePoint *  cp )

inlineprotected

{ CapturePoints.push_back(cp); }

References CapturePoints.

Referenced by BattlefieldWG::OnGameObjectCreate().

AddOrSetPlayerToCorrectBfGroup()

bool Battlefield::AddOrSetPlayerToCorrectBfGroup

(

Player *

player

)

Force player to join a battlefield group.

{
    if (!player->IsInWorld())
        return false;
 
    if (player->GetGroup() && (player->GetGroup()->isBGGroup() || player->GetGroup()->isBFGroup()))
    {
        LOG_INFO("misc", "Battlefield::AddOrSetPlayerToCorrectBfGroup - player is already in {} group!", (player->GetGroup()->isBGGroup() ? "BG" : "BF"));
        return false;
    }
 
    Group* group = GetFreeBfRaid(player->GetTeamId());
    if (!group)
    {
        group = new Group;
        group->SetBattlefieldGroup(this);
        group->Create(player);
        sGroupMgr->AddGroup(group);
        Groups[player->GetTeamId()].insert(group->GetGUID());
    }
    else if (group->IsMember(player->GetGUID()))
    {
        uint8 subgroup = group->GetMemberGroup(player->GetGUID());
        player->SetBattlegroundOrBattlefieldRaid(group, subgroup);
    }
    else
        group->AddMember(player);
 
    return true;
}

References Group::AddMember(), Group::Create(), GetFreeBfRaid(), Player::GetGroup(), Group::GetGUID(), Object::GetGUID(), Group::GetMemberGroup(), Player::GetTeamId(), Group::isBFGroup(), Group::isBGGroup(), Object::IsInWorld(), Group::IsMember(), LOG_INFO, Group::SetBattlefieldGroup(), Player::SetBattlegroundOrBattlefieldRaid(), and sGroupMgr.

Referenced by PlayerAcceptInviteToWar(), and TryRejoinAfterLogout().

AddPlayerToResurrectQueue()

void Battlefield::AddPlayerToResurrectQueue ( ObjectGuid  npcGuid, ObjectGuid  playerGuid  )

virtual

{
    Player* player = ObjectAccessor::FindPlayer(playerGuid);
    if (!player)
        return;
 
    player->CastSpell(player, SPELL_WAITING_FOR_RESURRECT, true);
}

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

AskToLeaveQueue()

void Battlefield::AskToLeaveQueue

(

Player *

player

)

{
    // Remove player from queue
    PlayersInQueue[player->GetTeamId()].erase(player->GetGUID());
    // Send notification
    player->GetSession()->SendBfLeaveMessage(BattleId, BF_LEAVE_REASON_CLOSE);
}

References BattleId, BF_LEAVE_REASON_CLOSE, Object::GetGUID(), Player::GetSession(), Player::GetTeamId(), PlayersInQueue, and WorldSession::SendBfLeaveMessage().

Referenced by WorldSession::HandleBfExitRequest().

BroadcastPacketToQueue()

void Battlefield::BroadcastPacketToQueue ( WorldPacket const *  data ) const

protected

{
    ForEachPlayerInQueue([data](Player* player) { player->SendDirectMessage(data); });
}

References ForEachPlayerInQueue(), and Player::SendDirectMessage().

BroadcastPacketToWar()

void Battlefield::BroadcastPacketToWar ( WorldPacket const *  data ) const

protected

{
    ForEachPlayerInWar([data](Player* player) { player->SendDirectMessage(data); });
}

References ForEachPlayerInWar(), and Player::SendDirectMessage().

Referenced by DoPlaySoundToAll().

BroadcastPacketToZone()

void Battlefield::BroadcastPacketToZone ( WorldPacket const *  data ) const

protected

{
    ForEachPlayerInZone([data](Player* player) { player->SendDirectMessage(data); });
}

References ForEachPlayerInZone(), and Player::SendDirectMessage().

CanFlyIn()

bool Battlefield::CanFlyIn ( ) const

inline

Return if we can use mount in battlefield.

{ return !Active; }

References Active.

Referenced by Spell::CheckCast(), spell_gen_mount::HandleMount(), and SpellArea::IsFitToRequirements().

DoPlaySoundToAll()

void Battlefield::DoPlaySoundToAll

(

uint32

soundId

)

{
    BroadcastPacketToWar(WorldPackets::Misc::Playsound(soundId).Write());
}

References BroadcastPacketToWar().

Referenced by EndBattle(), and StartBattle().

EndBattle()

void Battlefield::EndBattle

(

bool

endByTimer

)

{
    if (!Active)
        return;
 
    Active = false;
 
    _scheduler.CancelGroup(BATTLEFIELD_TIMER_GROUP_WAR);
 
    StartGrouping = false;
 
    if (!endByTimer)
        SetDefenderTeam(GetAttackerTeam());
 
    if (GetDefenderTeam() == TEAM_ALLIANCE)
        DoPlaySoundToAll(BF_ALLIANCE_WINS);
    else
        DoPlaySoundToAll(BF_HORDE_WINS);
 
    // Hook runs BEFORE OnBattleEnd so subscribers can read PlayersInWar
    // while it is still populated (OnBattleEnd hands out rewards and then
    // clears the set).
    sScriptMgr->OnBattlefieldWarEnd(this, endByTimer);
    OnBattleEnd(endByTimer);
 
    for (uint8 team = 0; team < PVP_TEAMS_COUNT; ++team)
    {
        for (ObjectGuid const& guid : Groups[team])
            if (Group* group = sGroupMgr->GetGroupByGUID(guid.GetCounter()))
                group->Disband();
        Groups[team].clear();
    }
 
    // Reset battlefield timer
    Timer = NoWarBattleTime;
    SendInitWorldStatesToAll();
    SendUpdateWorldStates();
}

References _scheduler, Active, BATTLEFIELD_TIMER_GROUP_WAR, BF_ALLIANCE_WINS, BF_HORDE_WINS, TaskScheduler::CancelGroup(), DoPlaySoundToAll(), GetAttackerTeam(), GetDefenderTeam(), NoWarBattleTime, OnBattleEnd(), PVP_TEAMS_COUNT, SendInitWorldStatesToAll(), SendUpdateWorldStates(), SetDefenderTeam(), sGroupMgr, sScriptMgr, StartGrouping, and TEAM_ALLIANCE.

Referenced by bf_commandscript::HandleBattlefieldEnd(), bf_commandscript::HandleBattlefieldSwitch(), BattlefieldWG::ProcessEvent(), and Update().

FillInitialWorldStates()

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

pure virtual

Implemented in BattlefieldWG.

Referenced by Player::SendInitWorldStates().

ForEachPlayerInQueue()

template<typename Func >

void Battlefield::ForEachPlayerInQueue ( Func &&  fn ) const

inlineprotected

    {
        for (uint8 team = 0; team < PVP_TEAMS_COUNT; ++team)
            for (ObjectGuid const& guid : PlayersInQueue[team])
                if (Player* player = ObjectAccessor::FindPlayer(guid))
                    fn(player);
    }

References ObjectAccessor::FindPlayer(), PlayersInQueue, and PVP_TEAMS_COUNT.

Referenced by BroadcastPacketToQueue().

ForEachPlayerInWar() [1/2]

template<typename Func >

void Battlefield::ForEachPlayerInWar ( Func &&  fn ) const

inlineprotected

    {
        for (uint8 team = 0; team < PVP_TEAMS_COUNT; ++team)
            for (ObjectGuid const& guid : PlayersInWar[team])
                if (Player* player = ObjectAccessor::FindPlayer(guid))
                    fn(player);
    }

References ObjectAccessor::FindPlayer(), PlayersInWar, and PVP_TEAMS_COUNT.

Referenced by BroadcastPacketToWar(), KickAfkPlayers(), and TeamCastSpell().

ForEachPlayerInWar() [2/2]

template<typename Func >

void Battlefield::ForEachPlayerInWar ( TeamId  team, Func &&  fn  ) const

inlineprotected

    {
        for (ObjectGuid const& guid : PlayersInWar[team])
            if (Player* player = ObjectAccessor::FindPlayer(guid))
                fn(player);
    }

References ObjectAccessor::FindPlayer(), and PlayersInWar.

ForEachPlayerInZone()

template<typename Func >

void Battlefield::ForEachPlayerInZone ( Func &&  fn ) const

inlineprotected

    {
        for (uint8 team = 0; team < PVP_TEAMS_COUNT; ++team)
            for (ObjectGuid const& guid : Players[team])
                if (Player* player = ObjectAccessor::FindPlayer(guid))
                    fn(player);
    }

References ObjectAccessor::FindPlayer(), Players, and PVP_TEAMS_COUNT.

Referenced by BroadcastPacketToZone(), InvitePlayersInZoneToQueue(), InvitePlayersInZoneToWar(), SendUpdateWorldState(), and BattlefieldWG::SetupBattlefield().

GetAttackerTeam()

TeamId Battlefield::GetAttackerTeam ( ) const

inline

{ return TeamId(1 - DefenderTeam); }

References DefenderTeam.

Referenced by BfWGGameObjectBuilding::Damaged(), EndBattle(), BattlefieldWG::FillInitialWorldStates(), npc_wg_quest_giver::GetDialogStatus(), BfWGGameObjectBuilding::Init(), BattlefieldWG::OnBattleEnd(), BattlefieldWG::OnBattleStart(), npc_wg_quest_giver::OnGossipHello(), BattlefieldWG::OnPlayerEnterZone(), BattlefieldWG::OnPlayerJoinWar(), BfWGGameObjectBuilding::Rebuild(), BattlefieldWG::SendUpdateWorldStates(), BattlefieldWG::SetupBattlefield(), BfWGGameObjectBuilding::UpdateCreatureAndGo(), BattlefieldWG::UpdateDamagedTowerCount(), BattlefieldWG::UpdatedDestroyedTowerCount(), and BfWGGameObjectBuilding::UpdateTurretAttack().

GetBattleId()

uint32 Battlefield::GetBattleId ( ) const

inline

{ return BattleId; }

References BattleId.

GetClosestGraveyard()

GraveyardStruct const * Battlefield::GetClosestGraveyard

(

Player *

player

)

{
    BfGraveyard* closestGY = nullptr;
    float maxdist = -1;
    for (BfGraveyard* gy : GraveyardList)
    {
        if (!gy)
            continue;
 
        if (gy->GetControlTeamId() != player->GetTeamId())
            continue;
 
        float dist = gy->GetDistance(player);
        if (dist < maxdist || maxdist < 0)
        {
            closestGY = gy;
            maxdist = dist;
        }
    }
 
    if (closestGY)
        return sGraveyard->GetGraveyard(closestGY->GetGraveyardId());
 
    return nullptr;
}

References BfGraveyard::GetDistance(), BfGraveyard::GetGraveyardId(), Player::GetTeamId(), GraveyardList, and sGraveyard.

GetCreature()

Creature * Battlefield::GetCreature

(

ObjectGuid const &

guid

)

{
    if (!BfMap)
        return nullptr;
 
    return BfMap->GetCreature(guid);
}

References BfMap, and Map::GetCreature().

Referenced by BfWGGameObjectBuilding::Damaged(), BattlefieldWG::OnBattleEnd(), BattlefieldWG::OnBattleStart(), SendWarning(), BattlefieldWG::SetupBattlefield(), BfWGGameObjectBuilding::UpdateCreatureAndGo(), BattlefieldWG::UpdateTenacity(), and BfWGGameObjectBuilding::UpdateTurretAttack().

GetData()

uint32 Battlefield::GetData ( uint32  dataId ) const

inlineoverridevirtual

Reimplemented from ZoneScript.

Reimplemented in BattlefieldWG.

{ return Data32[dataId]; }

References Data32.

Referenced by npc_wg_demolisher_engineer::canBuild(), BattlefieldWG::GetData(), and SpellArea::IsFitToRequirements().

GetData64()

uint64 Battlefield::GetData64 ( uint32  dataId ) const

inlineoverridevirtual

Reimplemented from ZoneScript.

{ return Data64[dataId]; }

GetDefenderTeam()

TeamId Battlefield::GetDefenderTeam ( ) const

inline

{ return DefenderTeam; }

References DefenderTeam.

Referenced by EndBattle(), BattlefieldWG::FillInitialWorldStates(), npc_wg_quest_giver::GetDialogStatus(), spell_wintergrasp_portal::HandleScript(), BfWGGameObjectBuilding::Init(), SpellArea::IsFitToRequirements(), BattlefieldWG::OnBattleEnd(), BattlefieldWG::OnBattleStart(), npc_wg_queue::OnGossipHello(), npc_wg_quest_giver::OnGossipHello(), BattlefieldWG::OnPlayerJoinWar(), BfWGGameObjectBuilding::Rebuild(), BattlefieldWG::SendUpdateWorldStates(), BattlefieldWG::SetupBattlefield(), BfWGGameObjectBuilding::UpdateCreatureAndGo(), BattlefieldWG::UpdatedDestroyedTowerCount(), WGWorkshop::UpdateGraveyardAndWorkshop(), and BfWGGameObjectBuilding::UpdateTurretAttack().

GetFreeBfRaid()

Group * Battlefield::GetFreeBfRaid

(

TeamId

teamId

)

Find a not full battlefield group, if there is no, create one.

Parameters

teamId

: Id of player team for who we search a group (player->GetTeamId())

{
    for (ObjectGuid const& guid : Groups[teamId])
        if (Group* group = sGroupMgr->GetGroupByGUID(guid.GetCounter()))
            if (!group->IsFull())
                return group;
 
    return nullptr;
}

References sGroupMgr.

Referenced by AddOrSetPlayerToCorrectBfGroup().

GetGameObject()

GameObject * Battlefield::GetGameObject

(

ObjectGuid const &

guid

)

{
    if (!BfMap)
        return nullptr;
 
    return BfMap->GetGameObject(guid);
}

References BfMap, and Map::GetGameObject().

Referenced by BfWGGameObjectBuilding::Destroyed(), BfCapturePoint::GetCapturePointGo(), BattlefieldWG::GetRelic(), BfWGGameObjectBuilding::Rebuild(), and BfWGGameObjectBuilding::UpdateTurretAttack().

GetGraveyardById()

BfGraveyard * Battlefield::GetGraveyardById

(

uint32

id

)

const

{
    if (id < GraveyardList.size())
    {
        if (GraveyardList[id])
            return GraveyardList[id];
        else
            LOG_ERROR("bg.battlefield", "Battlefield::GetGraveyardById Id:{} not existed", id);
    }
    else
        LOG_ERROR("bg.battlefield", "Battlefield::GetGraveyardById Id:{} cant be found", id);
 
    return nullptr;
}

References GraveyardList, and LOG_ERROR.

Referenced by BattlefieldWG::GetData(), WGWorkshop::GiveControlTo(), BattlefieldWG::OnBattleEnd(), and WGWorkshop::UpdateGraveyardAndWorkshop().

GetGraveyardVector()

GraveyardVect const & Battlefield::GetGraveyardVector ( ) const

inline

{ return GraveyardList; }

References GraveyardList.

Referenced by npc_wg_spirit_guide::OnGossipHello(), and npc_wg_spirit_guide::OnGossipSelect().

GetGroupPlayer()

Group * Battlefield::GetGroupPlayer	(	ObjectGuid	guid,
		TeamId	teamId
	)

Return battlefield group where player is.

{
    for (ObjectGuid const& groupGuid : Groups[teamId])
        if (Group* group = sGroupMgr->GetGroupByGUID(groupGuid.GetCounter()))
            if (group->IsMember(guid))
                return group;
 
    return nullptr;
}

References sGroupMgr.

GetInvitedPlayersMap()

PlayerTimerMap const & Battlefield::GetInvitedPlayersMap ( TeamId  teamId ) const

inline

Returns the map of players invited to join the active war, value is invite expiry timestamp (per team, read-only).

{ return InvitedPlayers[teamId]; }

References InvitedPlayers.

Referenced by bf_commandscript::HandleBattlefieldQueue().

GetMaxPlayersPerTeam()

uint32 Battlefield::GetMaxPlayersPerTeam ( ) const

inline

{ return MaxPlayer; }

References MaxPlayer.

GetOtherTeam()

TeamId Battlefield::GetOtherTeam ( TeamId  team ) const

inline

{ return (team == TEAM_HORDE ? TEAM_ALLIANCE : TEAM_HORDE); }

References TEAM_ALLIANCE, and TEAM_HORDE.

Referenced by InvitePlayerToQueue().

GetPlayersInWarCount()

uint32 Battlefield::GetPlayersInWarCount ( TeamId  teamId ) const

inline

{ return static_cast<uint32>(PlayersInWar[teamId].size() + InvitedPlayers[teamId].size()); }

References InvitedPlayers, and PlayersInWar.

Referenced by HasWarVacancy().

GetPlayersInWarSet()

GuidUnorderedSet const & Battlefield::GetPlayersInWarSet ( TeamId  teamId ) const

inline

Returns the set of players actively fighting in the war (per team, read-only).

{ return PlayersInWar[teamId]; }

References PlayersInWar.

Referenced by bf_commandscript::HandleBattlefieldQueue().

GetPlayersInZoneCount()

uint32 Battlefield::GetPlayersInZoneCount ( TeamId  teamId ) const

inline

{ return static_cast<uint32>(Players[teamId].size()); }

References Players.

GetPlayersQueueSet()

GuidUnorderedSet const & Battlefield::GetPlayersQueueSet ( TeamId  teamId ) const

inline

Returns the set of players waiting in the pre-battle queue (per team, read-only).

{ return PlayersInQueue[teamId]; }

References PlayersInQueue.

Referenced by bf_commandscript::HandleBattlefieldQueue().

GetTimer()

uint32 Battlefield::GetTimer ( ) const

inline

{ return Timer; }

References Timer.

Referenced by BattlefieldWG::FillInitialWorldStates(), bf_commandscript::HandleBattlefieldQueue(), instance_vault_of_archavon::instance_vault_of_archavon_InstanceMapScript::IsEncounterInProgress(), achievement_wg_within_our_grasp::OnCheck(), npc_wg_queue::OnGossipHello(), npc_wg_queue::OnGossipSelect(), and BattlefieldWG::SendUpdateWorldStates().

GetTypeId()

uint32 Battlefield::GetTypeId ( ) const

inline

{ return TypeId; }

References TypeId.

Referenced by SpellArea::IsFitToRequirements(), and Player::SendInitWorldStates().

GetZoneId()

uint32 Battlefield::GetZoneId ( ) const

inline

{ return ZoneId; }

References ZoneId.

Referenced by WorldSession::HandleBfEntryInviteResponse(), KickAfkPlayers(), and KickPlayerFromBattlefield().

HandleKill()

virtual void Battlefield::HandleKill ( Player *  , Unit *    )

inlinevirtual

Called when a Unit is killed in battlefield zone.

Reimplemented in BattlefieldWG.

{};

HandlePlayerEnterZone()

void Battlefield::HandlePlayerEnterZone	(	Player *	player,
		uint32	zone
	)

Called when player (player) enters the zone.

Todo:

: Send a packet to announce it to player

{
    RemovePlayerFromTracking(player->GetGUID());
 
    // Allow scripts to adjust the player's effective team or appearance before
    // any team-based battlefield containers (such as player lists or queues) are updated.
    sScriptMgr->OnBattlefieldPlayerEnterZone(this, player);
 
    TryRejoinAfterLogout(player); // relog: auto-rejoin, skip invite below
 
    // Xinef: do not invite players on taxi
    // GMs are not invited to war (see InvitePlayerToWar), so skip queue and slot tracking too
    if (!player->IsInFlight() && !player->IsGameMaster())
    {
        // If battle is started,
        // If not full of players > invite player to join the war
        // If full of players > announce to player that BF is full and kick him after a few second if he doesn't leave
        if (IsWarTime())
        {
            if (HasWarVacancy(player->GetTeamId()))
                InvitePlayerToWar(player);
            else
            {
                PlayersWillBeKick[player->GetTeamId()][player->GetGUID()] = GameTime::GetGameTime().count() + 10;
                InvitePlayerToQueue(player);
            }
        }
        else
        {
            // If time left is < 15 minutes invite player to join queue
            if (Timer <= StartGroupingTimer)
                InvitePlayerToQueue(player);
        }
    }
 
    Players[player->GetTeamId()].insert(player->GetGUID());
    OnPlayerEnterZone(player);
}

References GameTime::GetGameTime(), Object::GetGUID(), Player::GetTeamId(), HasWarVacancy(), InvitePlayerToQueue(), InvitePlayerToWar(), Player::IsGameMaster(), Unit::IsInFlight(), IsWarTime(), OnPlayerEnterZone(), Players, PlayersWillBeKick, RemovePlayerFromTracking(), sScriptMgr, StartGroupingTimer, and TryRejoinAfterLogout().

Referenced by BattlefieldMgr::HandlePlayerEnterZone().

HandlePlayerLeaveZone()

void Battlefield::HandlePlayerLeaveZone	(	Player *	player,
		uint32	zone
	)

Called when player (player) leaves the zone.

{
    // Logout still runs full leave-war cleanup, but marks the player for grace-window auto-rejoin.
    bool const isLogout = player->GetSession() && player->GetSession()->PlayerLogout();
 
    if (IsWarTime())
    {
        // If the player is participating to the battle
        if (PlayersInWar[player->GetTeamId()].erase(player->GetGUID()))
        {
            if (isLogout)
                LogoutGracePlayers[player->GetTeamId()][player->GetGUID()] =
                    GameTime::GetGameTime().count() + LOGOUT_GRACE_SECONDS;
            else
                player->GetSession()->SendBfLeaveMessage(BattleId);
 
            if (Group* group = player->GetGroup()) // Remove the player from the raid group
                if (group->isBFGroup())
                    group->RemoveMember(player->GetGUID());
 
            OnPlayerLeaveWar(player);
            sScriptMgr->OnBattlefieldPlayerLeaveWar(this, player);
        }
    }
 
    for (BfCapturePoint* cp : CapturePoints)
        cp->HandlePlayerLeave(player);
 
    RemovePlayerFromTracking(player->GetGUID(), /*removeFromQueue=*/false);
    SendRemoveWorldStates(player);
    RemovePlayerFromResurrectQueue(player->GetGUID());
    OnPlayerLeaveZone(player);
}

References BattleId, CapturePoints, GameTime::GetGameTime(), Player::GetGroup(), Object::GetGUID(), Player::GetSession(), Player::GetTeamId(), IsWarTime(), LOGOUT_GRACE_SECONDS, LogoutGracePlayers, OnPlayerLeaveWar(), OnPlayerLeaveZone(), WorldSession::PlayerLogout(), PlayersInWar, RemovePlayerFromResurrectQueue(), RemovePlayerFromTracking(), WorldSession::SendBfLeaveMessage(), SendRemoveWorldStates(), and sScriptMgr.

HasPlayer()

bool Battlefield::HasPlayer ( Player *  player ) const

protected

{
    for (uint8 i = 0; i < PVP_TEAMS_COUNT; ++i)
        if (Players[i].count(player->GetGUID()))
            return true;
    return false;
}

References Object::GetGUID(), Players, and PVP_TEAMS_COUNT.

HasWarVacancy()

bool Battlefield::HasWarVacancy ( TeamId  teamId ) const

inline

Returns true if there is still room for another player on the given team in the active war.

{ return GetPlayersInWarCount(teamId) < MaxPlayer; }

References GetPlayersInWarCount(), and MaxPlayer.

Referenced by HandlePlayerEnterZone(), InvitePlayersInQueueToWar(), InvitePlayersInZoneToWar(), and TryRejoinAfterLogout().

HideNpc()

void Battlefield::HideNpc

(

Creature *

creature

)

{
    creature->CombatStop();
    creature->SetReactState(REACT_PASSIVE);
    creature->SetUnitFlag(UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE);
    creature->SetPhaseMask(2, false); // pussywizard: false because UpdateObjectVisibility(true) is called below in SetVisible(), no need to have it here
    creature->DisappearAndDie();
    creature->SetVisible(false);
}

References Unit::CombatStop(), Creature::DisappearAndDie(), REACT_PASSIVE, Unit::SetPhaseMask(), Creature::SetReactState(), Unit::SetUnitFlag(), Unit::SetVisible(), UNIT_FLAG_NON_ATTACKABLE, and UNIT_FLAG_NOT_SELECTABLE.

Referenced by BfWGGameObjectBuilding::Damaged(), BfWGGameObjectBuilding::Init(), BattlefieldWG::OnBattleEnd(), BattlefieldWG::SetupBattlefield(), BfWGGameObjectBuilding::UpdateCreatureAndGo(), and BfWGGameObjectBuilding::UpdateTurretAttack().

InitStalker()

void Battlefield::InitStalker	(	uint32	entry,
		float	x,
		float	y,
		float	z,
		float	o
	)

{
    if (Creature* creature = SpawnCreature(entry, x, y, z, o, TEAM_NEUTRAL))
        StalkerGuid = creature->GetGUID();
    else
        LOG_ERROR("bg.battlefield", "Battlefield::InitStalker: could not spawn Stalker (Creature entry {}), zone messages will be unavailable", entry);
}

References LOG_ERROR, SpawnCreature(), StalkerGuid, and TEAM_NEUTRAL.

Referenced by BattlefieldWG::SetupBattlefield().

InvitePlayersInQueueToWar()

void Battlefield::InvitePlayersInQueueToWar

(

)

Invite all players in queue to join battle on battle start.

{
    for (uint8 team = 0; team < PVP_TEAMS_COUNT; ++team)
    {
        GuidUnorderedSet copy(PlayersInQueue[team]);
        for (ObjectGuid const& guid : copy)
            if (Player* player = ObjectAccessor::FindPlayer(guid))
                if (HasWarVacancy(player->GetTeamId()))
                    InvitePlayerToWar(player);
        PlayersInQueue[team].clear();
    }
}

References ObjectAccessor::FindPlayer(), HasWarVacancy(), InvitePlayerToWar(), PlayersInQueue, and PVP_TEAMS_COUNT.

Referenced by StartBattle().

InvitePlayersInZoneToQueue()

void Battlefield::InvitePlayersInZoneToQueue

(

)

Invite all players in zone to join the queue, called x minutes before battle start in Update()

{
    ForEachPlayerInZone([this](Player* player) { InvitePlayerToQueue(player); });
}

References ForEachPlayerInZone(), and InvitePlayerToQueue().

Referenced by Update().

InvitePlayersInZoneToWar()

void Battlefield::InvitePlayersInZoneToWar

(

)

Invite all players in zone to join battle on battle start.

{
    ForEachPlayerInZone([this](Player* player)
    {
        // Skip GMs: they are never invited, so they would linger in PlayersWillBeKick forever
        if (player->IsGameMaster())
            return;
 
        if (IsPlayerInWarOrInvited(player))
            return;
 
        if (HasWarVacancy(player->GetTeamId()))
            InvitePlayerToWar(player);
        else if (!PlayersWillBeKick[player->GetTeamId()].count(player->GetGUID())) // Battlefield is full of players
            PlayersWillBeKick[player->GetTeamId()][player->GetGUID()] = GameTime::GetGameTime().count() + 10;
    });
}

References ForEachPlayerInZone(), GameTime::GetGameTime(), Object::GetGUID(), Player::GetTeamId(), HasWarVacancy(), InvitePlayerToWar(), Player::IsGameMaster(), IsPlayerInWarOrInvited(), and PlayersWillBeKick.

Referenced by StartBattle().

InvitePlayerToQueue()

void Battlefield::InvitePlayerToQueue

(

Player *

player

)

{
    if (player->IsGameMaster()) // GMs are not invited to war, so don't queue them either
        return;
 
    if (PlayersInQueue[player->GetTeamId()].count(player->GetGUID()))
        return;
 
    if (PlayersInQueue[player->GetTeamId()].size() <= MinPlayer || PlayersInQueue[GetOtherTeam(player->GetTeamId())].size() >= MinPlayer)
        player->GetSession()->SendBfInvitePlayerToQueue(BattleId);
}

References BattleId, Object::GetGUID(), GetOtherTeam(), Player::GetSession(), Player::GetTeamId(), Player::IsGameMaster(), MinPlayer, PlayersInQueue, and WorldSession::SendBfInvitePlayerToQueue().

Referenced by HandlePlayerEnterZone(), InvitePlayersInZoneToQueue(), and npc_wg_queue::OnGossipSelect().

InvitePlayerToWar()

void Battlefield::InvitePlayerToWar

(

Player *

player

)

Todo:

: needed ?

{
    if (!player)
        return;
 
    if (player->IsGameMaster())
        return;
 
    if (player->IsInFlight())
        return;
 
    if (player->InBattleground())
    {
        PlayersInQueue[player->GetTeamId()].erase(player->GetGUID());
        return;
    }
 
    // If the player does not match minimal level requirements for the battlefield, kick him
    if (player->GetLevel() < MinLevel)
    {
        if (!PlayersWillBeKick[player->GetTeamId()].count(player->GetGUID()))
            PlayersWillBeKick[player->GetTeamId()][player->GetGUID()] = GameTime::GetGameTime().count() + 10;
        return;
    }
 
    // Check if player is not already in war
    if (IsPlayerInWarOrInvited(player))
        return;
 
    sScriptMgr->OnBattlefieldBeforeInvitePlayerToWar(this, player);
 
    PlayersWillBeKick[player->GetTeamId()].erase(player->GetGUID());
    InvitedPlayers[player->GetTeamId()][player->GetGUID()] = GameTime::GetGameTime().count() + TimeForAcceptInvite;
    player->GetSession()->SendBfInvitePlayerToWar(BattleId, ZoneId, TimeForAcceptInvite);
}

References BattleId, GameTime::GetGameTime(), Object::GetGUID(), Unit::GetLevel(), Player::GetSession(), Player::GetTeamId(), Player::InBattleground(), InvitedPlayers, Player::IsGameMaster(), Unit::IsInFlight(), IsPlayerInWarOrInvited(), MinLevel, PlayersInQueue, PlayersWillBeKick, WorldSession::SendBfInvitePlayerToWar(), sScriptMgr, TimeForAcceptInvite, and ZoneId.

Referenced by HandlePlayerEnterZone(), InvitePlayersInQueueToWar(), InvitePlayersInZoneToWar(), and npc_wg_queue::OnGossipSelect().

IsEnabled()

bool Battlefield::IsEnabled ( ) const

inline

Return if battlefield is enabled.

{ return Enabled; }

References Enabled.

Referenced by bf_commandscript::HandleBattlefieldEnable(), and Update().

IsPlayerInBattlefield()

bool Battlefield::IsPlayerInBattlefield

(

ObjectGuid

guid

)

const

{
    if (!IsWarTime())
        return false;
 
    // PlayersInWar is split into per-team sets, but a GUID alone does not indicate the team, so check both sets.
    // This also stays correct if an OnBattlefieldPlayerJoinWar handler reassigned the team GetTeamId() returns.
    for (uint8 team = 0; team < PVP_TEAMS_COUNT; ++team)
        if (PlayersInWar[team].count(guid))
            return true;
 
    return false;
}

References IsWarTime(), PlayersInWar, and PVP_TEAMS_COUNT.

IsPlayerInWarOrInvited()

bool Battlefield::IsPlayerInWarOrInvited ( Player *  player ) const

protected

Returns true if the player is already tracked as actively in the war or invited to join it.

{
    TeamId teamId = player->GetTeamId();
    return PlayersInWar[teamId].count(player->GetGUID()) || InvitedPlayers[teamId].count(player->GetGUID());
}

References Object::GetGUID(), Player::GetTeamId(), InvitedPlayers, and PlayersInWar.

Referenced by InvitePlayersInZoneToWar(), and InvitePlayerToWar().

IsWarTime()

bool Battlefield::IsWarTime ( ) const

inline

Return true if battle is started, false if battle is not started.

{ return Active; }

References Active.

Referenced by Player::CreateCorpse(), BattlefieldWG::FillInitialWorldStates(), bf_commandscript::HandleBattlefieldQueue(), spell_wintergrasp_hide_small_elementals_aura::HandlePeriodicDummy(), HandlePlayerEnterZone(), HandlePlayerLeaveZone(), Player::InBattlefield(), instance_vault_of_archavon::instance_vault_of_archavon_InstanceMapScript::IsEncounterInProgress(), SpellArea::IsFitToRequirements(), IsPlayerInBattlefield(), BattlefieldWG::OnCreatureCreate(), npc_wg_queue::OnGossipHello(), npc_wg_queue::OnGossipSelect(), BattlefieldWG::OnPlayerEnterZone(), BattlefieldWG::OnStartGrouping(), BattlefieldWG::OnUnitDeath(), PlayerAcceptInviteToWar(), BattlefieldWG::ProcessEvent(), BattlefieldWG::SendUpdateWorldStates(), TryRejoinAfterLogout(), and Update().

KickAfkPlayers()

void Battlefield::KickAfkPlayers ( )

protected

{
    ForEachPlayerInWar([this](Player* player)
    {
        if (player->isAFK() && player->GetZoneId() == GetZoneId() && !player->IsGameMaster())
            player->TeleportTo(KickPosition);
    });
}

References ForEachPlayerInWar(), GetZoneId(), WorldObject::GetZoneId(), Player::isAFK(), Player::IsGameMaster(), KickPosition, and Player::TeleportTo().

Referenced by StartBattle().

KickPlayerFromBattlefield()

void Battlefield::KickPlayerFromBattlefield

(

ObjectGuid

guid

)

Kick player from battlefield and teleport him to kick-point location.

Parameters

guid	: guid of player who must be kicked

{
    if (Player* player = ObjectAccessor::FindPlayer(guid))
        if (player->GetZoneId() == GetZoneId() && !player->IsGameMaster()
            && !PlayersInWar[player->GetTeamId()].count(guid))
        {
            player->TeleportTo(KickPosition);
            // Eagerly drop zone tracking: the teleport's zone change does not
            // propagate until the next Player::Update, so callers iterating
            // Players[team] in the same tick would otherwise still see them.
            for (uint8 i = 0; i < PVP_TEAMS_COUNT; ++i)
                Players[i].erase(guid);
        }
}

References ObjectAccessor::FindPlayer(), GetZoneId(), KickPosition, Players, PlayersInWar, and PVP_TEAMS_COUNT.

Referenced by WorldSession::HandleBfEntryInviteResponse(), BattlefieldWG::OnPlayerEnterZone(), and StartBattle().

OnBattleEnd()

virtual void Battlefield::OnBattleEnd ( bool  )

inlinevirtual

Called at the end of battle.

Reimplemented in BattlefieldWG.

{};

Referenced by EndBattle().

OnBattleStart()

virtual void Battlefield::OnBattleStart ( )

inlinevirtual

Called on start.

Reimplemented in BattlefieldWG.

{};

Referenced by StartBattle().

OnPlayerEnterZone()

virtual void Battlefield::OnPlayerEnterZone ( Player *  )

inlinevirtual

Called when a player enters the battlefield zone.

Reimplemented in BattlefieldWG.

{};

Referenced by HandlePlayerEnterZone().

OnPlayerJoinWar()

virtual void Battlefield::OnPlayerJoinWar ( Player *  )

inlinevirtual

Called when a player accepts to join the battle.

Reimplemented in BattlefieldWG.

{};

Referenced by PlayerAcceptInviteToWar(), and TryRejoinAfterLogout().

OnPlayerLeaveWar()

virtual void Battlefield::OnPlayerLeaveWar ( Player *  )

inlinevirtual

Called when a player leaves the battle.

Reimplemented in BattlefieldWG.

{};

Referenced by HandlePlayerLeaveZone().

OnPlayerLeaveZone()

virtual void Battlefield::OnPlayerLeaveZone ( Player *  )

inlinevirtual

Called when a player leaves the battlefield zone.

Reimplemented in BattlefieldWG.

{};

Referenced by HandlePlayerLeaveZone().

OnStartGrouping()

virtual void Battlefield::OnStartGrouping ( )

inlinevirtual

Called x minutes before battle start when players in zone are invited to join queue.

Reimplemented in BattlefieldWG.

{};

Referenced by Update().

PlayerAcceptInviteToQueue()

void Battlefield::PlayerAcceptInviteToQueue

(

Player *

player

)

{
    // Add player in queue
    PlayersInQueue[player->GetTeamId()].insert(player->GetGUID());
    // Send notification
    player->GetSession()->SendBfQueueInviteResponse(BattleId, ZoneId);
}

References BattleId, Object::GetGUID(), Player::GetSession(), Player::GetTeamId(), PlayersInQueue, WorldSession::SendBfQueueInviteResponse(), and ZoneId.

Referenced by WorldSession::HandleBfQueueInviteResponse().

PlayerAcceptInviteToWar()

void Battlefield::PlayerAcceptInviteToWar

(

Player *

player

)

{
    if (!IsWarTime())
        return;
 
    // Reject unknown / expired invites; the kick task only sweeps every 5s.
    TeamId const invitedTeam = player->GetTeamId();
    auto itr = InvitedPlayers[invitedTeam].find(player->GetGUID());
    if (itr == InvitedPlayers[invitedTeam].end()
        || itr->second <= GameTime::GetGameTime().count())
        return;
 
    sScriptMgr->OnBattlefieldPlayerJoinWar(this, player);
 
    if (AddOrSetPlayerToCorrectBfGroup(player))
    {
        player->GetSession()->SendBfEntered(BattleId);
        PlayersInWar[player->GetTeamId()].insert(player->GetGUID());
        // Use pre-hook team: JoinWar may have just reassigned GetTeamId().
        InvitedPlayers[invitedTeam].erase(player->GetGUID());
 
        if (player->isAFK())
            player->ToggleAFK();
 
        OnPlayerJoinWar(player);
    }
}

References AddOrSetPlayerToCorrectBfGroup(), BattleId, GameTime::GetGameTime(), Object::GetGUID(), Player::GetSession(), Player::GetTeamId(), InvitedPlayers, Player::isAFK(), IsWarTime(), OnPlayerJoinWar(), PlayersInWar, WorldSession::SendBfEntered(), sScriptMgr, and Player::ToggleAFK().

Referenced by WorldSession::HandleBfEntryInviteResponse().

PlayerAskToLeave()

void Battlefield::PlayerAskToLeave

(

Player *

player

)

{
    // Player leaving Wintergrasp, teleport to homebind position.
    player->TeleportTo(player->m_homebindMapId, player->m_homebindX, player->m_homebindY, player->m_homebindZ, player->GetOrientation());
}

References Position::GetOrientation(), Player::m_homebindMapId, Player::m_homebindX, Player::m_homebindY, Player::m_homebindZ, and Player::TeleportTo().

RegisterZone()

void Battlefield::RegisterZone ( uint32  zoneId )

protected

{
    sBattlefieldMgr->AddZone(zoneId, this);
}

References sBattlefieldMgr.

Referenced by BattlefieldWG::SetupBattlefield().

RemovePlayerFromResurrectQueue()

void Battlefield::RemovePlayerFromResurrectQueue

(

ObjectGuid

playerGuid

)

{
    Player* player = ObjectAccessor::FindPlayer(playerGuid);
    if (!player)
        return;
 
    player->RemoveAurasDueToSpell(SPELL_WAITING_FOR_RESURRECT);
}

References ObjectAccessor::FindPlayer(), Unit::RemoveAurasDueToSpell(), and SPELL_WAITING_FOR_RESURRECT.

Referenced by HandlePlayerLeaveZone().

RemovePlayerFromTracking()

void Battlefield::RemovePlayerFromTracking ( ObjectGuid  playerGuid, bool  removeFromQueue = true  )

protected

{
    for (uint8 i = 0; i < PVP_TEAMS_COUNT; ++i)
    {
        InvitedPlayers[i].erase(playerGuid);
        if (removeFromQueue)
            PlayersInQueue[i].erase(playerGuid);
        PlayersWillBeKick[i].erase(playerGuid);
        Players[i].erase(playerGuid);
    }
}

References InvitedPlayers, Players, PlayersInQueue, PlayersWillBeKick, and PVP_TEAMS_COUNT.

Referenced by HandlePlayerEnterZone(), and HandlePlayerLeaveZone().

SendAreaSpiritHealerQueryOpcode()

void Battlefield::SendAreaSpiritHealerQueryOpcode	(	Player *	player,
		ObjectGuid const &	guid
	)

{
    WorldPacket data(SMSG_AREA_SPIRIT_HEALER_TIME, 12);
    Milliseconds remaining = _scheduler.GetNextGroupOccurrence(BATTLEFIELD_TIMER_GROUP_RESURRECT);
    uint32 time = static_cast<uint32>(std::clamp(remaining,
        Milliseconds::zero(), Milliseconds(RESURRECTION_INTERVAL)).count());
 
    data << guid << time;
    ASSERT(player);
    player->SendDirectMessage(&data);
}

References _scheduler, ASSERT, BATTLEFIELD_TIMER_GROUP_RESURRECT, TaskScheduler::GetNextGroupOccurrence(), RESURRECTION_INTERVAL, Player::SendDirectMessage(), and SMSG_AREA_SPIRIT_HEALER_TIME.

Referenced by npc_wg_spirit_guide::OnGossipHello().

SendInitWorldStatesToAll()

virtual void Battlefield::SendInitWorldStatesToAll ( )

pure virtual

Send all worldstate data to all players in zone.

Implemented in BattlefieldWG.

Referenced by EndBattle(), and bf_commandscript::HandleBattlefieldTimer().

SendRemoveWorldStates()

virtual void Battlefield::SendRemoveWorldStates ( Player *  )

inlineprotectedvirtual

{}

Referenced by HandlePlayerLeaveZone().

SendUpdateWorldState()

void Battlefield::SendUpdateWorldState	(	uint32	field,
		uint32	value
	)

Update data of a worldstate to all players present in zone.

{
    ForEachPlayerInZone([field, value](Player* player) { player->SendUpdateWorldState(field, value); });
}

References ForEachPlayerInZone(), and Player::SendUpdateWorldState().

Referenced by BfWGGameObjectBuilding::Damaged(), BfWGGameObjectBuilding::Destroyed(), WGWorkshop::GiveControlTo(), and BfWGGameObjectBuilding::Rebuild().

SendUpdateWorldStates()

virtual void Battlefield::SendUpdateWorldStates ( Player *  player = nullptr )

pure virtual

Implemented in BattlefieldWG.

Referenced by EndBattle(), StartBattle(), and Update().

SendWarning()

void Battlefield::SendWarning	(	uint8	id,
		WorldObject const *	target = nullptr
	)

{
    if (Creature* stalker = GetCreature(StalkerGuid))
        sCreatureTextMgr->SendChat(stalker, id, target);
}

References GetCreature(), sCreatureTextMgr, and StalkerGuid.

Referenced by BfWGGameObjectBuilding::Damaged(), BfWGGameObjectBuilding::Destroyed(), WGWorkshop::GiveControlTo(), BattlefieldWG::OnBattleEnd(), BattlefieldWG::OnBattleStart(), BattlefieldWG::OnStartGrouping(), and BattlefieldWG::PromotePlayer().

SetData()

void Battlefield::SetData ( uint32  dataId, uint32  value  )

inlineoverridevirtual

Reimplemented from ZoneScript.

{ Data32[dataId] = value; }

References Data32.

Referenced by BattlefieldWG::OnBattleStart(), and BattlefieldWG::UpdateCounterVehicle().

SetData64()

void Battlefield::SetData64 ( uint32  dataId, uint64  value  )

inlineoverridevirtual

Reimplemented from ZoneScript.

{ Data64[dataId] = value; }

SetDefenderTeam()

void Battlefield::SetDefenderTeam ( TeamId  team )

inline

{ DefenderTeam = team; }

References DefenderTeam.

Referenced by EndBattle().

SetGraveyardNumber()

void Battlefield::SetGraveyardNumber ( uint32  number )

inline

{ GraveyardList.resize(number); }

References GraveyardList.

Referenced by BattlefieldWG::SetupBattlefield().

SetTimer()

void Battlefield::SetTimer ( uint32  timer )

inline

{ Timer = timer; }

Referenced by bf_commandscript::HandleBattlefieldTimer().

SetupBattlefield()

virtual bool Battlefield::SetupBattlefield ( )

inlinevirtual

Call this to init the Battlefield.

Reimplemented in BattlefieldWG.

{ return true; }

Referenced by BattlefieldMgr::InitBattlefield().

ShowNpc()

void Battlefield::ShowNpc	(	Creature *	creature,
		bool	aggressive
	)

{
    creature->SetPhaseMask(1, false); // pussywizard: false because UpdateObjectVisibility(true) is called below in SetVisible(), no need to have it here
    creature->SetVisible(true);
    creature->RemoveUnitFlag(UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE);
    if (!creature->IsAlive())
        creature->Respawn(true);
    if (aggressive)
        creature->SetReactState(REACT_AGGRESSIVE);
    else
    {
        creature->SetUnitFlag(UNIT_FLAG_NON_ATTACKABLE);
        creature->SetReactState(REACT_PASSIVE);
    }
}

References Unit::IsAlive(), REACT_AGGRESSIVE, REACT_PASSIVE, Unit::RemoveUnitFlag(), Creature::Respawn(), Unit::SetPhaseMask(), Creature::SetReactState(), Unit::SetUnitFlag(), Unit::SetVisible(), UNIT_FLAG_NON_ATTACKABLE, and UNIT_FLAG_NOT_SELECTABLE.

Referenced by BattlefieldWG::OnBattleEnd(), BattlefieldWG::OnBattleStart(), BfWGGameObjectBuilding::UpdateCreatureAndGo(), and BfWGGameObjectBuilding::UpdateTurretAttack().

SpawnCreature() [1/2]

Creature * Battlefield::SpawnCreature	(	uint32	entry,
		float	x,
		float	y,
		float	z,
		float	o,
		TeamId	teamId
	)

{
    Map* map = sMapMgr->CreateBaseMap(MapId);
    if (!map)
    {
        LOG_ERROR("bg.battlefield", "Battlefield::SpawnCreature: Can't create creature entry: {} map not found", entry);
        return nullptr;
    }
 
    CreatureTemplate const* cinfo = sObjectMgr->GetCreatureTemplate(entry);
    if (!cinfo)
    {
        LOG_ERROR("sql.sql", "Battlefield::SpawnCreature: entry {} does not exist.", entry);
        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.battlefield", "Battlefield::SpawnCreature: Can't create creature entry: {}", entry);
        delete creature;
        return nullptr;
    }
 
    // no need to set faction for neutral team
    if (teamId == TEAM_ALLIANCE || teamId == TEAM_HORDE)
        creature->SetFaction(BattlefieldFactions[teamId]);
 
    creature->SetHomePosition(x, y, z, o);
 
    // force using DB speeds -- do we really need this?
    creature->SetSpeed(MOVE_WALK, cinfo->speed_walk);
    creature->SetSpeed(MOVE_RUN, cinfo->speed_run);
 
    map->AddToMap(creature);
    creature->setActive(true);
 
    return creature;
}

References Map::AddToMap(), BattlefieldFactions, Creature::Create(), Map::GenerateLowGuid(), LOG_ERROR, MapId, MOVE_RUN, MOVE_WALK, PHASEMASK_NORMAL, WorldObject::setActive(), Unit::SetFaction(), Creature::SetHomePosition(), Unit::SetSpeed(), sMapMgr, sObjectMgr, CreatureTemplate::speed_run, CreatureTemplate::speed_walk, TEAM_ALLIANCE, TEAM_HORDE, and Unit.

Referenced by BfWGGameObjectBuilding::Init(), InitStalker(), BattlefieldWG::SetupBattlefield(), and SpawnCreature().

SpawnCreature() [2/2]

Creature * Battlefield::SpawnCreature	(	uint32	entry,
		Position	pos,
		TeamId	teamId
	)

{
    return SpawnCreature(entry, pos.m_positionX, pos.m_positionY, pos.m_positionZ, pos.m_orientation, teamId);
}

References Position::m_orientation, Position::m_positionX, Position::m_positionY, Position::m_positionZ, and SpawnCreature().

SpawnGameObject()

GameObject * Battlefield::SpawnGameObject	(	uint32	entry,
		float	x,
		float	y,
		float	z,
		float	o
	)

{
    Map* map = sMapMgr->CreateBaseMap(MapId);
    if (!map)
        return nullptr;
 
    GameObject* go = sObjectMgr->IsGameObjectStaticTransport(entry) ? new StaticTransport() : new GameObject();
    G3D::Quat rotation = G3D::Quat::fromAxisAngleRotation(G3D::Vector3::unitZ(), o);
    if (!go->Create(map->GenerateLowGuid<HighGuid::GameObject>(), entry, map, PHASEMASK_NORMAL, x, y, z, o, rotation, 100, GO_STATE_READY))
    {
        LOG_ERROR("sql.sql", "Battlefield::SpawnGameObject: Gameobject template {} not found in database! Battlefield not created!", entry);
        LOG_ERROR("bg.battlefield", "Battlefield::SpawnGameObject: Cannot create gameobject template {}! Battlefield not created!", entry);
        delete go;
        return nullptr;
    }
 
    map->AddToMap(go);
    go->setActive(true);
 
    return go;
}

References Map::AddToMap(), GameObject::Create(), GameObject, Map::GenerateLowGuid(), GO_STATE_READY, LOG_ERROR, MapId, PHASEMASK_NORMAL, WorldObject::setActive(), sMapMgr, and sObjectMgr.

Referenced by BfWGGameObjectBuilding::Init(), BattlefieldWG::OnBattleStart(), and BattlefieldWG::SetupBattlefield().

StartBattle()

void Battlefield::StartBattle

(

)

{
    if (Active)
        return;
 
    for (uint8 team = 0; team < PVP_TEAMS_COUNT; ++team)
    {
        PlayersInWar[team].clear();
        Groups[team].clear();
        LogoutGracePlayers[team].clear();
    }
 
    Timer = BattleTime;
    Active = true;
 
    // Schedule war-only periodic timers
    _scheduler.Schedule(1s, BATTLEFIELD_TIMER_GROUP_WAR, [this](TaskContext context)
    {
        KickAfkPlayers();
        context.Repeat(20s);
    });
 
    _scheduler.Schedule(1s, BATTLEFIELD_TIMER_GROUP_WAR, [this](TaskContext context)
    {
        time_t const now = GameTime::GetGameTime().count();
 
        // Send eject so the 3.3.5 client closes its popup (it does not on its
        // own when the timer hits zero), then drop the entry and teleport.
        for (uint8 team = 0; team < PVP_TEAMS_COUNT; ++team)
        {
            std::vector<ObjectGuid> expired;
            for (auto const& [guid, expireAt] : InvitedPlayers[team])
                if (expireAt <= now)
                    expired.push_back(guid);
 
            for (ObjectGuid const& guid : expired)
            {
                if (Player* player = ObjectAccessor::FindPlayer(guid))
                    player->GetSession()->SendBfLeaveMessage(BattleId, BF_LEAVE_REASON_EXITED);
                InvitedPlayers[team].erase(guid);
                KickPlayerFromBattlefield(guid);
            }
        }
 
        InvitePlayersInZoneToWar();
        for (uint8 team = 0; team < PVP_TEAMS_COUNT; ++team)
            for (PlayerTimerMap::value_type const& pair : PlayersWillBeKick[team])
                if (pair.second <= now)
                    KickPlayerFromBattlefield(pair.first);
 
        context.Repeat(5s);
    });
 
    InvitePlayersInZoneToWar();
    InvitePlayersInQueueToWar();
 
    DoPlaySoundToAll(BF_START);
 
    OnBattleStart();
 
    SendUpdateWorldStates();
}

References _scheduler, Active, BATTLEFIELD_TIMER_GROUP_WAR, BattleId, BattleTime, BF_LEAVE_REASON_EXITED, BF_START, DoPlaySoundToAll(), ObjectAccessor::FindPlayer(), GameTime::GetGameTime(), InvitedPlayers, InvitePlayersInQueueToWar(), InvitePlayersInZoneToWar(), KickAfkPlayers(), KickPlayerFromBattlefield(), LogoutGracePlayers, OnBattleStart(), PlayersInWar, PlayersWillBeKick, PVP_TEAMS_COUNT, TaskContext::Repeat(), TaskScheduler::Schedule(), and SendUpdateWorldStates().

Referenced by bf_commandscript::HandleBattlefieldStart(), and Update().

TeamApplyBuff()

void Battlefield::TeamApplyBuff	(	TeamId	team,
		uint32	spellId,
		uint32	spellId2 = 0
	)

TeamCastSpell()

void Battlefield::TeamCastSpell ( TeamId  team, int32  spellId  )

protected

{
    ForEachPlayerInWar(team, [spellId](Player* player)
    {
        if (spellId > 0)
            player->CastSpell(player, uint32(spellId), true);
        else
            player->RemoveAuraFromStack(uint32(-spellId));
    });
}

References Unit::CastSpell(), ForEachPlayerInWar(), and Unit::RemoveAuraFromStack().

ToggleBattlefield()

void Battlefield::ToggleBattlefield ( bool  enable )

inline

Enable or Disable battlefield.

{ Enabled = enable; }

References Enabled.

Referenced by bf_commandscript::HandleBattlefieldEnable().

TryRejoinAfterLogout()

void Battlefield::TryRejoinAfterLogout

(

Player *

player

)

Auto-rejoin a player who relogged within the grace window after a mid-war logout, via the normal join hooks. No-op without a pending logout marker. Called from HandlePlayerEnterZone (which fires on the post-login zone set).

{
    ObjectGuid const guid = player->GetGUID();
    time_t const now = GameTime::GetGameTime().count();
 
    // Consume the marker and honor its grace window (check both teams; team may have changed).
    bool pending = false;
    for (uint8 team = 0; team < PVP_TEAMS_COUNT; ++team)
        if (auto itr = LogoutGracePlayers[team].find(guid); itr != LogoutGracePlayers[team].end())
        {
            pending = itr->second > now;
            LogoutGracePlayers[team].erase(itr);
        }
 
    // Vacancy gate mirrors HandlePlayerEnterZone (full team -> queue path). Pre-hook:
    // we can't abort after JoinWar, which may already have mutated module state.
    if (!pending || !IsWarTime() || !HasWarVacancy(player->GetTeamId()))
        return;
 
    if (Group* current = player->GetGroup())
        if (current->isBGGroup() || current->isBFGroup())
            return;
 
    // Rejoin via the normal join path: firing JoinWar lets modules rebuild
    // per-session (Player*-keyed) state and pick the team before the raid bind.
    sScriptMgr->OnBattlefieldPlayerJoinWar(this, player);
 
    if (AddOrSetPlayerToCorrectBfGroup(player))
    {
        player->GetSession()->SendBfEntered(BattleId);
        PlayersInWar[player->GetTeamId()].insert(guid);
        OnPlayerJoinWar(player);
    }
}

References AddOrSetPlayerToCorrectBfGroup(), BattleId, GameTime::GetGameTime(), Player::GetGroup(), Object::GetGUID(), Player::GetSession(), Player::GetTeamId(), HasWarVacancy(), IsWarTime(), LogoutGracePlayers, OnPlayerJoinWar(), PlayersInWar, PVP_TEAMS_COUNT, WorldSession::SendBfEntered(), and sScriptMgr.

Referenced by HandlePlayerEnterZone().

Update()

bool Battlefield::Update ( uint32  diff )

virtual

Called every time for update bf data and time.

• Update timer for start/end battle
• Invite player in zone to queue StartGroupingTimer minutes before start
• Kick Afk players

  Parameters

  diff	: time elapsed since last call (in ms)

Reimplemented in BattlefieldWG.

{
    if (Timer <= diff)
    {
        uint32 sessionLimit = sWorld->getIntConfig(CONFIG_WINTERGRASP_SKIP_BATTLE_SESSION_COUNT);
        bool tooManySessions = sessionLimit && !IsWarTime()
            && sWorldSessionMgr->GetActiveSessionCount() > sessionLimit;
 
        if (!IsEnabled() || tooManySessions)
        {
            Active = true;
            EndBattle(false);
            return false;
        }
        // Battlefield ends on time
        if (IsWarTime())
            EndBattle(true);
        else // Time to start a new battle!
            StartBattle();
    }
    else
        Timer -= diff;
 
    if (!IsEnabled())
        return false;
 
    // Invite players a few minutes before the battle's beginning
    if (!IsWarTime() && !StartGrouping && Timer <= StartGroupingTimer)
    {
        StartGrouping = true;
        InvitePlayersInZoneToQueue();
        OnStartGrouping();
        SendUpdateWorldStates();
    }
 
    _scheduler.Update();
 
    bool objectiveChanged = false;
    if (IsWarTime())
    {
        for (BfCapturePoint* cp : CapturePoints)
            if (cp->Update(diff))
                objectiveChanged = true;
    }
 
    return objectiveChanged;
}

References _scheduler, Active, CapturePoints, CONFIG_WINTERGRASP_SKIP_BATTLE_SESSION_COUNT, EndBattle(), InvitePlayersInZoneToQueue(), IsEnabled(), IsWarTime(), OnStartGrouping(), SendUpdateWorldStates(), StartBattle(), StartGrouping, StartGroupingTimer, sWorld, sWorldSessionMgr, and TaskScheduler::Update().

Referenced by BattlefieldWG::Update().

UpdateData()

virtual void Battlefield::UpdateData ( uint32  index, int32  pad  )

inlinevirtual

{ Data32[index] += pad; }

References Data32.

Friends And Related Symbol Documentation

BattlefieldMgr

friend class BattlefieldMgr

friend

Member Data Documentation

_scheduler

TaskScheduler Battlefield::_scheduler

protected

Referenced by EndBattle(), BattlefieldWG::OnBattleStart(), SendAreaSpiritHealerQueryOpcode(), BattlefieldWG::SetupBattlefield(), StartBattle(), and Update().

Active

bool Battlefield::Active

protected

Referenced by CanFlyIn(), EndBattle(), IsWarTime(), BattlefieldWG::OnPlayerEnterZone(), BattlefieldWG::OnPlayerLeaveZone(), BattlefieldWG::PromotePlayer(), BattlefieldWG::SetupBattlefield(), StartBattle(), and Update().

BattleId

uint32 Battlefield::BattleId

protected

Referenced by AskToLeaveQueue(), GetBattleId(), HandlePlayerLeaveZone(), InvitePlayerToQueue(), InvitePlayerToWar(), PlayerAcceptInviteToQueue(), PlayerAcceptInviteToWar(), BattlefieldWG::SetupBattlefield(), StartBattle(), and TryRejoinAfterLogout().

BattleTime

uint32 Battlefield::BattleTime

protected

Referenced by BattlefieldWG::SetupBattlefield(), and StartBattle().

BfMap

Map* Battlefield::BfMap

protected

Referenced by GetCreature(), GetGameObject(), and BattlefieldWG::SetupBattlefield().

CapturePoints

BfCapturePointVector Battlefield::CapturePoints

protected

Referenced by AddCapturePoint(), HandlePlayerLeaveZone(), BattlefieldWG::OnBattleStart(), Update(), and ~Battlefield().

Data32

std::vector<uint32> Battlefield::Data32

protected

Referenced by GetData(), SetData(), BattlefieldWG::SetupBattlefield(), and UpdateData().

Data64

std::vector<uint64> Battlefield::Data64

protected

DefenderTeam

TeamId Battlefield::DefenderTeam

protected

Referenced by BattlefieldWG::FillInitialWorldStates(), GetAttackerTeam(), GetDefenderTeam(), BattlefieldWG::OnBattleEnd(), BattlefieldWG::OnPlayerEnterZone(), SetDefenderTeam(), and BattlefieldWG::SetupBattlefield().

Enabled

bool Battlefield::Enabled

protected

Referenced by IsEnabled(), BattlefieldWG::SetupBattlefield(), and ToggleBattlefield().

GraveyardList

GraveyardVect Battlefield::GraveyardList

protected

Referenced by GetClosestGraveyard(), GetGraveyardById(), GetGraveyardVector(), BattlefieldWG::OnCreatureCreate(), SetGraveyardNumber(), BattlefieldWG::SetupBattlefield(), and ~Battlefield().

Groups

GuidUnorderedSet Battlefield::Groups[PVP_TEAMS_COUNT]

protected

InvitedPlayers

PlayerTimerMap Battlefield::InvitedPlayers[PVP_TEAMS_COUNT]

protected

Referenced by GetInvitedPlayersMap(), GetPlayersInWarCount(), InvitePlayerToWar(), IsPlayerInWarOrInvited(), PlayerAcceptInviteToWar(), RemovePlayerFromTracking(), and StartBattle().

KickPosition

WorldLocation Battlefield::KickPosition

protected

Referenced by KickAfkPlayers(), KickPlayerFromBattlefield(), and BattlefieldWG::SetupBattlefield().

LOGOUT_GRACE_SECONDS

constexpr uint32 Battlefield::LOGOUT_GRACE_SECONDS = 120

staticconstexprprotected

Referenced by HandlePlayerLeaveZone().

LogoutGracePlayers

PlayerTimerMap Battlefield::LogoutGracePlayers[PVP_TEAMS_COUNT]

protected

Referenced by HandlePlayerLeaveZone(), StartBattle(), and TryRejoinAfterLogout().

MapId

uint32 Battlefield::MapId

protected

Referenced by BattlefieldWG::SendInitWorldStatesTo(), BattlefieldWG::SetupBattlefield(), SpawnCreature(), and SpawnGameObject().

MaxPlayer

uint32 Battlefield::MaxPlayer

protected

Referenced by GetMaxPlayersPerTeam(), HasWarVacancy(), and BattlefieldWG::SetupBattlefield().

MinLevel

uint32 Battlefield::MinLevel

protected

Referenced by InvitePlayerToWar(), and BattlefieldWG::SetupBattlefield().

MinPlayer

uint32 Battlefield::MinPlayer

protected

Referenced by InvitePlayerToQueue(), and BattlefieldWG::SetupBattlefield().

NoWarBattleTime

uint32 Battlefield::NoWarBattleTime

protected

Referenced by EndBattle(), and BattlefieldWG::SetupBattlefield().

Players

GuidUnorderedSet Battlefield::Players[PVP_TEAMS_COUNT]

protected

Referenced by BattlefieldWG::CapturePointTaken(), ForEachPlayerInZone(), GetPlayersInZoneCount(), HandlePlayerEnterZone(), HasPlayer(), KickPlayerFromBattlefield(), BattlefieldWG::OnBattleEnd(), RemovePlayerFromTracking(), BattlefieldWG::SendInitWorldStatesToAll(), and BattlefieldWG::UpdateVehicleCountWG().

PlayersInQueue

GuidUnorderedSet Battlefield::PlayersInQueue[PVP_TEAMS_COUNT]

protected

Referenced by AskToLeaveQueue(), ForEachPlayerInQueue(), GetPlayersQueueSet(), InvitePlayersInQueueToWar(), InvitePlayerToQueue(), InvitePlayerToWar(), PlayerAcceptInviteToQueue(), and RemovePlayerFromTracking().

PlayersInWar

GuidUnorderedSet Battlefield::PlayersInWar[PVP_TEAMS_COUNT]

protected

Referenced by ForEachPlayerInWar(), ForEachPlayerInWar(), GetPlayersInWarCount(), GetPlayersInWarSet(), BattlefieldWG::HandleKill(), HandlePlayerLeaveZone(), IsPlayerInBattlefield(), IsPlayerInWarOrInvited(), KickPlayerFromBattlefield(), BattlefieldWG::OnBattleEnd(), PlayerAcceptInviteToWar(), StartBattle(), TryRejoinAfterLogout(), BattlefieldWG::UpdatedDestroyedTowerCount(), and BattlefieldWG::UpdateTenacity().

PlayersWillBeKick

PlayerTimerMap Battlefield::PlayersWillBeKick[PVP_TEAMS_COUNT]

protected

Referenced by HandlePlayerEnterZone(), InvitePlayersInZoneToWar(), InvitePlayerToWar(), RemovePlayerFromTracking(), and StartBattle().

RestartAfterCrash

uint32 Battlefield::RestartAfterCrash

protected

Referenced by BattlefieldWG::SetupBattlefield().

StalkerGuid

ObjectGuid Battlefield::StalkerGuid

protected

Referenced by InitStalker(), and SendWarning().

StartGrouping

bool Battlefield::StartGrouping

protected

Referenced by EndBattle(), BattlefieldWG::SetupBattlefield(), and Update().

StartGroupingTimer

uint32 Battlefield::StartGroupingTimer

protected

Referenced by HandlePlayerEnterZone(), BattlefieldWG::SetupBattlefield(), and Update().

TimeForAcceptInvite

uint32 Battlefield::TimeForAcceptInvite

protected

Referenced by InvitePlayerToWar(), and BattlefieldWG::SetupBattlefield().

Timer

uint32 Battlefield::Timer

protected

Referenced by GetTimer().

TypeId

uint32 Battlefield::TypeId

protected

Referenced by GetTypeId(), and BattlefieldWG::SetupBattlefield().

ZoneId

uint32 Battlefield::ZoneId

protected

Referenced by GetZoneId(), InvitePlayerToWar(), PlayerAcceptInviteToQueue(), BattlefieldWG::SendInitWorldStatesTo(), and BattlefieldWG::SetupBattlefield().

---

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

• azerothcore-wotlk/src/server/game/Battlefield/Battlefield.h
• azerothcore-wotlk/src/server/game/Battlefield/Battlefield.cpp