Battlefield Class Reference

#include "Battlefield.h"

Inheritance diagram for Battlefield:

Public Types
typedef std::vector< BfCapturePoint * >	BfCapturePointVector
	typedef of map witch store capturepoint and the associate gameobject entry

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 kill in battlefield zone.
uint32	GetTypeId ()
uint32	GetZoneId ()
void	TeamApplyBuff (TeamId team, uint32 spellId, uint32 spellId2=0)
bool	IsWarTime ()
	Return true if battle is start, false if battle is not started.
void	ToggleBattlefield (bool enable)
	Enable or Disable battlefield.
bool	IsEnabled ()
	Return if battlefield is enable.
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) enter in zone.
void	HandlePlayerLeaveZone (Player *player, uint32 zone)
	Called when player (player) leave 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 ()
TeamId	GetAttackerTeam ()
TeamId	GetOtherTeam (TeamId team)
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.
GraveyardStruct 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
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 player in zone are invite to join queue.
virtual void	OnPlayerJoinWar (Player *)
	Called when a player accept to join the battle.
virtual void	OnPlayerLeaveWar (Player *)
	Called when a player leave the battle.
virtual void	OnPlayerLeaveZone (Player *)
	Called when a player leave battlefield zone.
virtual void	OnPlayerEnterZone (Player *)
	Called when a player enter in battlefield zone.
void	SendWarning (uint8 id, WorldObject const *target=nullptr)
void	PlayerAcceptInviteToQueue (Player *player)
void	PlayerAcceptInviteToWar (Player *player)
uint32	GetBattleId ()
void	AskToLeaveQueue (Player *player)
void	PlayerAskToLeave (Player *player)
virtual void	SendInitWorldStatesToAll ()=0
	Send all worldstate data to all player in zone.
virtual void	FillInitialWorldStates (WorldPackets::WorldState::InitWorldStates &)=0
virtual void	SendUpdateWorldStates (Player *player=nullptr)=0
bool	CanFlyIn ()
	Return if we can use mount in battlefield.
void	SendAreaSpiritHealerQueryOpcode (Player *player, const ObjectGuid &guid)
void	StartBattle ()
void	EndBattle (bool endByTimer)
void	HideNpc (Creature *creature)
void	ShowNpc (Creature *creature, bool aggressive)
GraveyardVect	GetGraveyardVector ()
uint32	GetTimer ()
void	SetTimer (uint32 timer)
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)

Protected Attributes
ObjectGuid	StalkerGuid
uint32	m_Timer
bool	m_IsEnabled
bool	m_isActive
TeamId	m_DefenderTeam
BfCapturePointVector	m_capturePoints
GuidUnorderedSet	m_players [PVP_TEAMS_COUNT]
GuidUnorderedSet	m_PlayersInQueue [PVP_TEAMS_COUNT]
GuidUnorderedSet	m_PlayersInWar [PVP_TEAMS_COUNT]
PlayerTimerMap	m_InvitedPlayers [PVP_TEAMS_COUNT]
PlayerTimerMap	m_PlayersWillBeKick [PVP_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_LastResurectTimer
uint32	m_StartGroupingTimer
bool	m_StartGrouping
GuidUnorderedSet	m_Groups [PVP_TEAMS_COUNT]
std::vector< uint64 >	m_Data64
std::vector< uint32 >	m_Data32

Friends
class	BattlefieldMgr

Detailed Description

Member Typedef Documentation

BfCapturePointVector

typedef std::vector<BfCapturePoint*> Battlefield::BfCapturePointVector

typedef of map witch store capturepoint and the associate gameobject entry

Constructor & Destructor Documentation

Battlefield()

Battlefield::Battlefield

(

)

Constructor.

Todo:

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

{
    m_Timer = 0;
    m_IsEnabled = true;
    m_isActive = false;
    m_DefenderTeam = TEAM_NEUTRAL;
 
    m_TypeId = 0;
    m_BattleId = 0;
    m_ZoneId = 0;
    m_Map = nullptr;
    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_LastResurectTimer = RESURRECTION_INTERVAL;
    m_StartGroupingTimer = 0;
    m_StartGrouping = false;
}

References m_BattleId, m_BattleTime, m_DefenderTeam, m_isActive, m_IsEnabled, m_LastResurectTimer, m_Map, m_MapId, m_MaxPlayer, m_MinLevel, m_MinPlayer, m_NoWarBattleTime, m_RestartAfterCrash, m_StartGrouping, m_StartGroupingTimer, m_TimeForAcceptInvite, m_Timer, m_TypeId, m_uiKickAfkPlayersTimer, m_uiKickDontAcceptTimer, m_ZoneId, RESURRECTION_INTERVAL, and TEAM_NEUTRAL.

~Battlefield()

Battlefield::~Battlefield ( )

override

Destructor.

{
    for (BfCapturePointVector::iterator itr = m_capturePoints.begin(); itr != m_capturePoints.end(); ++itr)
        delete *itr;
 
    for (GraveyardVect::const_iterator itr = m_GraveyardList.begin(); itr != m_GraveyardList.end(); ++itr)
        delete *itr;
 
    m_capturePoints.clear();
}

References m_capturePoints, and m_GraveyardList.

Member Function Documentation

AddCapturePoint()

void Battlefield::AddCapturePoint ( BfCapturePoint *  cp )

inlineprotected

{ m_capturePoints.push_back(cp); }

References m_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);
        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;
}

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, m_Groups, Group::SetBattlefieldGroup(), Player::SetBattlegroundOrBattlefieldRaid(), and sGroupMgr.

