OPvPCapturePoint Class Reference

#include <OutdoorPvP.h>

Public Member Functions
	OPvPCapturePoint (OutdoorPvP *pvp)
virtual	~OPvPCapturePoint ()
virtual void	FillInitialWorldStates (WorldPackets::WorldState::InitWorldStates &)
void	SendUpdateWorldState (uint32 field, uint32 value)
void	SendObjectiveComplete (uint32 id, ObjectGuid guid)
virtual bool	HandlePlayerEnter (Player *player)
virtual void	HandlePlayerLeave (Player *player)
bool	IsInsideObjective (Player *player) const
virtual bool	HandleCustomSpell (Player *player, uint32 spellId, GameObject *go)
virtual int32	HandleOpenGo (Player *player, GameObject *go)
virtual bool	Update (uint32 diff)
virtual void	ChangeState ()=0
virtual void	ChangeTeam (TeamId)
virtual void	SendChangePhase ()
virtual bool	HandleGossipOption (Player *, Creature *, uint32)
virtual bool	CanTalkTo (Player *, Creature *, GossipMenuItems const &)
virtual bool	HandleDropFlag (Player *, uint32)
virtual void	DeleteSpawns ()
void	AddGO (uint32 type, ObjectGuid::LowType guid)
void	AddCre (uint32 type, ObjectGuid::LowType guid)
bool	SetCapturePointData (uint32 entry, uint32 map, float x, float y, float z, float o=0, float rotation0=0, float rotation1=0, float rotation2=0, float rotation3=0)

Public Attributes
ObjectGuid::LowType	m_capturePointSpawnId
GameObject *	m_capturePoint

Protected Member Functions
bool	AddObject (uint32 type, uint32 entry, uint32 map, float x, float y, float z, float o, float rotation0, float rotation1, float rotation2, float rotation3)
virtual bool	AddCreature (uint32 type, uint32 entry, uint32 map, float x, float y, float z, float o, TeamId teamId=TEAM_NEUTRAL, uint32 spawntimedelay=0)
bool	DelCreature (uint32 type)
bool	DelObject (uint32 type)
bool	DelCapturePoint ()

Protected Attributes
GuidSet	m_activePlayers [2]
float	m_maxValue
float	m_minValue
float	m_maxSpeed
float	m_value
TeamId	m_team
ObjectiveStates	m_OldState
ObjectiveStates	m_State
uint32	m_neutralValuePct
OutdoorPvP *	m_PvP
std::map< uint32, ObjectGuid::LowType >	m_Objects
std::map< uint32, ObjectGuid::LowType >	m_Creatures
std::map< ObjectGuid::LowType, uint32 >	m_ObjectTypes
std::map< ObjectGuid::LowType, uint32 >	m_CreatureTypes

Constructor & Destructor Documentation

OPvPCapturePoint::OPvPCapturePoint

(

OutdoorPvP *

pvp

)

 :
 m_capturePointSpawnId(), m_capturePoint(NULL), m_maxValue(0.0f), m_minValue(0.0f), m_maxSpeed(0),
 m_value(0), m_team(TEAM_NEUTRAL), m_OldState(OBJECTIVESTATE_NEUTRAL),
 m_State(OBJECTIVESTATE_NEUTRAL), m_neutralValuePct(0), m_PvP(pvp)
{ }

virtual OPvPCapturePoint::~OPvPCapturePoint ( )

inlinevirtual

{ }

Member Function Documentation

void OPvPCapturePoint::AddCre	(	uint32	type,
		ObjectGuid::LowType	guid
	)

{
 CreatureData const* data = sObjectMgr->GetCreatureData(guid);
 if (!data)
 return;

 m_Creatures[type] = guid;
 m_CreatureTypes[m_Creatures[type]] = type;
}

Here is the caller graph for this function:

bool OPvPCapturePoint::AddCreature ( uint32  type, uint32  entry, uint32  map, float  x, float  y, float  z, float  o, TeamId  teamId = TEAM_NEUTRAL, uint32  spawntimedelay = 0  )

