BfCapturePoint Class Reference

#include <Battlefield.h>

Public Member Functions
	BfCapturePoint (Battlefield *bf)
virtual	~BfCapturePoint ()
virtual void	FillInitialWorldStates (WorldPackets::WorldState::InitWorldStates &)
void	SendUpdateWorldState (uint32 field, uint32 value)
void	SendObjectiveComplete (uint32 id, ObjectGuid guid)
virtual bool	HandlePlayerEnter (Player *player)
virtual GuidSet::iterator	HandlePlayerLeave (Player *player)
bool	IsInsideObjective (Player *player) const
virtual bool	Update (uint32 diff)
virtual void	ChangeTeam (TeamId)
virtual void	SendChangePhase ()
bool	SetCapturePointData (GameObject *capturePoint)
GameObject *	GetCapturePointGo ()
uint32	GetCapturePointEntry () const
TeamId	GetTeamId () const

Protected Member Functions
bool	DelCapturePoint ()

Protected Attributes
GuidSet	m_activePlayers [BG_TEAMS_COUNT]
float	m_maxValue
float	m_minValue
float	m_maxSpeed
float	m_value
TeamId	m_team
BattlefieldObjectiveStates	m_OldState
BattlefieldObjectiveStates	m_State
uint32	m_neutralValuePct
Battlefield *	m_Bf
uint32	m_capturePointEntry
ObjectGuid	m_capturePointGUID

Constructor & Destructor Documentation

BfCapturePoint::BfCapturePoint

(

Battlefield *

bf

)

 : m_Bf(battlefield), m_capturePointGUID()
{
 m_team = TEAM_NEUTRAL;
 m_value = 0;
 m_minValue = 0.0f;
 m_maxValue = 0.0f;
 m_State = BF_CAPTUREPOINT_OBJECTIVESTATE_NEUTRAL;
 m_OldState = BF_CAPTUREPOINT_OBJECTIVESTATE_NEUTRAL;
 m_capturePointEntry = 0;
 m_neutralValuePct = 0;
 m_maxSpeed = 0;
}

virtual BfCapturePoint::~BfCapturePoint ( )

inlinevirtual

{ }

Member Function Documentation

virtual void BfCapturePoint::ChangeTeam ( TeamId  )

inlinevirtual

Reimplemented in WintergraspCapturePoint.

{ }

Here is the caller graph for this function:

bool BfCapturePoint::DelCapturePoint ( )

protected

{
 if (!m_capturePointGUID.IsEmpty())
 {
 if (GameObject* capturePoint = m_Bf->GetGameObject(m_capturePointGUID))
 {
 capturePoint->SetRespawnTime(0); // not save respawn time
 capturePoint->Delete();
 capturePoint = NULL;
 }
 m_capturePointGUID.Clear();
 }

 return true;
}

Here is the call graph for this function:

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

inlinevirtual

{ }

uint32 BfCapturePoint::GetCapturePointEntry ( ) const

inline

{ return m_capturePointEntry; }

Here is the caller graph for this function:

GameObject * BfCapturePoint::GetCapturePointGo

(

)

{
 return m_Bf->GetGameObject(m_capturePointGUID);
}

Here is the call graph for this function:

TeamId BfCapturePoint::GetTeamId ( ) const

inline

{ return m_team; }

bool BfCapturePoint::HandlePlayerEnter ( Player *  player )

virtual

