Battlefield Class Reference

#include <Battlefield.h>

Public Types
typedef std::map< uint32, BfCapturePoint * >	BfCapturePointMap
	typedef of map witch store capturepoint and the associate gameobject entry More...

Public Member Functions
	Battlefield ()
	Constructor. More...
virtual	~Battlefield ()
	Destructor. More...
virtual bool	SetupBattlefield ()
	Call this to init the Battlefield. More...
void	SendUpdateWorldState (uint32 variable, uint32 value, bool hidden=false)
	Update data of a worldstate to all players present in zone. More...
virtual bool	Update (uint32 diff)
	Called every time for update bf data and time. More...
void	InvitePlayersInZoneToQueue ()
	Invite all players in zone to join the queue, called x minutes before battle start in Update() More...
void	InvitePlayersInQueueToWar ()
	Invite all players in queue to join battle on battle start. More...
void	InvitePlayersInZoneToWar ()
	Invite all players in zone to join battle on battle start. More...
virtual void	HandleKill (Player *, Unit *)
	Called when a Unit is kill in battlefield zone. More...
uint32	GetTypeId () const
uint32	GetZoneId () const
uint64	GetQueueId () const
void	TeamApplyBuff (TeamId team, uint32 spellId, uint32 spellId2=0)
bool	IsWarTime () const
	Return true if battle is start, false if battle is not started. More...
int8	GetState () const
void	ToggleBattlefield (bool enable)
	Enable or Disable battlefield. More...
bool	IsEnabled () const
	Return if battlefield is enable. More...
void	KickPlayerFromBattlefield (ObjectGuid guid)
	Kick player from battlefield and teleport him to kick-point location. More...
void	HandlePlayerEnterZone (Player *player, uint32 zone)
	Called when player (player) enter in zone. More...
void	HandlePlayerLeaveZone (Player *player, uint32 zone)
	Called when player (player) leave the zone. More...
virtual uint64	GetData64 (uint32 dataId) const override
virtual void	SetData64 (uint32 dataId, uint64 value) override
virtual uint32	GetData (uint32 dataId) const override
virtual 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. More...
Group *	GetGroupPlayer (ObjectGuid guid, TeamId TeamId)
	Return battlefield group where player is. More...
bool	AddOrSetPlayerToCorrectBfGroup (Player *player)
	Force player to join a battlefield group. More...
WorldSafeLocsEntry const *	GetClosestGraveYard (Player *player)
virtual void	AddPlayerToResurrectQueue (ObjectGuid npc_guid, ObjectGuid player_guid)
void	RemovePlayerFromResurrectQueue (ObjectGuid player_guid)
void	SetGraveyardNumber (uint32 number)
BfGraveyard *	GetGraveyardById (uint32 id) const
virtual Creature *	SpawnCreature (uint32 entry, float x, float y, float z, float o, TeamId)
Creature *	SpawnCreature (uint32 entry, Position const &pos, TeamId)
GameObject *	SpawnGameObject (uint32 entry, float x, float y, float z, float o)
Creature *	GetCreature (ObjectGuid guid)
GameObject *	GetGameObject (ObjectGuid guid)
virtual void	OnBattleStart ()
	Called on start. More...
virtual void	OnBattleEnd (bool)
	Called at the end of battle. More...
virtual void	OnStartGrouping ()
	Called x minutes before battle start when player in zone are invite to join queue. More...
virtual void	OnPlayerJoinWar (Player *)
	Called when a player accept to join the battle. More...
virtual void	OnPlayerLeaveWar (Player *)
	Called when a player leave the battle. More...
virtual void	OnPlayerLeaveZone (Player *)
	Called when a player leave battlefield zone. More...
virtual void	OnPlayerEnterZone (Player *)
	Called when a player enter in battlefield zone. More...
void	SendWarning (uint8 id, WorldObject const *target=nullptr)
void	PlayerAcceptInviteToQueue (Player *player)
void	PlayerAcceptInviteToWar (Player *player)
uint32	GetBattleId () const
void	AskToLeaveQueue (Player *player)
virtual void	DoCompleteOrIncrementAchievement (uint32, Player *, uint8)
virtual void	SendInitWorldStatesToAll ()=0
	Send all worldstate data to all player in zone. More...
virtual void	FillInitialWorldStates (WorldPackets::WorldState::InitWorldStates &)=0
bool	CanFlyIn ()
	Return if we can use mount in battlefield. More...
