#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 (WorldPacket &)=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 uint64	GetData64 (uint32) const

virtual void	SetData64 (uint32, uint64)

virtual uint32	GetData (uint32) const

virtual void	SetData (uint32, uint32)

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.

{
    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

421{ 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 m_GraveyardList.

◆ AskToLeaveQueue()

void Battlefield::AskToLeaveQueue ( Player * player )

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

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

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.

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

References BF_ALLIANCE_WINS, BF_HORDE_WINS, DoPlaySoundToAll(), GetAttackerTeam(), GetDefenderTeam(), m_isActive, m_NoWarBattleTime, m_StartGrouping, m_Timer, OnBattleEnd(), SendInitWorldStatesToAll(), SetDefenderTeam(), and TEAM_ALLIANCE.

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

◆ FillInitialWorldStates()

virtual void Battlefield::FillInitialWorldStates ( WorldPacket & )

pure virtual

Implemented in BattlefieldWG.

Referenced by Player::SendInitWorldStates().

◆ GetAttackerTeam()

TeamId Battlefield::GetAttackerTeam ( )

inline

◆ GetBattleId()

uint32 Battlefield::GetBattleId ( )

inline

330{ 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::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.

271{ return m_Data32[dataId]; }

Battlefield::m_Data32

std::vector< uint32 > m_Data32

Definition: Battlefield.h:408

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.

267{ return m_Data64[dataId]; }

Battlefield::m_Data64

std::vector< uint64 > m_Data64

Definition: Battlefield.h:407

References m_Data64.

◆ GetDefenderTeam()

TeamId Battlefield::GetDefenderTeam ( )

inline

276{ return m_DefenderTeam; }

References m_DefenderTeam.

Referenced by EndBattle(), BattlefieldWG::FillInitialWorldStates(), npc_wg_quest_giver::GetDialogStatus(), spell_wintergrasp_portal::spell_wintergrasp_portal_SpellScript::HandleScript(), BfWGGameObjectBuilding::Init(), SpellArea::IsFitToRequirements(), BattlefieldWG::OnBattleEnd(), BattlefieldWG::OnBattleStart(), npc_wg_queue::OnGossipHello(), npc_wg_quest_giver::OnGossipHello(), BattlefieldWG::OnPlayerJoinWar(), BfWGGameObjectBuilding::Rebuild(), 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

351{ 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

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

TEAM_HORDE

@ TEAM_HORDE

Definition: SharedDefines.h:733

References TEAM_ALLIANCE, and TEAM_HORDE.

Referenced by InvitePlayerToQueue().

◆ GetTimer()

uint32 Battlefield::GetTimer ( )

inline

353{ return m_Timer; }

References m_Timer.

Referenced by instance_vault_of_archavon::instance_vault_of_archavon_InstanceMapScript::IsEncounterInProgress(), achievement_wg_within_our_grasp::OnCheck(), npc_wg_queue::OnGossipHello(), and npc_wg_queue::OnGossipSelect().

◆ GetTypeId()

uint32 Battlefield::GetTypeId ( )

inline

242{ return m_TypeId; }

References m_TypeId.

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

◆ GetZoneId()

uint32 Battlefield::GetZoneId ( )

inline

243{ 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.

240{};

◆ 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().

◆ 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.

253{ 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.

248{ return m_isActive; }

References m_isActive.

Referenced by Player::CreateCorpse(), BattlefieldWG::FillInitialWorldStates(), spell_wintergrasp_hide_small_elementals::spell_wintergrasp_hide_small_elementals_AuraScript::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(), 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.

314{};

Referenced by EndBattle().

◆ OnBattleStart()

virtual void Battlefield::OnBattleStart ( )

inlinevirtual

Called on start.

Reimplemented in BattlefieldWG.

312{};

Referenced by StartBattle().

◆ OnPlayerEnterZone()

virtual void Battlefield::OnPlayerEnterZone ( Player * )

inlinevirtual

Called when a player enter in battlefield zone.

Reimplemented in BattlefieldWG.

324{};

Referenced by HandlePlayerEnterZone().

◆ OnPlayerJoinWar()

virtual void Battlefield::OnPlayerJoinWar ( Player * )

inlinevirtual

Called when a player accept to join the battle.

Reimplemented in BattlefieldWG.

318{};

Referenced by PlayerAcceptInviteToWar().

◆ OnPlayerLeaveWar()

virtual void Battlefield::OnPlayerLeaveWar ( Player * )

inlinevirtual

Called when a player leave the battle.

Reimplemented in BattlefieldWG.

320{};

Referenced by HandlePlayerLeaveZone().

◆ OnPlayerLeaveZone()

virtual void Battlefield::OnPlayerLeaveZone ( Player * )

inlinevirtual

Called when a player leave battlefield zone.

Reimplemented in BattlefieldWG.

322{};

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.

316{};

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, trigger Hearthstone spell.
    player->CastSpell(player, 8690, true);
}

References Unit::CastSpell().

◆ 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

413{}

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().

◆ 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.

272{ 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.

268{ m_Data64[dataId] = value; }

References m_Data64.

◆ SetDefenderTeam()

void Battlefield::SetDefenderTeam ( TeamId team )

inline

279{ m_DefenderTeam = team; }

References m_DefenderTeam.

Referenced by EndBattle().

◆ SetGraveyardNumber()

void Battlefield::SetGraveyardNumber ( uint32 number )

inline

298{ m_GraveyardList.resize(number); }

References m_GraveyardList.

Referenced by BattlefieldWG::SetupBattlefield().

◆ SetTimer()

void Battlefield::SetTimer ( uint32 timer )

inline

354{ 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.

218{ 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;
    }
 
    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, and CreatureTemplate::speed_walk.

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

References BF_START, DoPlaySoundToAll(), InvitePlayersInQueueToWar(), InvitePlayersInZoneToWar(), m_BattleTime, m_Groups, m_isActive, m_PlayersInWar, m_Timer, OnBattleStart(), and PVP_TEAMS_COUNT.

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.

251{ 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() && sWorld->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();
    }
 
    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;
}