protectedvirtual

{
 if (ObjectGuid::LowType guid = sObjectMgr->AddCreatureData(entry, map, x, y, z, o, spawntimedelay))
 {
 AddCre(type, guid);
 return true;
 }

 return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void OPvPCapturePoint::AddGO	(	uint32	type,
		ObjectGuid::LowType	guid
	)

{
 GameObjectData const* data = sObjectMgr->GetGOData(guid);
 if (!data)
 return;

 m_Objects[type] = guid;
 m_ObjectTypes[m_Objects[type]] = type;
}

Here is the caller graph for this function:

bool OPvPCapturePoint::AddObject ( uint32  type, uint32  entry, uint32  map, float  x, float  y, float  z, float  o, float  rotation0, float  rotation1, float  rotation2, float  rotation3  )

protected

{
 if (ObjectGuid::LowType guid = sObjectMgr->AddGOData(entry, map, x, y, z, o, 0, rotation0, rotation1, rotation2, rotation3))
 {
 AddGO(type, guid);
 return true;
 }

 return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

virtual bool OPvPCapturePoint::CanTalkTo ( Player *  , Creature *  , GossipMenuItems const &    )

inlinevirtual

Reimplemented in OPvPCapturePointZM_GraveYard.

{ return false; }

virtual void OPvPCapturePoint::ChangeState ( )

pure virtual

Implemented in OPvPCapturePointNA, OPvPCapturePointZM_GraveYard, OPvPCapturePointZM_Beacon, OPvPCapturePointTF, and OPvPCapturePointHP.

Here is the caller graph for this function:

virtual void OPvPCapturePoint::ChangeTeam ( TeamId  )

inlinevirtual

{ }

Here is the caller graph for this function:

bool OPvPCapturePoint::DelCapturePoint ( )

protected

{
 sObjectMgr->DeleteGOData(m_capturePointSpawnId);
 m_capturePointSpawnId = 0;

 if (m_capturePoint)
 {
 m_capturePoint->SetRespawnTime(0); // not save respawn time
 m_capturePoint->Delete();
 }

 return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool OPvPCapturePoint::DelCreature ( uint32  type )

protected

{
 ObjectGuid::LowType spawnId = m_Creatures[type];
 if (!spawnId)
 {
 TC_LOG_DEBUG("outdoorpvp", "opvp creature type %u was already deleted", type);
 return false;
 }

 auto bounds = m_PvP->GetMap()->GetCreatureBySpawnIdStore().equal_range(spawnId);
 for (auto itr = bounds.first; itr != bounds.second;)
 {
 Creature* c = itr->second;
 ++itr;
 // Don't save respawn time
 c->SetRespawnTime(0);
 c->RemoveCorpse();
 c->AddObjectToRemoveList();
 }

 TC_LOG_DEBUG("outdoorpvp", "deleting opvp creature type %u", type);
 // explicit removal from map
 // beats me why this is needed, but with the recent removal "cleanup" some creatures stay in the map if "properly" deleted
 // so this is a big fat workaround, if AddObjectToRemoveList and DoDelayedMovesAndRemoves worked correctly, this wouldn't be needed
 //if (Map* map = sMapMgr->FindMap(cr->GetMapId()))
 // map->Remove(cr, false);
 // delete respawn time for this creature
 PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CREATURE_RESPAWN);
 stmt->setUInt64(0, spawnId);
 stmt->setUInt16(1, m_PvP->GetMap()->GetId());
 stmt->setUInt32(2, 0); // instance id, always 0 for world maps
 CharacterDatabase.Execute(stmt);

 sObjectMgr->DeleteCreatureData(spawnId);
 m_CreatureTypes[m_Creatures[type]] = 0;
 m_Creatures[type] = 0;
 return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void OPvPCapturePoint::DeleteSpawns ( )

virtual

{
 for (std::map<uint32, ObjectGuid::LowType>::iterator i = m_Objects.begin(); i != m_Objects.end(); ++i)
 DelObject(i->first);
 for (std::map<uint32, ObjectGuid::LowType>::iterator i = m_Creatures.begin(); i != m_Creatures.end(); ++i)
 DelCreature(i->first);
 DelCapturePoint();
}

Here is the call graph for this function:

bool OPvPCapturePoint::DelObject ( uint32  type )

protected

{
 if (!m_Objects[type])
 return false;

 ObjectGuid::LowType spawnId = m_Objects[type];
 auto bounds = m_PvP->GetMap()->GetGameObjectBySpawnIdStore().equal_range(spawnId);
 for (auto itr = bounds.first; itr != bounds.second;)
 {
 GameObject* go = itr->second;
 ++itr;
 // Don't save respawn time
 go->SetRespawnTime(0);
 go->Delete();
 }

 sObjectMgr->DeleteGOData(spawnId);
 m_ObjectTypes[m_Objects[type]] = 0;
 m_Objects[type] = 0;
 return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

inlinevirtual

Reimplemented in OPvPCapturePointNA, OPvPCapturePointZM_GraveYard, OPvPCapturePointZM_Beacon, OPvPCapturePointTF, and OPvPCapturePointHP.

{ }

bool OPvPCapturePoint::HandleCustomSpell ( Player *  player, uint32  spellId, GameObject *  go  )

virtual

Reimplemented in OPvPCapturePointNA.

{
 if (!player->IsOutdoorPvPActive())
 return false;
 return true;
}

virtual bool OPvPCapturePoint::HandleDropFlag ( Player *  , uint32    )

inlinevirtual

Reimplemented in OPvPCapturePointZM_GraveYard.

{ return false; }

virtual bool OPvPCapturePoint::HandleGossipOption ( Player *  , Creature *  , uint32    )

inlinevirtual

Reimplemented in OPvPCapturePointZM_GraveYard.

{ return false; }

int32 OPvPCapturePoint::HandleOpenGo ( Player *  player, GameObject *  go  )

virtual

Reimplemented in OPvPCapturePointNA, and OPvPCapturePointZM_GraveYard.

{
 std::map<ObjectGuid::LowType, uint32>::iterator itr = m_ObjectTypes.find(go->GetSpawnId());
 if (itr != m_ObjectTypes.end())
 return itr->second;

 return -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool OPvPCapturePoint::HandlePlayerEnter ( Player *  player )

virtual

{
 if (m_capturePoint)
 {
 player->SendUpdateWorldState(m_capturePoint->GetGOInfo()->controlZone.worldState1, 1);
 player->SendUpdateWorldState(m_capturePoint->GetGOInfo()->controlZone.worldstate2, (uint32)ceil((m_value + m_maxValue) / (2 * m_maxValue) * 100.0f));
 player->SendUpdateWorldState(m_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:

void OPvPCapturePoint::HandlePlayerLeave ( Player *  player )

virtual

{
 if (m_capturePoint)
 player->SendUpdateWorldState(m_capturePoint->GetGOInfo()->controlZone.worldState1, 0);
 m_activePlayers[player->GetTeamId()].erase(player->GetGUID());
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool OPvPCapturePoint::IsInsideObjective

(

Player *

player

)

const

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

void OPvPCapturePoint::SendChangePhase ( )

virtual

{
 if (!m_capturePoint)
 return;

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

{
 uint32 team;
 switch (m_State)
 {
 case OBJECTIVESTATE_ALLIANCE:
 team = 0;
 break;
 case 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* const player = ObjectAccessor::FindPlayer(*itr))
 player->KilledMonsterCredit(id, guid);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

{
 for (uint32 team = 0; team < 2; ++team)
 {
 // send to all players present in the area
 for (GuidSet::iterator itr = m_activePlayers[team].begin(); itr != m_activePlayers[team].end(); ++itr)
 if (Player* const 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 OPvPCapturePoint::SetCapturePointData	(	uint32	entry,
		uint32	map,
		float	x,
		float	y,
		float	z,
		float	o = 0,
		float	rotation0 = 0,
		float	rotation1 = 0,
		float	rotation2 = 0,
		float	rotation3 = 0
	)

{
 TC_LOG_DEBUG("outdoorpvp", "Creating capture point %u", entry);

 // check info existence
 GameObjectTemplate const* goinfo = sObjectMgr->GetGameObjectTemplate(entry);
 if (!goinfo || goinfo->type != GAMEOBJECT_TYPE_CONTROL_ZONE)
 {
 TC_LOG_ERROR("outdoorpvp", "OutdoorPvP: GO %u is not capture point!", entry);
 return false;
 }

 m_capturePointSpawnId = sObjectMgr->AddGOData(entry, map, x, y, z, o, 0, rotation0, rotation1, rotation2, rotation3);
 if (!m_capturePointSpawnId)
 return false;

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

 return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool OPvPCapturePoint::Update ( uint32  diff )

virtual

Reimplemented in OPvPCapturePointNA, OPvPCapturePointZM_GraveYard, and OPvPCapturePointTF.

{
 if (!m_capturePoint)
 return false;

 float radius = (float)m_capturePoint->GetGOInfo()->controlZone.radius;

 for (uint32 team = 0; team < 2; ++team)
 {
 for (GuidSet::iterator itr = m_activePlayers[team].begin(); itr != m_activePlayers[team].end();)
 {
 ObjectGuid playerGuid = *itr;
 ++itr;

 if (Player* player = ObjectAccessor::FindPlayer(playerGuid))
 if (!m_capturePoint->IsWithinDistInMap(player, radius) || !player->IsOutdoorPvPActive())
 HandlePlayerLeave(player);
 }
 }

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

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

 // get the difference of numbers
 float fact_diff = ((float)m_activePlayers[0].size() - (float)m_activePlayers[1].size()) * diff / OUTDOORPVP_OBJECTIVE_UPDATE_INTERVAL;
 if (!fact_diff)
 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 == 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 == 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 = OBJECTIVESTATE_HORDE;
 m_team = TEAM_HORDE;
 }
 else if (m_value > m_minValue) // blue
 {
 if (m_value > m_maxValue)
 m_value = m_maxValue;
 m_State = 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 = OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE;
 // if challenger is horde, then n->h challenge
 else if (Challenger == HORDE)
 m_State = 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 == OBJECTIVESTATE_HORDE || m_OldState == OBJECTIVESTATE_NEUTRAL_HORDE_CHALLENGE))
 m_State = OBJECTIVESTATE_HORDE_ALLIANCE_CHALLENGE;
 else if (Challenger == HORDE && (m_OldState == OBJECTIVESTATE_ALLIANCE || m_OldState == OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE))
 m_State = OBJECTIVESTATE_ALLIANCE_HORDE_CHALLENGE;
 m_team = TEAM_NEUTRAL;
 }

 if (m_value != oldValue)
 SendChangePhase();

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

 return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

GuidSet OPvPCapturePoint::m_activePlayers[2]

protected

GameObject* OPvPCapturePoint::m_capturePoint

ObjectGuid::LowType OPvPCapturePoint::m_capturePointSpawnId

std::map<uint32, ObjectGuid::LowType> OPvPCapturePoint::m_Creatures

protected

std::map<ObjectGuid::LowType, uint32> OPvPCapturePoint::m_CreatureTypes

protected

float OPvPCapturePoint::m_maxSpeed

protected

float OPvPCapturePoint::m_maxValue

protected

float OPvPCapturePoint::m_minValue

protected

uint32 OPvPCapturePoint::m_neutralValuePct

protected

std::map<uint32, ObjectGuid::LowType> OPvPCapturePoint::m_Objects

protected

std::map<ObjectGuid::LowType, uint32> OPvPCapturePoint::m_ObjectTypes

protected

ObjectiveStates OPvPCapturePoint::m_OldState

protected

OutdoorPvP* OPvPCapturePoint::m_PvP

protected

ObjectiveStates OPvPCapturePoint::m_State

protected

TeamId OPvPCapturePoint::m_team

protected

float OPvPCapturePoint::m_value

protected

---

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

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