void	SendAreaSpiritHealerQueryOpcode (Player *player, ObjectGuid const &guid)
void	StartBattle ()
void	EndBattle (bool endByTimer)
void	HideNpc (Creature *creature)
void	ShowNpc (Creature *creature, bool aggressive)
GraveyardVect	GetGraveyardVector () const
uint32	GetTimer () const
void	SetTimer (uint32 timer)
void	DoPlaySoundToAll (uint32 SoundID)
void	InvitePlayerToQueue (Player *player)
void	InvitePlayerToWar (Player *player)
void	InitStalker (uint32 entry, Position const &pos)
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 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)
BfCapturePoint *	GetCapturePoint (uint32 entry) const
void	RegisterZone (uint32 zoneid)
bool	HasPlayer (Player *player) const
void	TeamCastSpell (TeamId team, int32 spellId)

Protected Attributes
ObjectGuid	StalkerGuid
uint32	m_Timer
bool	m_IsEnabled
bool	m_isActive
TeamId	m_DefenderTeam
BfCapturePointMap	m_capturePoints
GuidSet	m_players [BG_TEAMS_COUNT]
GuidSet	m_PlayersInQueue [BG_TEAMS_COUNT]
GuidSet	m_PlayersInWar [BG_TEAMS_COUNT]
PlayerTimerMap	m_InvitedPlayers [BG_TEAMS_COUNT]
PlayerTimerMap	m_PlayersWillBeKick [BG_TEAMS_COUNT]
uint32	m_TypeId
uint32	m_BattleId
uint32	m_ZoneId
uint32	m_MapId
Map *	m_Map
uint32	m_MaxPlayer
uint32	m_MinPlayer
uint32	m_MinLevel
uint32	m_BattleTime
uint32	m_NoWarBattleTime
uint32	m_RestartAfterCrash
uint32	m_TimeForAcceptInvite
uint32	m_uiKickDontAcceptTimer
WorldLocation	KickPosition
uint32	m_uiKickAfkPlayersTimer
GraveyardVect	m_GraveyardList
uint32	m_LastResurrectTimer
uint32	m_StartGroupingTimer
bool	m_StartGrouping
GuidSet	m_Groups [BG_TEAMS_COUNT]
std::vector< uint64 >	m_Data64
std::vector< uint32 >	m_Data32

Friends
class	BattlefieldMgr

Member Typedef Documentation

typedef std::map<uint32 , BfCapturePoint*> Battlefield::BfCapturePointMap

typedef of map witch store capturepoint and the associate gameobject entry

Constructor & Destructor Documentation

Battlefield::Battlefield

(

)

Constructor.

{
 m_Timer = 0;
 m_IsEnabled = true;
 m_isActive = false;
 m_DefenderTeam = TEAM_NEUTRAL;

 m_TypeId = 0;
 m_BattleId = 0;
 m_ZoneId = 0;
 m_Map = NULL;
 m_MapId = 0;
 m_MaxPlayer = 0;
 m_MinPlayer = 0;
 m_MinLevel = 0;
 m_BattleTime = 0;
 m_NoWarBattleTime = 0;
 m_RestartAfterCrash = 0;
 m_TimeForAcceptInvite = 20;
 m_uiKickDontAcceptTimer = 1000;

 m_uiKickAfkPlayersTimer = 1000;

 m_LastResurrectTimer = 30 * IN_MILLISECONDS;
 m_StartGroupingTimer = 0;
 m_StartGrouping = false;
}

Battlefield::~Battlefield ( )

virtual

Destructor.

{
 for (BfCapturePointMap::iterator itr = m_capturePoints.begin(); itr != m_capturePoints.end(); ++itr)
 delete itr->second;

 for (GraveyardVect::const_iterator itr = m_GraveyardList.begin(); itr != m_GraveyardList.end(); ++itr)
 delete *itr;
}

Member Function Documentation

void Battlefield::AddCapturePoint ( BfCapturePoint *  cp )

protected