Referenced by PlayerAcceptInviteToWar().

AddPlayerToResurrectQueue()

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;
        }
    }
}

References BfGraveyard::AddPlayer(), and m_GraveyardList.

AskToLeaveQueue()

void Battlefield::AskToLeaveQueue

(

Player *

player

)

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

References BF_LEAVE_REASON_CLOSE, Object::GetGUID(), Player::GetSession(), Player::GetTeamId(), m_BattleId, m_PlayersInQueue, and WorldSession::SendBfLeaveMessage().

Referenced by WorldSession::HandleBfExitRequest().

BroadcastPacketToQueue()

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

protected

{
    for (uint8 team = 0; team < PVP_TEAMS_COUNT; ++team)
        for (GuidUnorderedSet::const_iterator itr = m_PlayersInQueue[team].begin(); itr != m_PlayersInQueue[team].end(); ++itr)
            if (Player* player = ObjectAccessor::FindPlayer(*itr))
                player->GetSession()->SendPacket(data);
}

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

BroadcastPacketToWar()

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

protected

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

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

Referenced by DoPlaySoundToAll().

BroadcastPacketToZone()

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

protected

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

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

CanFlyIn()

bool Battlefield::CanFlyIn ( )

inline

Return if we can use mount in battlefield.

{ return !m_isActive; }

References m_isActive.

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 (!m_isActive)
        return;
 
    m_isActive = false;
 
    m_StartGrouping = false;
 
    if (!endByTimer)
        SetDefenderTeam(GetAttackerTeam());
 
    if (GetDefenderTeam() == TEAM_ALLIANCE)
        DoPlaySoundToAll(BF_ALLIANCE_WINS);
    else
        DoPlaySoundToAll(BF_HORDE_WINS);
 
    OnBattleEnd(endByTimer);
 
    // Reset battlefield timer
    m_Timer = m_NoWarBattleTime;
    SendInitWorldStatesToAll();
    SendUpdateWorldStates();
}

References BF_ALLIANCE_WINS, BF_HORDE_WINS, DoPlaySoundToAll(), GetAttackerTeam(), GetDefenderTeam(), m_isActive, m_NoWarBattleTime, m_StartGrouping, m_Timer, OnBattleEnd(), SendInitWorldStatesToAll(), SendUpdateWorldStates(), SetDefenderTeam(), 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().

GetAttackerTeam()

TeamId Battlefield::GetAttackerTeam ( )

inline

{ return TeamId(1 - m_DefenderTeam); }