{
 if (!m_capturePointGUID.IsEmpty())
 {
 if (GameObject* capturePoint = m_Bf->GetGameObject(m_capturePointGUID))
 {
 player->SendUpdateWorldState(capturePoint->GetGOInfo()->controlZone.worldState1, 1);
 player->SendUpdateWorldState(capturePoint->GetGOInfo()->controlZone.worldstate2, uint32(ceil((m_value + m_maxValue) / (2 * m_maxValue) * 100.0f)));
 player->SendUpdateWorldState(capturePoint->GetGOInfo()->controlZone.worldstate3, m_neutralValuePct);
 }
 }

 return m_activePlayers[player->GetTeamId()].insert(player->GetGUID()).second;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GuidSet::iterator BfCapturePoint::HandlePlayerLeave ( Player *  player )

virtual

{
 if (!m_capturePointGUID.IsEmpty())
 if (GameObject* capturePoint = m_Bf->GetGameObject(m_capturePointGUID))
 player->SendUpdateWorldState(capturePoint->GetGOInfo()->controlZone.worldState1, 0);

 GuidSet::iterator current = m_activePlayers[player->GetTeamId()].find(player->GetGUID());

 if (current == m_activePlayers[player->GetTeamId()].end())
 return current; // return end()

 m_activePlayers[player->GetTeamId()].erase(current++);
 return current;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool BfCapturePoint::IsInsideObjective

(

Player *

player

)

const

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

void BfCapturePoint::SendChangePhase ( )

virtual

{
 if (!m_capturePointGUID)
 return;

 if (GameObject* capturePoint = m_Bf->GetGameObject(m_capturePointGUID))
 {
 // send this too, sometimes the slider disappears, dunno why :(
 SendUpdateWorldState(capturePoint->GetGOInfo()->controlZone.worldState1, 1);
 // send these updates to only the ones in this objective
 SendUpdateWorldState(capturePoint->GetGOInfo()->controlZone.worldstate2, (uint32)std::ceil((m_value + m_maxValue) / (2 * m_maxValue) * 100.0f));
 // send this too, sometimes it resets :S
 SendUpdateWorldState(capturePoint->GetGOInfo()->controlZone.worldstate3, m_neutralValuePct);
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void BfCapturePoint::SendObjectiveComplete	(	uint32	id,
		ObjectGuid	guid
	)

{
 uint8 team;
 switch (m_State)
 {
 case BF_CAPTUREPOINT_OBJECTIVESTATE_ALLIANCE:
 team = 0;
 break;
 case BF_CAPTUREPOINT_OBJECTIVESTATE_HORDE:
 team = 1;
 break;
 default:
 return;
 }

 // send to all players present in the area
 for (GuidSet::iterator itr = m_activePlayers[team].begin(); itr != m_activePlayers[team].end(); ++itr)
 if (Player* player = ObjectAccessor::FindPlayer(*itr))
 player->KilledMonsterCredit(id, guid);
}

Here is the call graph for this function:

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

{
 for (uint8 team = 0; team < 2; ++team)
 for (GuidSet::iterator itr = m_activePlayers[team].begin(); itr != m_activePlayers[team].end(); ++itr) // send to all players present in the area
 if (Player* player = ObjectAccessor::FindPlayer(*itr))
 player->SendUpdateWorldState(field, value);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool BfCapturePoint::SetCapturePointData

(

GameObject *

capturePoint

)

{
 ASSERT(capturePoint);

 TC_LOG_DEBUG("bg.battlefield", "Creating capture point %u", capturePoint->GetEntry());

 m_capturePointGUID = capturePoint->GetGUID();
 m_capturePointEntry = capturePoint->GetEntry();

 // check info existence
 GameObjectTemplate const* goinfo = capturePoint->GetGOInfo();
 if (goinfo->type != GAMEOBJECT_TYPE_CONTROL_ZONE)
 {
 TC_LOG_ERROR("misc", "OutdoorPvP: GO %u is not capture point!", capturePoint->GetEntry());
 return false;
 }

 // get the needed values from goinfo
 m_maxValue = goinfo->controlZone.maxTime;
 m_maxSpeed = m_maxValue / (goinfo->controlZone.minTime ? goinfo->controlZone.minTime : 60);
 m_neutralValuePct = goinfo->controlZone.neutralPercent;
 m_minValue = m_maxValue * goinfo->controlZone.neutralPercent / 100;

 if (m_team == TEAM_ALLIANCE)
 {
 m_value = m_maxValue;
 m_State = BF_CAPTUREPOINT_OBJECTIVESTATE_ALLIANCE;
 }
 else
 {
 m_value = -m_maxValue;
 m_State = BF_CAPTUREPOINT_OBJECTIVESTATE_HORDE;
 }

 return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool BfCapturePoint::Update ( uint32  diff )

virtual

{
 if (!m_capturePointGUID)
 return false;

 if (GameObject* capturePoint = m_Bf->GetGameObject(m_capturePointGUID))
 {
 float radius = capturePoint->GetGOInfo()->controlZone.radius;

 for (uint8 team = 0; team < 2; ++team)
 {
 for (GuidSet::iterator itr = m_activePlayers[team].begin(); itr != m_activePlayers[team].end();)
 {
 if (Player* player = ObjectAccessor::FindPlayer(*itr))
 {
 if (!capturePoint->IsWithinDistInMap(player, radius) || !player->IsOutdoorPvPActive())
 itr = HandlePlayerLeave(player);
 else
 ++itr;
 }
 else
 ++itr;
 }
 }

 std::list<Player*> players;
 Trinity::AnyPlayerInObjectRangeCheck checker(capturePoint, radius);
 Trinity::PlayerListSearcher<Trinity::AnyPlayerInObjectRangeCheck> searcher(capturePoint, players, checker);
 capturePoint->VisitNearbyWorldObject(radius, searcher);

 for (std::list<Player*>::iterator itr = players.begin(); itr != players.end(); ++itr)
 if ((*itr)->IsOutdoorPvPActive())
 if (m_activePlayers[(*itr)->GetTeamId()].insert((*itr)->GetGUID()).second)
 HandlePlayerEnter(*itr);
 }

 // get the difference of numbers
 float fact_diff = ((float) m_activePlayers[0].size() - (float) m_activePlayers[1].size()) * diff / BATTLEFIELD_OBJECTIVE_UPDATE_INTERVAL;
 if (G3D::fuzzyEq(fact_diff, 0.0f))
 return false;

 uint32 Challenger = 0;
 float maxDiff = m_maxSpeed * diff;

 if (fact_diff < 0)
 {
 // horde is in majority, but it's already horde-controlled -> no change
 if (m_State == BF_CAPTUREPOINT_OBJECTIVESTATE_HORDE && m_value <= -m_maxValue)
 return false;

 if (fact_diff < -maxDiff)
 fact_diff = -maxDiff;

 Challenger = HORDE;
 }
 else
 {
 // ally is in majority, but it's already ally-controlled -> no change
 if (m_State == BF_CAPTUREPOINT_OBJECTIVESTATE_ALLIANCE && m_value >= m_maxValue)
 return false;

 if (fact_diff > maxDiff)
 fact_diff = maxDiff;

 Challenger = ALLIANCE;
 }

 float oldValue = m_value;
 TeamId oldTeam = m_team;

 m_OldState = m_State;

 m_value += fact_diff;

 if (m_value < -m_minValue) // red
 {
 if (m_value < -m_maxValue)
 m_value = -m_maxValue;
 m_State = BF_CAPTUREPOINT_OBJECTIVESTATE_HORDE;
 m_team = TEAM_HORDE;
 }
 else if (m_value > m_minValue) // blue
 {
 if (m_value > m_maxValue)
 m_value = m_maxValue;
 m_State = BF_CAPTUREPOINT_OBJECTIVESTATE_ALLIANCE;
 m_team = TEAM_ALLIANCE;
 }
 else if (oldValue * m_value <= 0) // grey, go through mid point
 {
 // if challenger is ally, then n->a challenge
 if (Challenger == ALLIANCE)
 m_State = BF_CAPTUREPOINT_OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE;
 // if challenger is horde, then n->h challenge
 else if (Challenger == HORDE)
 m_State = BF_CAPTUREPOINT_OBJECTIVESTATE_NEUTRAL_HORDE_CHALLENGE;
 m_team = TEAM_NEUTRAL;
 }
 else // grey, did not go through mid point
 {
 // old phase and current are on the same side, so one team challenges the other
 if (Challenger == ALLIANCE && (m_OldState == BF_CAPTUREPOINT_OBJECTIVESTATE_HORDE || m_OldState == BF_CAPTUREPOINT_OBJECTIVESTATE_NEUTRAL_HORDE_CHALLENGE))
 m_State = BF_CAPTUREPOINT_OBJECTIVESTATE_HORDE_ALLIANCE_CHALLENGE;
 else if (Challenger == HORDE && (m_OldState == BF_CAPTUREPOINT_OBJECTIVESTATE_ALLIANCE || m_OldState == BF_CAPTUREPOINT_OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE))
 m_State = BF_CAPTUREPOINT_OBJECTIVESTATE_ALLIANCE_HORDE_CHALLENGE;
 m_team = TEAM_NEUTRAL;
 }

 if (G3D::fuzzyNe(m_value, oldValue))
 SendChangePhase();

 if (m_OldState != m_State)
 {
 //TC_LOG_ERROR("bg.battlefield", "%u->%u", m_OldState, m_State);
 if (oldTeam != m_team)
 ChangeTeam(oldTeam);
 return true;
 }

 return false;
}

Here is the call graph for this function:

Member Data Documentation

GuidSet BfCapturePoint::m_activePlayers[BG_TEAMS_COUNT]

protected

Battlefield* BfCapturePoint::m_Bf

protected

uint32 BfCapturePoint::m_capturePointEntry

protected

ObjectGuid BfCapturePoint::m_capturePointGUID

protected

float BfCapturePoint::m_maxSpeed

protected

float BfCapturePoint::m_maxValue

protected

float BfCapturePoint::m_minValue

protected

uint32 BfCapturePoint::m_neutralValuePct

protected

BattlefieldObjectiveStates BfCapturePoint::m_OldState

protected

BattlefieldObjectiveStates BfCapturePoint::m_State

protected

TeamId BfCapturePoint::m_team

protected

float BfCapturePoint::m_value

protected

---

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

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