{
 Battlefield::BfCapturePointMap::iterator i = m_capturePoints.find(cp->GetCapturePointEntry());
 if (i != m_capturePoints.end())
 {
 TC_LOG_ERROR("bg.battlefield", "Battlefield::AddCapturePoint: CapturePoint %u already exists!", cp->GetCapturePointEntry());
 delete i->second;
 }
 m_capturePoints[cp->GetCapturePointEntry()] = cp;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool Battlefield::AddOrSetPlayerToCorrectBfGroup

(

Player *

player

)

Force player to join a battlefield group.

{
 if (!player->IsInWorld())
 return false;

 if (Group* group = player->GetGroup())
 group->RemoveMember(player->GetGUID());

 Group* group = GetFreeBfRaid(player->GetTeamId());
 if (!group)
 {
 group = new Group;
 group->SetBattlefieldGroup(this);
 group->Create(player);
 sGroupMgr->AddGroup(group);
 m_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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

virtual

{
 for (uint8 i = 0; i < m_GraveyardList.size(); i++)
 {
 if (!m_GraveyardList[i])
 continue;

 if (m_GraveyardList[i]->HasNpc(npcGuid))
 {
 m_GraveyardList[i]->AddPlayer(playerGuid);
 break;
 }
 }
}

void Battlefield::AskToLeaveQueue

(

Player *

player

)

{
 // Remove player from queue
 m_PlayersInQueue[player->GetTeamId()].erase(player->GetGUID());
}

Here is the caller graph for this function:

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

protected

{
 for (uint8 team = 0; team < BG_TEAMS_COUNT; ++team)
 for (GuidSet::const_iterator itr = m_PlayersInQueue[team].begin(); itr != m_PlayersInQueue[team].end(); ++itr)
 if (Player* player = ObjectAccessor::FindConnectedPlayer(*itr))
 player->SendDirectMessage(data);
}

Here is the call graph for this function:

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

protected

{
 for (uint8 team = 0; team < BG_TEAMS_COUNT; ++team)
 for (GuidSet::const_iterator itr = m_PlayersInWar[team].begin(); itr != m_PlayersInWar[team].end(); ++itr)
 if (Player* player = ObjectAccessor::FindPlayer(*itr))
 player->SendDirectMessage(data);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

{
 for (uint8 team = 0; team < BG_TEAMS_COUNT; ++team)
 for (GuidSet::const_iterator itr = m_players[team].begin(); itr != m_players[team].end(); ++itr)
 if (Player* player = ObjectAccessor::FindPlayer(*itr))
 player->SendDirectMessage(data);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool Battlefield::CanFlyIn ( )

inline

Return if we can use mount in battlefield.

{ return !m_isActive; }

Here is the caller graph for this function:

virtual void Battlefield::DoCompleteOrIncrementAchievement ( uint32  , Player *  , uint8    )

inlinevirtual

Reimplemented in BattlefieldWG.

{ }

void Battlefield::DoPlaySoundToAll

(

uint32

SoundID

)

{
 BroadcastPacketToWar(WorldPackets::Misc::PlaySound(ObjectGuid::Empty, soundID).Write());
}

Here is the call graph for this function:

void Battlefield::EndBattle

(

bool

endByTimer

)

{
 if (!m_isActive)
 return;

 m_isActive = false;

 m_StartGrouping = false;

 if (!endByTimer)
 SetDefenderTeam(GetAttackerTeam());

 OnBattleEnd(endByTimer);

 // Reset battlefield timer
 m_Timer = m_NoWarBattleTime;
 SendInitWorldStatesToAll();
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

pure virtual

Implemented in BattlefieldWG.

TeamId Battlefield::GetAttackerTeam ( ) const

inline

{ return TeamId(1 - m_DefenderTeam); }

Here is the caller graph for this function:

uint32 Battlefield::GetBattleId ( ) const

inline

{ return m_BattleId; }

BfCapturePoint * Battlefield::GetCapturePoint ( uint32  entry ) const

protected

{
 Battlefield::BfCapturePointMap::const_iterator itr = m_capturePoints.find(entry);
 if (itr != m_capturePoints.end())
 return itr->second;
 return nullptr;
}

WorldSafeLocsEntry const * Battlefield::GetClosestGraveYard

(

Player *

player

)

{
 BfGraveyard* closestGY = NULL;
 float maxdist = -1;
 for (uint8 i = 0; i < m_GraveyardList.size(); i++)
 {
 if (m_GraveyardList[i])
 {
 if (m_GraveyardList[i]->GetControlTeamId() != player->GetTeamId())
 continue;

 float dist = m_GraveyardList[i]->GetDistance(player);
 if (dist < maxdist || maxdist < 0)
 {
 closestGY = m_GraveyardList[i];
 maxdist = dist;
 }
 }
 }

 if (closestGY)
 return sWorldSafeLocsStore.LookupEntry(closestGY->GetGraveyardId());

 return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Creature * Battlefield::GetCreature

(

ObjectGuid

guid

)

{
 if (!m_Map)
 return NULL;
 return m_Map->GetCreature(guid);
}

Here is the call graph for this function:

Here is the caller graph for this function:

virtual uint32 Battlefield::GetData ( uint32  dataId ) const

inlineoverridevirtual

Reimplemented from ZoneScript.

Reimplemented in BattlefieldWG.

{ return m_Data32[dataId]; }

Here is the caller graph for this function:

virtual uint64 Battlefield::GetData64 ( uint32  dataId ) const

inlineoverridevirtual

Reimplemented from ZoneScript.

{ return m_Data64[dataId]; }

TeamId Battlefield::GetDefenderTeam ( ) const

inline

{ return m_DefenderTeam; }

Here is the caller graph for this function:

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 (GuidSet::const_iterator itr = m_Groups[TeamId].begin(); itr != m_Groups[TeamId].end(); ++itr)
 if (Group* group = sGroupMgr->GetGroupByGUID(*itr))
 if (!group->IsFull())
 return group;

 return NULL;
}

Here is the caller graph for this function:

GameObject * Battlefield::GetGameObject

(

ObjectGuid

guid

)

{
 if (!m_Map)
 return NULL;
 return m_Map->GetGameObject(guid);
}

Here is the call graph for this function:

Here is the caller graph for this function:

BfGraveyard * Battlefield::GetGraveyardById

(

uint32

id

)

const

{
 if (id < m_GraveyardList.size())
 {
 if (BfGraveyard* graveyard = m_GraveyardList.at(id))
 return graveyard;
 else
 TC_LOG_ERROR("bg.battlefield", "Battlefield::GetGraveyardById Id:%u not existed", id);
 }
 else
 TC_LOG_ERROR("bg.battlefield", "Battlefield::GetGraveyardById Id:%u cant be found", id);

 return NULL;
}

Here is the caller graph for this function:

GraveyardVect Battlefield::GetGraveyardVector ( ) const

inline

{ return m_GraveyardList; }

Here is the caller graph for this function:

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

Return battlefield group where player is.

{
 for (GuidSet::const_iterator itr = m_Groups[TeamId].begin(); itr != m_Groups[TeamId].end(); ++itr)
 if (Group* group = sGroupMgr->GetGroupByGUID(*itr))
 if (group->IsMember(guid))
 return group;

 return NULL;
}

TeamId Battlefield::GetOtherTeam ( TeamId  team ) const

inline

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

Here is the caller graph for this function:

uint64 Battlefield::GetQueueId ( ) const

inline

{ return MAKE_PAIR64(m_BattleId | 0x20000, 0x1F100000); }

Here is the call graph for this function:

Here is the caller graph for this function:

int8 Battlefield::GetState ( ) const

inline

{ return m_isActive ? BATTLEFIELD_IN_PROGRESS : (m_Timer <= m_StartGroupingTimer ? BATTLEFIELD_WARMUP : BATTLEFIELD_INACTIVE); }

Here is the caller graph for this function:

uint32 Battlefield::GetTimer ( ) const

inline

{ return m_Timer; }

Here is the caller graph for this function:

uint32 Battlefield::GetTypeId ( ) const

inline

{ return m_TypeId; }

Here is the caller graph for this function:

uint32 Battlefield::GetZoneId ( ) const

inline

{ return m_ZoneId; }

Here is the caller graph for this function:

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

inlinevirtual

Called when a Unit is kill in battlefield zone.

Reimplemented in BattlefieldWG.

{ };

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

Called when player (player) enter in zone.

Todo:

Send a packet to announce it to player

{
 // 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 desn't leave
 if (IsWarTime())
 {
 if (m_PlayersInWar[player->GetTeamId()].size() + m_InvitedPlayers[player->GetTeamId()].size() < m_MaxPlayer) // Vacant spaces
 InvitePlayerToWar(player);
 else // No more vacant places
 {
 m_PlayersWillBeKick[player->GetTeamId()][player->GetGUID()] = time(NULL) + 10;
 InvitePlayerToQueue(player);
 }
 }
 else
 {
 // If time left is < 15 minutes invite player to join queue
 if (m_Timer <= m_StartGroupingTimer)
 InvitePlayerToQueue(player);
 }

 // Add player in the list of player in zone
 m_players[player->GetTeamId()].insert(player->GetGUID());
 OnPlayerEnterZone(player);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Called when player (player) leave the zone.

{
 if (IsWarTime())
 {
 // If the player is participating to the battle
 if (m_PlayersInWar[player->GetTeamId()].find(player->GetGUID()) != m_PlayersInWar[player->GetTeamId()].end())
 {
 m_PlayersInWar[player->GetTeamId()].erase(player->GetGUID());
 player->GetSession()->SendBfLeaveMessage(GetQueueId(), GetState(), player->GetZoneId() == GetZoneId());
 if (Group* group = player->GetGroup()) // Remove the player from the raid group
 group->RemoveMember(player->GetGUID());

 OnPlayerLeaveWar(player);
 }
 }

 for (BfCapturePointMap::iterator itr = m_capturePoints.begin(); itr != m_capturePoints.end(); ++itr)
 itr->second->HandlePlayerLeave(player);

 m_InvitedPlayers[player->GetTeamId()].erase(player->GetGUID());
 m_PlayersWillBeKick[player->GetTeamId()].erase(player->GetGUID());
 m_players[player->GetTeamId()].erase(player->GetGUID());
 SendRemoveWorldStates(player);
 RemovePlayerFromResurrectQueue(player->GetGUID());
 OnPlayerLeaveZone(player);
}

Here is the call graph for this function:

bool Battlefield::HasPlayer ( Player *  player ) const

protected

{
 return m_players[player->GetTeamId()].find(player->GetGUID()) != m_players[player->GetTeamId()].end();
}

Here is the caller graph for this function:

void Battlefield::HideNpc

(

Creature *

creature

)

{
 creature->CombatStop();
 creature->SetReactState(REACT_PASSIVE);
 creature->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE);
 creature->DisappearAndDie();
 creature->SetVisible(false);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Battlefield::InitStalker	(	uint32	entry,
		Position const &	pos
	)

{
 if (Creature* creature = SpawnCreature(entry, pos, TEAM_NEUTRAL))
 StalkerGuid = creature->GetGUID();
 else
 TC_LOG_ERROR("bg.battlefield", "Battlefield::InitStalker: could not spawn Stalker (Creature entry %u), zone messeges will be un-available", entry);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Battlefield::InvitePlayersInQueueToWar

(

)

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

{
 for (uint8 team = 0; team < BG_TEAMS_COUNT; ++team)
 {
 for (GuidSet::const_iterator itr = m_PlayersInQueue[team].begin(); itr != m_PlayersInQueue[team].end(); ++itr)
 {
 if (Player* player = ObjectAccessor::FindPlayer(*itr))
 {
 if (m_PlayersInWar[player->GetTeamId()].size() + m_InvitedPlayers[player->GetTeamId()].size() < m_MaxPlayer)
 InvitePlayerToWar(player);
 else
 {
 //Full
 }
 }
 }
 m_PlayersInQueue[team].clear();
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Battlefield::InvitePlayersInZoneToQueue

(

)

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

{
 for (uint8 team = 0; team < 2; ++team)
 for (GuidSet::const_iterator itr = m_players[team].begin(); itr != m_players[team].end(); ++itr)
 if (Player* player = ObjectAccessor::FindPlayer(*itr))
 InvitePlayerToQueue(player);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Battlefield::InvitePlayersInZoneToWar

(

)

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

{
 for (uint8 team = 0; team < BG_TEAMS_COUNT; ++team)
 for (GuidSet::const_iterator itr = m_players[team].begin(); itr != m_players[team].end(); ++itr)
 {
 if (Player* player = ObjectAccessor::FindPlayer(*itr))
 {
 if (m_PlayersInWar[player->GetTeamId()].count(player->GetGUID()) || m_InvitedPlayers[player->GetTeamId()].count(player->GetGUID()))
 continue;
 if (m_PlayersInWar[player->GetTeamId()].size() + m_InvitedPlayers[player->GetTeamId()].size() < m_MaxPlayer)
                    InvitePlayerToWar(player);
                else // Battlefield is full of players
                    m_PlayersWillBeKick[player->GetTeamId()][player->GetGUID()] = time(NULL) + 10;
            }
        }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Battlefield::InvitePlayerToQueue

(

Player *

player

)

{
    if (m_PlayersInQueue[player->GetTeamId()].count(player->GetGUID()))
        return;

    if (m_PlayersInQueue[player->GetTeamId()].size() <= m_MinPlayer || m_PlayersInQueue[GetOtherTeam(player->GetTeamId())].size() >= m_MinPlayer)
        player->GetSession()->SendBfInvitePlayerToQueue(GetQueueId(), GetState());
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Battlefield::InvitePlayerToWar

(

Player *

player

)

Todo:

needed ?

{
    if (!player)
        return;

    if (player->IsInFlight())
        return;

    if (player->InArena() || player->GetBattleground())
    {
        m_PlayersInQueue[player->GetTeamId()].erase(player->GetGUID());
        return;
    }

    // If the player does not match minimal level requirements for the battlefield, kick him
    if (player->getLevel() < m_MinLevel)
    {
        if (m_PlayersWillBeKick[player->GetTeamId()].count(player->GetGUID()) == 0)
            m_PlayersWillBeKick[player->GetTeamId()][player->GetGUID()] = time(NULL) + 10;
        return;
    }

    // Check if player is not already in war
    if (m_PlayersInWar[player->GetTeamId()].count(player->GetGUID()) || m_InvitedPlayers[player->GetTeamId()].count(player->GetGUID()))
        return;

    m_PlayersWillBeKick[player->GetTeamId()].erase(player->GetGUID());
    m_InvitedPlayers[player->GetTeamId()][player->GetGUID()] = time(NULL) + m_TimeForAcceptInvite;
    player->GetSession()->SendBfInvitePlayerToWar(GetQueueId(), m_ZoneId, m_TimeForAcceptInvite);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool Battlefield::IsEnabled ( ) const

inline

Return if battlefield is enable.

{ return m_IsEnabled; }

Here is the caller graph for this function:

bool Battlefield::IsWarTime ( ) const

inline

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

{ return m_isActive; }

Here is the caller graph for this function:

void Battlefield::KickAfkPlayers ( )

protected

{
    for (uint8 team = 0; team < BG_TEAMS_COUNT; ++team)
        for (GuidSet::const_iterator itr = m_PlayersInWar[team].begin(); itr != m_PlayersInWar[team].end(); ++itr)
            if (Player* player = ObjectAccessor::FindPlayer(*itr))
                if (player->isAFK())
                    KickPlayerFromBattlefield(*itr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Battlefield::KickPlayerFromBattlefield

(

ObjectGuid

guid

)

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

Parameters

guid	: guid of player who must be kick

{
    if (Player* player = ObjectAccessor::FindPlayer(guid))
        if (player->GetZoneId() == GetZoneId())
            player->TeleportTo(KickPosition);
}

Here is the call graph for this function:

Here is the caller graph for this function:

virtual void Battlefield::OnBattleEnd ( bool  )

inlinevirtual

Called at the end of battle.

Reimplemented in BattlefieldWG.

{ }

Here is the caller graph for this function:

virtual void Battlefield::OnBattleStart ( )

inlinevirtual

Called on start.

Reimplemented in BattlefieldWG.

{ }

Here is the caller graph for this function:

virtual void Battlefield::OnPlayerEnterZone ( Player *  )

inlinevirtual

Called when a player enter in battlefield zone.

Reimplemented in BattlefieldWG.

{ }

Here is the caller graph for this function:

virtual void Battlefield::OnPlayerJoinWar ( Player *  )

inlinevirtual

Called when a player accept to join the battle.

Reimplemented in BattlefieldWG.

{ }

Here is the caller graph for this function:

virtual void Battlefield::OnPlayerLeaveWar ( Player *  )

inlinevirtual

Called when a player leave the battle.

Reimplemented in BattlefieldWG.

{ }

Here is the caller graph for this function:

virtual void Battlefield::OnPlayerLeaveZone ( Player *  )

inlinevirtual

Called when a player leave battlefield zone.

Reimplemented in BattlefieldWG.

{ }

Here is the caller graph for this function:

virtual void Battlefield::OnStartGrouping ( )

inlinevirtual

Called x minutes before battle start when player in zone are invite to join queue.

Reimplemented in BattlefieldWG.

{ }

Here is the caller graph for this function:

void Battlefield::PlayerAcceptInviteToQueue

(

Player *

player

)

{
    // Add player in queue
    m_PlayersInQueue[player->GetTeamId()].insert(player->GetGUID());
    // Send notification
    player->GetSession()->SendBfQueueInviteResponse(GetQueueId(), m_ZoneId, GetState());
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Battlefield::PlayerAcceptInviteToWar

(

Player *

player

)

{
    if (!IsWarTime())
        return;

    if (AddOrSetPlayerToCorrectBfGroup(player))
    {
        player->GetSession()->SendBfEntered(GetQueueId(), player->GetZoneId() != GetZoneId(), player->GetTeamId() == GetAttackerTeam());
        m_PlayersInWar[player->GetTeamId()].insert(player->GetGUID());
        m_InvitedPlayers[player->GetTeamId()].erase(player->GetGUID());

        if (player->isAFK())
            player->ToggleAFK();

        OnPlayerJoinWar(player);                               //for scripting
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Battlefield::RegisterZone ( uint32  zoneid )

protected

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

Here is the caller graph for this function:

void Battlefield::RemovePlayerFromResurrectQueue

(

ObjectGuid

player_guid

)

{
    for (uint8 i = 0; i < m_GraveyardList.size(); i++)
    {
        if (!m_GraveyardList[i])
            continue;

        if (m_GraveyardList[i]->HasPlayer(playerGuid))
        {
            m_GraveyardList[i]->RemovePlayer(playerGuid);
            break;
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

{
    WorldPackets::Battleground::AreaSpiritHealerTime areaSpiritHealerTime;
    areaSpiritHealerTime.HealerGuid = guid;
    areaSpiritHealerTime.TimeLeft = m_LastResurrectTimer;
    player->SendDirectMessage(areaSpiritHealerTime.Write());
}

Here is the call graph for this function:

virtual void Battlefield::SendInitWorldStatesToAll ( )

pure virtual

Send all worldstate data to all player in zone.

Implemented in BattlefieldWG.

Here is the caller graph for this function:

virtual void Battlefield::SendRemoveWorldStates ( Player *  )

inlineprotectedvirtual

{ }

Here is the caller graph for this function:

void Battlefield::SendUpdateWorldState	(	uint32	variable,
		uint32	value,
		bool	hidden = false
	)

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

inlineoverridevirtual

Reimplemented from ZoneScript.

{ m_Data32[dataId] = value; }

Here is the caller graph for this function:

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

inlineoverridevirtual

Reimplemented from ZoneScript.

{ m_Data64[dataId] = value; }

void Battlefield::SetDefenderTeam ( TeamId  team )

inline

{ m_DefenderTeam = team; }

Here is the caller graph for this function:

void Battlefield::SetGraveyardNumber ( uint32  number )

inline

{ m_GraveyardList.resize(number); }

Here is the caller graph for this function:

void Battlefield::SetTimer ( uint32  timer )

inline

{ m_Timer = timer; }

Here is the caller graph for this function:

virtual bool Battlefield::SetupBattlefield ( )

inlinevirtual

Call this to init the Battlefield.

Reimplemented in BattlefieldWG.

{ return true; }

Here is the caller graph for this function:

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

{
    creature->SetVisible(true);
    creature->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE);
    if (!creature->IsAlive())
        creature->Respawn(true);
    if (aggressive)
        creature->SetReactState(REACT_AGGRESSIVE);
    else
    {
        creature->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
        creature->SetReactState(REACT_PASSIVE);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

virtual

{
    //Get map object
    Map* map = sMapMgr->CreateBaseMap(m_MapId);
    if (!map)
    {
        TC_LOG_ERROR("bg.battlefield", "Battlefield::SpawnCreature: Can't create creature entry: %u map not found", entry);
        return nullptr;
    }

    CreatureTemplate const* cinfo = sObjectMgr->GetCreatureTemplate(entry);
    if (!cinfo)
    {
        TC_LOG_ERROR("bg.battlefield", "Battlefield::SpawnCreature: entry %u does not exist.", entry);
        return nullptr;
    }

    Creature* creature = new Creature();
    if (!creature->Create(map->GenerateLowGuid<HighGuid::Creature>(), map, PHASEMASK_NORMAL, entry, x, y, z, o))
    {
        TC_LOG_ERROR("bg.battlefield", "Battlefield::SpawnCreature: Can't create creature entry: %u", entry);
        delete creature;
        return nullptr;
    }

    creature->SetHomePosition(x, y, z, o);

    // Set creature in world
    map->AddToMap(creature);
    creature->setActive(true);

    return creature;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

{
    return SpawnCreature(entry, pos.GetPositionX(), pos.GetPositionY(), pos.GetPositionZ(), pos.GetOrientation(), teamId);
}

Here is the call graph for this function:

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

{
    // Get map object
    Map* map = sMapMgr->CreateBaseMap(m_MapId);
    if (!map)
    {
        TC_LOG_ERROR("bg.battlefield", "Battlefield::SpawnGameObject: Can't create GameObject (Entry: %u). Map not found.", entry);
        return nullptr;
    }

    GameObjectTemplate const* goInfo = sObjectMgr->GetGameObjectTemplate(entry);
    if (!goInfo)
    {
        TC_LOG_ERROR("bg.battlefield", "Battlefield::SpawnGameObject: GameObject template %u not found in database! Battlefield not created!", entry);
        return nullptr;
    }

    // Create gameobject
    GameObject* go = new GameObject;
    if (!go->Create(map->GenerateLowGuid<HighGuid::GameObject>(), entry, map, PHASEMASK_NORMAL, x, y, z, o, 0, 0, 0, 0, 100, GO_STATE_READY))
    {
        TC_LOG_ERROR("bg.battlefield", "Battlefield::SpawnGameObject: Cannot create gameobject template %u! Battlefield not created!", entry);
        delete go;
        return nullptr;
    }

    // Add to world
    map->AddToMap(go);
    go->setActive(true);

    return go;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Battlefield::StartBattle

(

)

{
    if (m_isActive)
        return;

    for (int team = 0; team < BG_TEAMS_COUNT; team++)
    {
        m_PlayersInWar[team].clear();
        m_Groups[team].clear();
    }

    m_Timer = m_BattleTime;
    m_isActive = true;

    InvitePlayersInZoneToWar();
    InvitePlayersInQueueToWar();

    OnBattleStart();
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

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

protected

{
    if (spellId > 0)
    {
        for (GuidSet::const_iterator itr = m_PlayersInWar[team].begin(); itr != m_PlayersInWar[team].end(); ++itr)
            if (Player* player = ObjectAccessor::FindPlayer(*itr))
                player->CastSpell(player, uint32(spellId), true);
    }
    else
    {
        for (GuidSet::const_iterator itr = m_PlayersInWar[team].begin(); itr != m_PlayersInWar[team].end(); ++itr)
            if (Player* player = ObjectAccessor::FindPlayer(*itr))
                player->RemoveAuraFromStack(uint32(-spellId));
    }
}

Here is the call graph for this function:

void Battlefield::ToggleBattlefield ( bool  enable )

inline

Enable or Disable battlefield.

{ m_IsEnabled = enable; }

Here is the caller graph for this function:

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 m_StartGroupingTimer minutes before start
• Kick Afk players

  Parameters

  diff	: time ellapsed since last call (in ms)

Reimplemented in BattlefieldWG.

{
    if (m_Timer <= diff)
    {
        // Battlefield ends on time
        if (IsWarTime())
            EndBattle(true);
        else // Time to start a new battle!
            StartBattle();
    }
    else
        m_Timer -= diff;

    // Invite players a few minutes before the battle's beginning
    if (!IsWarTime() && !m_StartGrouping && m_Timer <= m_StartGroupingTimer)
    {
        m_StartGrouping = true;
        InvitePlayersInZoneToQueue();
        OnStartGrouping();
    }

    bool objective_changed = false;
    if (IsWarTime())
    {
        if (m_uiKickAfkPlayersTimer <= diff)
        {
            m_uiKickAfkPlayersTimer = 1000;
            KickAfkPlayers();
        }
        else
            m_uiKickAfkPlayersTimer -= diff;

        // Kick players who chose not to accept invitation to the battle
        if (m_uiKickDontAcceptTimer <= diff)
        {
            time_t now = time(NULL);
            for (int team = 0; team < 2; team++)
                for (PlayerTimerMap::iterator itr = m_InvitedPlayers[team].begin(); itr != m_InvitedPlayers[team].end(); ++itr)
                    if (itr->second <= now)
                        KickPlayerFromBattlefield(itr->first);

            InvitePlayersInZoneToWar();
            for (int team = 0; team < 2; team++)
                for (PlayerTimerMap::iterator itr = m_PlayersWillBeKick[team].begin(); itr != m_PlayersWillBeKick[team].end(); ++itr)
                    if (itr->second <= now)
                        KickPlayerFromBattlefield(itr->first);

            m_uiKickDontAcceptTimer = 1000;
        }
        else
            m_uiKickDontAcceptTimer -= diff;

        for (BfCapturePointMap::iterator itr = m_capturePoints.begin(); itr != m_capturePoints.end(); ++itr)
            if (itr->second->Update(diff))
                objective_changed = true;
    }


    if (m_LastResurrectTimer <= diff)
    {
        for (uint8 i = 0; i < m_GraveyardList.size(); i++)
            if (GetGraveyardById(i))
                m_GraveyardList[i]->Resurrect();
        m_LastResurrectTimer = RESURRECTION_INTERVAL;
    }
    else
        m_LastResurrectTimer -= diff;

    return objective_changed;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

inlinevirtual

{ m_Data32[index] += pad; }

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Function Documentation

friend class BattlefieldMgr

friend

Member Data Documentation

WorldLocation Battlefield::KickPosition

protected

uint32 Battlefield::m_BattleId

protected

uint32 Battlefield::m_BattleTime

protected

BfCapturePointMap Battlefield::m_capturePoints

protected

std::vector<uint32> Battlefield::m_Data32

protected

std::vector<uint64> Battlefield::m_Data64

protected

TeamId Battlefield::m_DefenderTeam

protected

GraveyardVect Battlefield::m_GraveyardList

protected

GuidSet Battlefield::m_Groups[BG_TEAMS_COUNT]

protected

PlayerTimerMap Battlefield::m_InvitedPlayers[BG_TEAMS_COUNT]

protected

bool Battlefield::m_isActive

protected

bool Battlefield::m_IsEnabled

protected

uint32 Battlefield::m_LastResurrectTimer

protected

Map* Battlefield::m_Map

protected

uint32 Battlefield::m_MapId

protected

uint32 Battlefield::m_MaxPlayer

protected

uint32 Battlefield::m_MinLevel

protected

uint32 Battlefield::m_MinPlayer

protected

uint32 Battlefield::m_NoWarBattleTime

protected

GuidSet Battlefield::m_players[BG_TEAMS_COUNT]

protected

GuidSet Battlefield::m_PlayersInQueue[BG_TEAMS_COUNT]

protected

GuidSet Battlefield::m_PlayersInWar[BG_TEAMS_COUNT]

protected

PlayerTimerMap Battlefield::m_PlayersWillBeKick[BG_TEAMS_COUNT]

protected

uint32 Battlefield::m_RestartAfterCrash

protected

bool Battlefield::m_StartGrouping

protected

uint32 Battlefield::m_StartGroupingTimer

protected

uint32 Battlefield::m_TimeForAcceptInvite

protected

uint32 Battlefield::m_Timer

protected

uint32 Battlefield::m_TypeId

protected

uint32 Battlefield::m_uiKickAfkPlayersTimer

protected

uint32 Battlefield::m_uiKickDontAcceptTimer

protected

uint32 Battlefield::m_ZoneId

protected

ObjectGuid Battlefield::StalkerGuid

protected

---

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

• src/server/game/Battlefield/Battlefield.h
• src/server/game/Battlefield/Battlefield.cpp