References m_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 ( )

inline

{ return m_BattleId; }

References m_BattleId.

GetClosestGraveyard()

GraveyardStruct const * Battlefield::GetClosestGraveyard

(

Player *

player

)

{
    BfGraveyard* closestGY = nullptr;
    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 sGraveyard->GetGraveyard(closestGY->GetGraveyardId());
 
    return nullptr;
}

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

Referenced by BfGraveyard::RelocateDeadPlayers().

GetCreature()

Creature * Battlefield::GetCreature

(

ObjectGuid const

guid

)

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

References Map::GetCreature(), and m_Map.

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 m_Data32[dataId]; }

References m_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 m_Data64[dataId]; }

References m_Data64.

GetDefenderTeam()

TeamId Battlefield::GetDefenderTeam ( )

inline

{ return m_DefenderTeam; }

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

References m_Groups, and sGroupMgr.

Referenced by AddOrSetPlayerToCorrectBfGroup().

GetGameObject()

GameObject * Battlefield::GetGameObject

(

ObjectGuid const

guid

)

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

References Map::GetGameObject(), and m_Map.

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

GetGraveyardById()

BfGraveyard * Battlefield::GetGraveyardById

(

uint32

id

)

const

{
    if (id < m_GraveyardList.size())
    {
        if (m_GraveyardList[id])
            return m_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 LOG_ERROR, and m_GraveyardList.

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

GetGraveyardVector()

GraveyardVect Battlefield::GetGraveyardVector ( )

inline

{ return m_GraveyardList; }

References m_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 (GuidUnorderedSet::const_iterator itr = m_Groups[TeamId].begin(); itr != m_Groups[TeamId].end(); ++itr)
        if (Group* group = sGroupMgr->GetGroupByGUID(itr->GetCounter()))
            if (group->IsMember(guid))
                return group;
 
    return nullptr;
}

References m_Groups, and sGroupMgr.

GetOtherTeam()

TeamId Battlefield::GetOtherTeam ( TeamId  team )

inline

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

References TEAM_ALLIANCE, and TEAM_HORDE.

Referenced by InvitePlayerToQueue().

GetTimer()

uint32 Battlefield::GetTimer ( )

inline

{ return m_Timer; }

References m_Timer.

Referenced by BattlefieldWG::FillInitialWorldStates(), 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 ( )

inline

{ return m_TypeId; }

References m_TypeId.

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

GetZoneId()

uint32 Battlefield::GetZoneId ( )

inline

{ return m_ZoneId; }

References m_ZoneId.

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

HandleKill()

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

inlinevirtual

Called when a Unit is kill in battlefield zone.

Reimplemented in BattlefieldWG.

{};

HandlePlayerEnterZone()

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

Called when player (player) enter in zone.

Todo:

: Send a packet to announce it to player

{
    // Xinef: do not invite players on taxi
    if (!player->IsInFlight())
    {
        // 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()] = GameTime::GetGameTime().count() + (player->IsGameMaster() ? 30 * MINUTE : 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);
}

References GameTime::GetGameTime(), Object::GetGUID(), Player::GetTeamId(), InvitePlayerToQueue(), InvitePlayerToWar(), Player::IsGameMaster(), Unit::IsInFlight(), IsWarTime(), m_InvitedPlayers, m_MaxPlayer, m_players, m_PlayersInWar, m_PlayersWillBeKick, m_StartGroupingTimer, m_Timer, MINUTE, and OnPlayerEnterZone().

Referenced by BattlefieldMgr::HandlePlayerEnterZone().

HandlePlayerLeaveZone()

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(m_BattleId);
            if (Group* group = player->GetGroup()) // Remove the player from the raid group
                if (group->isBFGroup())
                    group->RemoveMember(player->GetGUID());
 
            OnPlayerLeaveWar(player);
        }
    }
 
    for (BfCapturePointVector::iterator itr = m_capturePoints.begin(); itr != m_capturePoints.end(); ++itr)
        (*itr)->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);
}

References Player::GetGroup(), Object::GetGUID(), Player::GetSession(), Player::GetTeamId(), IsWarTime(), m_BattleId, m_capturePoints, m_InvitedPlayers, m_players, m_PlayersInWar, m_PlayersWillBeKick, OnPlayerLeaveWar(), OnPlayerLeaveZone(), RemovePlayerFromResurrectQueue(), WorldSession::SendBfLeaveMessage(), and SendRemoveWorldStates().

HasPlayer()

bool Battlefield::HasPlayer ( Player *  player ) const

protected

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

References Object::GetGUID(), Player::GetTeamId(), and m_players.

Referenced by RemovePlayerFromResurrectQueue().

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 messeges will be un-available", 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(m_PlayersInQueue[team]);
        for (GuidUnorderedSet::const_iterator itr = copy.begin(); itr != copy.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();
    }
}

References ObjectAccessor::FindPlayer(), InvitePlayerToWar(), m_InvitedPlayers, m_MaxPlayer, m_PlayersInQueue, m_PlayersInWar, 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()

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

References ObjectAccessor::FindPlayer(), InvitePlayerToQueue(), and m_players.

Referenced by Update().

InvitePlayersInZoneToWar()

void Battlefield::InvitePlayersInZoneToWar

(

)

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

{
    for (uint8 team = 0; team < PVP_TEAMS_COUNT; ++team)
        for (GuidUnorderedSet::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 if (m_PlayersWillBeKick[player->GetTeamId()].count(player->GetGUID()) == 0)// Battlefield is full of players
                    m_PlayersWillBeKick[player->GetTeamId()][player->GetGUID()] = GameTime::GetGameTime().count() + 10;
            }
        }
}

References ObjectAccessor::FindPlayer(), GameTime::GetGameTime(), InvitePlayerToWar(), m_InvitedPlayers, m_MaxPlayer, m_players, m_PlayersInWar, m_PlayersWillBeKick, and PVP_TEAMS_COUNT.

Referenced by StartBattle(), and Update().

InvitePlayerToQueue()

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(m_BattleId);
}

References Object::GetGUID(), GetOtherTeam(), Player::GetSession(), Player::GetTeamId(), m_BattleId, m_MinPlayer, m_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->IsInFlight())
        return;
 
    if (player->InBattleground())
    {
        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()] = GameTime::GetGameTime().count() + 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()] = GameTime::GetGameTime().count() + m_TimeForAcceptInvite;
    player->GetSession()->SendBfInvitePlayerToWar(m_BattleId, m_ZoneId, m_TimeForAcceptInvite);
}

References GameTime::GetGameTime(), Object::GetGUID(), Unit::GetLevel(), Player::GetSession(), Player::GetTeamId(), Player::InBattleground(), Unit::IsInFlight(), m_BattleId, m_InvitedPlayers, m_MinLevel, m_PlayersInQueue, m_PlayersInWar, m_PlayersWillBeKick, m_TimeForAcceptInvite, m_ZoneId, and WorldSession::SendBfInvitePlayerToWar().

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

IsEnabled()

bool Battlefield::IsEnabled ( )

inline

Return if battlefield is enable.

{ return m_IsEnabled; }

References m_IsEnabled.

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

IsWarTime()

bool Battlefield::IsWarTime ( )

inline

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

{ return m_isActive; }

References m_isActive.

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

KickAfkPlayers()

void Battlefield::KickAfkPlayers ( )

protected

{
    // xinef: optimization, dont lookup player twice
    for (uint8 team = 0; team < PVP_TEAMS_COUNT; ++team)
        for (GuidUnorderedSet::const_iterator itr = m_PlayersInWar[team].begin(); itr != m_PlayersInWar[team].end(); ++itr)
            if (Player* player = ObjectAccessor::FindPlayer(*itr))
                if (player->isAFK() && player->GetZoneId() == GetZoneId() && !player->IsGameMaster())
                    player->TeleportTo(KickPosition);
}

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

Referenced by Update().

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 kick

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

References ObjectAccessor::FindPlayer(), GetZoneId(), and KickPosition.

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

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 enter in battlefield zone.

Reimplemented in BattlefieldWG.

{};

Referenced by HandlePlayerEnterZone().

OnPlayerJoinWar()

virtual void Battlefield::OnPlayerJoinWar ( Player *  )

inlinevirtual

Called when a player accept to join the battle.

Reimplemented in BattlefieldWG.

{};

Referenced by PlayerAcceptInviteToWar().

OnPlayerLeaveWar()

virtual void Battlefield::OnPlayerLeaveWar ( Player *  )

inlinevirtual

Called when a player leave the battle.

Reimplemented in BattlefieldWG.

{};

Referenced by HandlePlayerLeaveZone().

OnPlayerLeaveZone()

virtual void Battlefield::OnPlayerLeaveZone ( Player *  )

inlinevirtual

Called when a player leave battlefield zone.

Reimplemented in BattlefieldWG.

{};

Referenced by HandlePlayerLeaveZone().

OnStartGrouping()

virtual void Battlefield::OnStartGrouping ( )

inlinevirtual

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

Reimplemented in BattlefieldWG.

{};

Referenced by Update().

PlayerAcceptInviteToQueue()

void Battlefield::PlayerAcceptInviteToQueue

(

Player *

player

)

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

References Object::GetGUID(), Player::GetSession(), Player::GetTeamId(), m_BattleId, m_PlayersInQueue, m_ZoneId, and WorldSession::SendBfQueueInviteResponse().

Referenced by WorldSession::HandleBfQueueInviteResponse().

PlayerAcceptInviteToWar()

void Battlefield::PlayerAcceptInviteToWar

(

Player *

player

)

{
    if (!IsWarTime())
        return;
 
    if (AddOrSetPlayerToCorrectBfGroup(player))
    {
        player->GetSession()->SendBfEntered(m_BattleId);
        m_PlayersInWar[player->GetTeamId()].insert(player->GetGUID());
        m_InvitedPlayers[player->GetTeamId()].erase(player->GetGUID());
 
        if (player->isAFK())
            player->ToggleAFK();
 
        OnPlayerJoinWar(player);                               //for scripting
    }
}

References AddOrSetPlayerToCorrectBfGroup(), Object::GetGUID(), Player::GetSession(), Player::GetTeamId(), Player::isAFK(), IsWarTime(), m_BattleId, m_InvitedPlayers, m_PlayersInWar, OnPlayerJoinWar(), WorldSession::SendBfEntered(), and Player::ToggleAFK().

Referenced by WorldSession::HandleBfEntryInviteResponse().

PlayerAskToLeave()

void Battlefield::PlayerAskToLeave

(

Player *

player

)

{
    // Player leaving Wintergrasp, teleport to homebind possition.
    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

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;
        }
    }
}

References HasPlayer(), and m_GraveyardList.

Referenced by HandlePlayerLeaveZone().

SendAreaSpiritHealerQueryOpcode()

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

{
    WorldPacket data(SMSG_AREA_SPIRIT_HEALER_TIME, 12);
    uint32 time = m_LastResurectTimer;  // resurrect every 30 seconds
 
    data << guid << time;
    ASSERT(player);
    player->GetSession()->SendPacket(&data);
}

References ASSERT, Player::GetSession(), m_LastResurectTimer, WorldSession::SendPacket(), and SMSG_AREA_SPIRIT_HEALER_TIME.

SendInitWorldStatesToAll()

virtual void Battlefield::SendInitWorldStatesToAll ( )

pure virtual

Send all worldstate data to all player 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.

{
    for (uint8 i = 0; i < PVP_TEAMS_COUNT; ++i)
        for (GuidUnorderedSet::iterator itr = m_players[i].begin(); itr != m_players[i].end(); ++itr)
            if (Player* player = ObjectAccessor::FindPlayer(*itr))
                player->SendUpdateWorldState(field, value);
}

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

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.

{ m_Data32[dataId] = value; }

References m_Data32.

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

SetData64()

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

inlineoverridevirtual

Reimplemented from ZoneScript.

{ m_Data64[dataId] = value; }

References m_Data64.

SetDefenderTeam()

void Battlefield::SetDefenderTeam ( TeamId  team )

inline

{ m_DefenderTeam = team; }

References m_DefenderTeam.

Referenced by EndBattle().

SetGraveyardNumber()

void Battlefield::SetGraveyardNumber ( uint32  number )

inline

{ m_GraveyardList.resize(number); }

References m_GraveyardList.

Referenced by BattlefieldWG::SetupBattlefield().

SetTimer()

void Battlefield::SetTimer ( uint32  timer )

inline

{ m_Timer = timer; }

References m_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
	)

{
    //Get map object
    Map* map = sMapMgr->CreateBaseMap(m_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(true);
    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);
 
    // Set creature in world
    map->AddToMap(creature);
    creature->setActive(true);
 
    return creature;
}

References Map::AddToMap(), BattlefieldFactions, Creature::Create(), Map::GenerateLowGuid(), LOG_ERROR, m_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
	)

{
    // Get map object
    Map* map = sMapMgr->CreateBaseMap(m_MapId);
    if (!map)
        return 0;
 
    // Create gameobject
    GameObject* go = sObjectMgr->IsGameObjectStaticTransport(entry) ? new StaticTransport() : new GameObject();
    if (!go->Create(map->GenerateLowGuid<HighGuid::GameObject>(), entry, map, PHASEMASK_NORMAL, x, y, z, o, G3D::Quat(), 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;
    }
 
    // Add to world
    map->AddToMap(go);
    go->setActive(true);
 
    return go;
}

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

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

StartBattle()

void Battlefield::StartBattle

(

)

{
    if (m_isActive)
        return;
 
    for (int team = 0; team < PVP_TEAMS_COUNT; team++)
    {
        m_PlayersInWar[team].clear();
        m_Groups[team].clear();
    }
 
    m_Timer = m_BattleTime;
    m_isActive = true;
 
    InvitePlayersInZoneToWar();
    InvitePlayersInQueueToWar();
 
    DoPlaySoundToAll(BF_START);
 
    OnBattleStart();
 
    SendUpdateWorldStates();
}

References BF_START, DoPlaySoundToAll(), InvitePlayersInQueueToWar(), InvitePlayersInZoneToWar(), m_BattleTime, m_Groups, m_isActive, m_PlayersInWar, m_Timer, OnBattleStart(), PVP_TEAMS_COUNT, 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

{
    if (spellId > 0)
    {
        for (GuidUnorderedSet::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 (GuidUnorderedSet::const_iterator itr = m_PlayersInWar[team].begin(); itr != m_PlayersInWar[team].end(); ++itr)
            if (Player* player = ObjectAccessor::FindPlayer(*itr))
                player->RemoveAuraFromStack(uint32(-spellId));
    }
}

References ObjectAccessor::FindPlayer(), and m_PlayersInWar.

ToggleBattlefield()

void Battlefield::ToggleBattlefield ( bool  enable )

inline

Enable or Disable battlefield.

{ m_IsEnabled = enable; }

References m_IsEnabled.

Referenced by bf_commandscript::HandleBattlefieldEnable().

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

  Parameters

  diff	: time ellapsed since last call (in ms)

Reimplemented in BattlefieldWG.

{
    if (m_Timer <= diff)
    {
        if (!IsEnabled() || (!IsWarTime() && sWorldSessionMgr->GetActiveSessionCount() > 3500)) // if WG is disabled or there is more than 3500 connections, switch automaticly
        {
            m_isActive = true;
            EndBattle(false);
            return false;
        }
        // Battlefield ends on time
        if (IsWarTime())
            EndBattle(true);
        else // Time to start a new battle!
            StartBattle();
    }
    else
        m_Timer -= diff;
 
    if (!IsEnabled())
        return false;
 
    // Invite players a few minutes before the battle's beginning
    if (!IsWarTime() && !m_StartGrouping && m_Timer <= m_StartGroupingTimer)
    {
        m_StartGrouping = true;
        InvitePlayersInZoneToQueue();
        OnStartGrouping();
        SendUpdateWorldStates();
    }
 
    bool objective_changed = false;
    if (IsWarTime())
    {
        if (m_uiKickAfkPlayersTimer <= diff)
        {
            m_uiKickAfkPlayersTimer = 20000;
            KickAfkPlayers();
        }
        else
            m_uiKickAfkPlayersTimer -= diff;
 
        // Kick players who chose not to accept invitation to the battle
        if (m_uiKickDontAcceptTimer <= diff)
        {
            time_t now = GameTime::GetGameTime().count();
            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 = 5000;
        }
        else
            m_uiKickDontAcceptTimer -= diff;
 
        for (BfCapturePointVector::iterator itr = m_capturePoints.begin(); itr != m_capturePoints.end(); ++itr)
            if ((*itr)->Update(diff))
                objective_changed = true;
    }
 
    if (m_LastResurectTimer <= diff)
    {
        for (uint8 i = 0; i < m_GraveyardList.size(); i++)
            if (GetGraveyardById(i))
                m_GraveyardList[i]->Resurrect();
        m_LastResurectTimer = RESURRECTION_INTERVAL;
    }
    else
        m_LastResurectTimer -= diff;
 
    return objective_changed;
}

References EndBattle(), GameTime::GetGameTime(), GetGraveyardById(), InvitePlayersInZoneToQueue(), InvitePlayersInZoneToWar(), IsEnabled(), IsWarTime(), KickAfkPlayers(), KickPlayerFromBattlefield(), m_capturePoints, m_GraveyardList, m_InvitedPlayers, m_isActive, m_LastResurectTimer, m_PlayersWillBeKick, m_StartGrouping, m_StartGroupingTimer, m_Timer, m_uiKickAfkPlayersTimer, m_uiKickDontAcceptTimer, OnStartGrouping(), Resurrect(), RESURRECTION_INTERVAL, SendUpdateWorldStates(), StartBattle(), and sWorldSessionMgr.

Referenced by BattlefieldMgr::Update(), and BattlefieldWG::Update().

UpdateData()

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

inlinevirtual

{ m_Data32[index] += pad; }

References m_Data32.

Friends And Related Symbol Documentation

BattlefieldMgr

friend class BattlefieldMgr

friend

Member Data Documentation

KickPosition

WorldLocation Battlefield::KickPosition

protected

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

m_BattleId

uint32 Battlefield::m_BattleId

protected

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

m_BattleTime

uint32 Battlefield::m_BattleTime

protected

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

m_capturePoints

BfCapturePointVector Battlefield::m_capturePoints

protected

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

m_Data32

std::vector<uint32> Battlefield::m_Data32

protected

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

m_Data64

std::vector<uint64> Battlefield::m_Data64

protected

Referenced by GetData64(), and SetData64().

m_DefenderTeam

TeamId Battlefield::m_DefenderTeam

protected

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

m_GraveyardList

GraveyardVect Battlefield::m_GraveyardList

protected

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

m_Groups

GuidUnorderedSet Battlefield::m_Groups[PVP_TEAMS_COUNT]

protected

Referenced by AddOrSetPlayerToCorrectBfGroup(), GetFreeBfRaid(), GetGroupPlayer(), and StartBattle().

m_InvitedPlayers

PlayerTimerMap Battlefield::m_InvitedPlayers[PVP_TEAMS_COUNT]

protected

Referenced by HandlePlayerEnterZone(), HandlePlayerLeaveZone(), InvitePlayersInQueueToWar(), InvitePlayersInZoneToWar(), InvitePlayerToWar(), PlayerAcceptInviteToWar(), and Update().

m_isActive

bool Battlefield::m_isActive

protected

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

m_IsEnabled

bool Battlefield::m_IsEnabled

protected

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

m_LastResurectTimer

uint32 Battlefield::m_LastResurectTimer

protected

Referenced by Battlefield(), SendAreaSpiritHealerQueryOpcode(), and Update().

m_Map

Map* Battlefield::m_Map

protected

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

m_MapId

uint32 Battlefield::m_MapId

protected

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

m_MaxPlayer

uint32 Battlefield::m_MaxPlayer

protected

Referenced by Battlefield(), HandlePlayerEnterZone(), InvitePlayersInQueueToWar(), InvitePlayersInZoneToWar(), and BattlefieldWG::SetupBattlefield().

m_MinLevel

uint32 Battlefield::m_MinLevel

protected

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

m_MinPlayer

uint32 Battlefield::m_MinPlayer

protected

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

m_NoWarBattleTime

uint32 Battlefield::m_NoWarBattleTime

protected

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

m_players

GuidUnorderedSet Battlefield::m_players[PVP_TEAMS_COUNT]

protected

Referenced by BroadcastPacketToZone(), BattlefieldWG::CapturePointTaken(), HandlePlayerEnterZone(), HandlePlayerLeaveZone(), HasPlayer(), InvitePlayersInZoneToQueue(), InvitePlayersInZoneToWar(), BattlefieldWG::OnBattleEnd(), BattlefieldWG::OnBattleStart(), BattlefieldWG::SendInitWorldStatesToAll(), SendUpdateWorldState(), and BattlefieldWG::UpdateVehicleCountWG().

m_PlayersInQueue

GuidUnorderedSet Battlefield::m_PlayersInQueue[PVP_TEAMS_COUNT]

protected

Referenced by AskToLeaveQueue(), BroadcastPacketToQueue(), InvitePlayersInQueueToWar(), InvitePlayerToQueue(), InvitePlayerToWar(), and PlayerAcceptInviteToQueue().

m_PlayersInWar

GuidUnorderedSet Battlefield::m_PlayersInWar[PVP_TEAMS_COUNT]

protected

Referenced by BroadcastPacketToWar(), BattlefieldWG::HandleKill(), HandlePlayerEnterZone(), HandlePlayerLeaveZone(), InvitePlayersInQueueToWar(), InvitePlayersInZoneToWar(), InvitePlayerToWar(), KickAfkPlayers(), BattlefieldWG::OnBattleEnd(), PlayerAcceptInviteToWar(), StartBattle(), TeamCastSpell(), BattlefieldWG::UpdatedDestroyedTowerCount(), and BattlefieldWG::UpdateTenacity().

m_PlayersWillBeKick

PlayerTimerMap Battlefield::m_PlayersWillBeKick[PVP_TEAMS_COUNT]

protected

Referenced by HandlePlayerEnterZone(), HandlePlayerLeaveZone(), InvitePlayersInZoneToWar(), InvitePlayerToWar(), and Update().

m_RestartAfterCrash

uint32 Battlefield::m_RestartAfterCrash

protected

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

m_StartGrouping

bool Battlefield::m_StartGrouping

protected

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

m_StartGroupingTimer

uint32 Battlefield::m_StartGroupingTimer

protected

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

m_TimeForAcceptInvite

uint32 Battlefield::m_TimeForAcceptInvite

protected

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

m_Timer

uint32 Battlefield::m_Timer

protected

Referenced by Battlefield(), EndBattle(), GetTimer(), HandlePlayerEnterZone(), SetTimer(), BattlefieldWG::SetupBattlefield(), StartBattle(), Update(), BattlefieldWG::Update(), and BattlefieldWG::UpdatedDestroyedTowerCount().

m_TypeId

uint32 Battlefield::m_TypeId

protected

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

m_uiKickAfkPlayersTimer

uint32 Battlefield::m_uiKickAfkPlayersTimer

protected

Referenced by Battlefield(), and Update().

m_uiKickDontAcceptTimer

uint32 Battlefield::m_uiKickDontAcceptTimer

protected

Referenced by Battlefield(), and Update().

m_ZoneId

uint32 Battlefield::m_ZoneId

protected

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

StalkerGuid

ObjectGuid Battlefield::StalkerGuid

protected

Referenced by InitStalker(), and SendWarning().

---

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