OPvPCapturePoint Class Reference

#include "OutdoorPvP.h"

Inheritance diagram for OPvPCapturePoint:

Public Member Functions
	OPvPCapturePoint (OutdoorPvP *pvp)
virtual	~OPvPCapturePoint ()
virtual void	FillInitialWorldStates (WorldPacket &)
void	SendUpdateWorldState (uint32 field, uint32 value)
void	SendObjectiveComplete (uint32 id, ObjectGuid guid=ObjectGuid::Empty)
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 *player, Creature *creature, uint32 gossipid)
virtual bool	CanTalkTo (Player *player, Creature *c, GossipMenuItems const &gso)
virtual bool	HandleDropFlag (Player *player, uint32 spellId)
virtual void	DeleteSpawns ()
void	AddGO (uint32 type, ObjectGuid::LowType guid, uint32 entry=0)
void	AddCre (uint32 type, ObjectGuid::LowType guid, uint32 entry=0)
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)
void	SetSlider (float slider)
float	GetSlider ()

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)
bool	AddCreature (uint32 type, uint32 entry, uint32 map, float x, float y, float z, float o, uint32 spawntimedelay=0)
bool	DelCreature (uint32 type)
bool	DelObject (uint32 type)
bool	DelCapturePoint ()

Protected Attributes
PlayerSet	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

Detailed Description

Constructor & Destructor Documentation

OPvPCapturePoint()

OPvPCapturePoint::OPvPCapturePoint

(

OutdoorPvP *

pvp

)

                                                 :
    m_capturePointSpawnId(0), m_capturePoint(nullptr), 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)
{ }

~OPvPCapturePoint()

virtual OPvPCapturePoint::~OPvPCapturePoint ( )

inlinevirtual

{}

Member Function Documentation

AddCre()

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

{
    if (!entry)
    {
        const CreatureData* data = sObjectMgr->GetCreatureData(guid);
        if (!data)
            return;
        entry = data->id1;
    }
    m_Creatures[type] = guid;
    m_CreatureTypes[m_Creatures[type]] = type;
}

References CreatureData::id1, m_Creatures, m_CreatureTypes, and sObjectMgr.

Referenced by AddCreature().

AddCreature()

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

protected

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

References AddCre(), and sObjectMgr.

Referenced by OPvPCapturePointZM_GraveYard::OPvPCapturePointZM_GraveYard(), OPvPCapturePointNA::SpawnNPCsForTeam(), OPvPCapturePointEP_PWT::SummonFlightMaster(), and OPvPCapturePointEP_EWT::SummonSupportUnitAtNorthpassTower().

AddGO()

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

{
    if (!entry)
    {
        const GameObjectData* data = sObjectMgr->GetGameObjectData(guid);
        if (!data)
            return;
        entry = data->id;
    }
    m_Objects[type] = guid;
    m_ObjectTypes[m_Objects[type]] = type;
}

References GameObjectData::id, m_Objects, m_ObjectTypes, and sObjectMgr.

Referenced by AddObject().

AddObject()

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, entry);
        return true;
    }
 
    return false;
}

References AddGO(), and sObjectMgr.

Referenced by OPvPCapturePointNA::HandleOpenGo(), OPvPCapturePointZM_GraveYard::HandleOpenGo(), OPvPCapturePointEP_CGT::OPvPCapturePointEP_CGT(), OPvPCapturePointEP_EWT::OPvPCapturePointEP_EWT(), OPvPCapturePointEP_NPT::OPvPCapturePointEP_NPT(), OPvPCapturePointEP_PWT::OPvPCapturePointEP_PWT(), OPvPCapturePointHP::OPvPCapturePointHP(), OPvPCapturePointZM_GraveYard::OPvPCapturePointZM_GraveYard(), OPvPCapturePointNA::SpawnGOsForTeam(), and OPvPCapturePointEP_NPT::SummonGO().

CanTalkTo()

bool OPvPCapturePoint::CanTalkTo ( Player *  player, Creature *  c, GossipMenuItems const &  gso  )

virtual

Reimplemented in OPvPCapturePointZM_GraveYard.

{
    return false;
}

ChangeState()

virtual void OPvPCapturePoint::ChangeState ( )

pure virtual

Implemented in OPvPCapturePointEP_EWT, OPvPCapturePointEP_NPT, OPvPCapturePointEP_CGT, OPvPCapturePointEP_PWT, OPvPCapturePointGH, OPvPCapturePointHP, OPvPCapturePointNA, OPvPCapturePointTF, OPvPCapturePointZM_Beacon, and OPvPCapturePointZM_GraveYard.

Referenced by Update().

ChangeTeam()

virtual void OPvPCapturePoint::ChangeTeam ( TeamId  )

inlinevirtual

{}

Referenced by Update().

DelCapturePoint()

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

References GameObject::Delete(), m_capturePoint, m_capturePointSpawnId, GameObject::SetRespawnTime(), and sObjectMgr.

Referenced by DeleteSpawns().

DelCreature()

bool OPvPCapturePoint::DelCreature ( uint32  type )

protected

{
    ObjectGuid::LowType spawnId = m_Creatures[type];
    if (!spawnId)
    {
        LOG_DEBUG("outdoorpvp", "opvp creature type {} was already deleted", type);
        return false;
    }
 
    auto bounds = m_PvP->GetMap()->GetCreatureBySpawnIdStore().equal_range(spawnId);
    for (auto itr = bounds.first; itr != bounds.second;)
    {
        // can happen when closing the core
        Creature* c = itr->second;
        ++itr;
        // Don't save respawn time
        c->SetRespawnTime(0);
        c->RemoveCorpse();
        c->AddObjectToRemoveList();
    }
    LOG_DEBUG("outdoorpvp", "deleting opvp creature type {}", 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
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CREATURE_RESPAWN);
    stmt->SetData(0, spawnId);
    stmt->SetData(1, m_PvP->GetMap()->GetId());
    stmt->SetData(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;
}

References WorldObject::AddObjectToRemoveList(), CHAR_DEL_CREATURE_RESPAWN, CharacterDatabase, Map::GetCreatureBySpawnIdStore(), Map::GetId(), OutdoorPvP::GetMap(), LOG_DEBUG, m_Creatures, m_CreatureTypes, m_PvP, Creature::RemoveCorpse(), PreparedStatementBase::SetData(), Creature::SetRespawnTime(), and sObjectMgr.

Referenced by OPvPCapturePointEP_PWT::ChangeState(), DeleteSpawns(), OPvPCapturePointNA::DeSpawnNPCs(), OPvPCapturePointEP_PWT::SummonFlightMaster(), and OPvPCapturePointEP_EWT::SummonSupportUnitAtNorthpassTower().

DeleteSpawns()

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

References DelCapturePoint(), DelCreature(), DelObject(), m_Creatures, and m_Objects.

DelObject()

bool OPvPCapturePoint::DelObject ( uint32  type )

protected

{
    ObjectGuid::LowType spawnId = m_Objects[type];
    if (!spawnId)
        return false;
 
    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;
}

References GameObject::Delete(), Map::GetGameObjectBySpawnIdStore(), OutdoorPvP::GetMap(), m_Objects, m_ObjectTypes, m_PvP, GameObject::SetRespawnTime(), and sObjectMgr.

Referenced by OPvPCapturePointEP_NPT::ChangeState(), DeleteSpawns(), OPvPCapturePointNA::DeSpawnGOs(), OPvPCapturePointNA::HandleOpenGo(), OPvPCapturePointZM_GraveYard::HandleOpenGo(), and OPvPCapturePointEP_NPT::SummonGO().

FillInitialWorldStates()

virtual void OPvPCapturePoint::FillInitialWorldStates ( WorldPacket &  )

inlinevirtual

Reimplemented in OPvPCapturePointEP_EWT, OPvPCapturePointEP_NPT, OPvPCapturePointEP_CGT, OPvPCapturePointEP_PWT, OPvPCapturePointGH, OPvPCapturePointHP, OPvPCapturePointNA, OPvPCapturePointTF, OPvPCapturePointZM_Beacon, and OPvPCapturePointZM_GraveYard.

{}

GetSlider()

float OPvPCapturePoint::GetSlider ( )

inline

    {
        return m_value;
    }

References m_value.

HandleCustomSpell()

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

virtual

Reimplemented in OPvPCapturePointNA.

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

References Player::IsOutdoorPvPActive().

HandleDropFlag()

bool OPvPCapturePoint::HandleDropFlag ( Player *  player, uint32  spellId  )

virtual

Reimplemented in OPvPCapturePointZM_GraveYard.

{
    return false;
}

HandleGossipOption()

bool OPvPCapturePoint::HandleGossipOption ( Player *  player, Creature *  creature, uint32  gossipid  )

virtual

Reimplemented in OPvPCapturePointZM_GraveYard.

{
    return false;
}

HandleOpenGo()

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

References GameObject::GetSpawnId(), and m_ObjectTypes.

Referenced by OPvPCapturePointNA::HandleOpenGo(), and OPvPCapturePointZM_GraveYard::HandleOpenGo().

HandlePlayerEnter()

bool OPvPCapturePoint::HandlePlayerEnter ( Player *  player )

virtual

Reimplemented in OPvPCapturePointEP_EWT, OPvPCapturePointEP_NPT, OPvPCapturePointEP_CGT, OPvPCapturePointEP_PWT, OPvPCapturePointGH, OPvPCapturePointHP, OPvPCapturePointNA, OPvPCapturePointTF, and OPvPCapturePointZM_Beacon.

{
    if (m_capturePoint)
    {
        player->SendUpdateWorldState(m_capturePoint->GetGOInfo()->capturePoint.worldState1, 1);
        player->SendUpdateWorldState(m_capturePoint->GetGOInfo()->capturePoint.worldstate2, (uint32)ceil((m_value + m_maxValue) / (2 * m_maxValue) * 100.0f));
        player->SendUpdateWorldState(m_capturePoint->GetGOInfo()->capturePoint.worldstate3, m_neutralValuePct);
    }
    return m_activePlayers[player->GetTeamId()].insert(player->GetGUID()).second;
}

References GameObjectTemplate::capturePoint, GameObject::GetGOInfo(), Object::GetGUID(), Player::GetTeamId(), m_activePlayers, m_capturePoint, m_maxValue, m_neutralValuePct, m_value, Player::SendUpdateWorldState(), GameObjectTemplate::worldState1, GameObjectTemplate::worldstate2, and GameObjectTemplate::worldstate3.

Referenced by OPvPCapturePointEP_EWT::HandlePlayerEnter(), OPvPCapturePointEP_NPT::HandlePlayerEnter(), OPvPCapturePointEP_CGT::HandlePlayerEnter(), OPvPCapturePointEP_PWT::HandlePlayerEnter(), OPvPCapturePointGH::HandlePlayerEnter(), OPvPCapturePointHP::HandlePlayerEnter(), OPvPCapturePointNA::HandlePlayerEnter(), OPvPCapturePointTF::HandlePlayerEnter(), OPvPCapturePointZM_Beacon::HandlePlayerEnter(), and Update().

HandlePlayerLeave()

void OPvPCapturePoint::HandlePlayerLeave ( Player *  player )

virtual

Reimplemented in OPvPCapturePointEP_EWT, OPvPCapturePointEP_NPT, OPvPCapturePointEP_CGT, OPvPCapturePointEP_PWT, OPvPCapturePointGH, OPvPCapturePointHP, OPvPCapturePointNA, OPvPCapturePointTF, and OPvPCapturePointZM_Beacon.

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

References GameObjectTemplate::capturePoint, GameObject::GetGOInfo(), Object::GetGUID(), Player::GetTeamId(), m_activePlayers, m_capturePoint, Player::SendUpdateWorldState(), and GameObjectTemplate::worldState1.

Referenced by OPvPCapturePointEP_EWT::HandlePlayerLeave(), OPvPCapturePointEP_NPT::HandlePlayerLeave(), OPvPCapturePointEP_CGT::HandlePlayerLeave(), OPvPCapturePointEP_PWT::HandlePlayerLeave(), OPvPCapturePointGH::HandlePlayerLeave(), OPvPCapturePointHP::HandlePlayerLeave(), OPvPCapturePointNA::HandlePlayerLeave(), OPvPCapturePointTF::HandlePlayerLeave(), OPvPCapturePointZM_Beacon::HandlePlayerLeave(), and Update().

IsInsideObjective()

bool OPvPCapturePoint::IsInsideObjective

(

Player *

player

)

const

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

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

SendChangePhase()

void OPvPCapturePoint::SendChangePhase ( )

virtual

Reimplemented in OPvPCapturePointEP_EWT, OPvPCapturePointEP_NPT, OPvPCapturePointEP_CGT, OPvPCapturePointEP_PWT, OPvPCapturePointGH, OPvPCapturePointHP, OPvPCapturePointNA, OPvPCapturePointTF, and OPvPCapturePointZM_Beacon.

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

References GameObjectTemplate::capturePoint, GameObject::GetGOInfo(), m_capturePoint, m_maxValue, m_neutralValuePct, m_value, SendUpdateWorldState(), GameObjectTemplate::worldState1, GameObjectTemplate::worldstate2, and GameObjectTemplate::worldstate3.

Referenced by Update().

SendObjectiveComplete()

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

{
    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 (PlayerSet::iterator itr = m_activePlayers[team].begin(); itr != m_activePlayers[team].end(); ++itr)
        if (Player* const player = ObjectAccessor::FindPlayer(*itr))
            player->KilledMonsterCredit(id, guid);
}

References ObjectAccessor::FindPlayer(), m_activePlayers, m_State, OBJECTIVESTATE_ALLIANCE, and OBJECTIVESTATE_HORDE.

Referenced by OPvPCapturePointEP_EWT::ChangeState(), OPvPCapturePointEP_NPT::ChangeState(), OPvPCapturePointEP_CGT::ChangeState(), OPvPCapturePointEP_PWT::ChangeState(), and OPvPCapturePointHP::ChangeState().

SendUpdateWorldState()

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

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

References ObjectAccessor::FindPlayer(), and m_activePlayers.

Referenced by SendChangePhase(), OPvPCapturePointEP_EWT::SendChangePhase(), OPvPCapturePointEP_NPT::SendChangePhase(), OPvPCapturePointEP_CGT::SendChangePhase(), OPvPCapturePointEP_PWT::SendChangePhase(), OPvPCapturePointGH::SendChangePhase(), OPvPCapturePointHP::SendChangePhase(), OPvPCapturePointNA::SendChangePhase(), OPvPCapturePointTF::SendChangePhase(), and OPvPCapturePointZM_Beacon::SendChangePhase().

SetCapturePointData()

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
	)

{
    LOG_DEBUG("outdoorpvp", "Creating capture point {}", entry);
 
    // check info existence
    GameObjectTemplate const* goinfo = sObjectMgr->GetGameObjectTemplate(entry);
    if (!goinfo || goinfo->type != GAMEOBJECT_TYPE_CAPTURE_POINT)
    {
        LOG_ERROR("outdoorpvp", "OutdoorPvP: GO {} 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->capturePoint.maxTime;
    m_maxSpeed = m_maxValue / (goinfo->capturePoint.minTime ? goinfo->capturePoint.minTime : 60);
    m_neutralValuePct = goinfo->capturePoint.neutralPercent;
    m_minValue = CalculatePct(m_maxValue, m_neutralValuePct);
    return true;
}

References CalculatePct(), GameObjectTemplate::capturePoint, GAMEOBJECT_TYPE_CAPTURE_POINT, LOG_DEBUG, LOG_ERROR, m_capturePointSpawnId, m_maxSpeed, m_maxValue, m_minValue, m_neutralValuePct, GameObjectTemplate::maxTime, GameObjectTemplate::minTime, GameObjectTemplate::neutralPercent, sObjectMgr, and GameObjectTemplate::type.

Referenced by OPvPCapturePointEP_CGT::OPvPCapturePointEP_CGT(), OPvPCapturePointEP_EWT::OPvPCapturePointEP_EWT(), OPvPCapturePointEP_NPT::OPvPCapturePointEP_NPT(), OPvPCapturePointEP_PWT::OPvPCapturePointEP_PWT(), OPvPCapturePointGH::OPvPCapturePointGH(), OPvPCapturePointHP::OPvPCapturePointHP(), OPvPCapturePointNA::OPvPCapturePointNA(), OPvPCapturePointTF::OPvPCapturePointTF(), and OPvPCapturePointZM_Beacon::OPvPCapturePointZM_Beacon().

SetSlider()

void OPvPCapturePoint::SetSlider ( float  slider )

inline

    {
        m_value = std::clamp<float>(slider, -m_maxValue, m_maxValue);
    }

References m_maxValue, and m_value.

Update()

bool OPvPCapturePoint::Update ( uint32  diff )

virtual

Reimplemented in OPvPCapturePointNA, OPvPCapturePointTF, and OPvPCapturePointZM_GraveYard.

{
    if (!m_capturePoint)
        return false;
 
    float radius = (float)m_capturePoint->GetGOInfo()->capturePoint.radius;
 
    for (uint32 team = 0; team < 2; ++team)
    {
        for (PlayerSet::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;
    Acore::AnyPlayerInObjectRangeCheck checker(m_capturePoint, radius);
    Acore::PlayerListSearcher<Acore::AnyPlayerInObjectRangeCheck> searcher(m_capturePoint, players, checker);
    Cell::VisitWorldObjects(m_capturePoint, searcher, radius);
 
    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;
 
    TeamId ChallengerId = TEAM_NEUTRAL;
    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;
 
        ChallengerId = TEAM_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;
 
        ChallengerId = TEAM_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 (ChallengerId == TEAM_ALLIANCE)
            m_State = OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE;
        // if challenger is horde, then n->h challenge
        else if (ChallengerId == TEAM_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 (ChallengerId == TEAM_ALLIANCE && (m_OldState == OBJECTIVESTATE_HORDE || m_OldState == OBJECTIVESTATE_NEUTRAL_HORDE_CHALLENGE))
            m_State = OBJECTIVESTATE_HORDE_ALLIANCE_CHALLENGE;
        else if (ChallengerId == TEAM_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)
    {
        if (oldTeam != m_team)
        {
            ChangeTeam(oldTeam);
        }
 
        ChangeState();
        return true;
    }
 
    return false;
}

References GameObjectTemplate::capturePoint, ChangeState(), ChangeTeam(), ObjectAccessor::FindPlayer(), GameObject::GetGOInfo(), Object::GetGUID(), Player::GetTeamId(), HandlePlayerEnter(), HandlePlayerLeave(), Player::IsOutdoorPvPActive(), GameObject::IsWithinDistInMap(), m_activePlayers, m_capturePoint, m_maxSpeed, m_maxValue, m_minValue, m_OldState, m_State, m_team, m_value, OBJECTIVESTATE_ALLIANCE, OBJECTIVESTATE_ALLIANCE_HORDE_CHALLENGE, OBJECTIVESTATE_HORDE, OBJECTIVESTATE_HORDE_ALLIANCE_CHALLENGE, OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE, OBJECTIVESTATE_NEUTRAL_HORDE_CHALLENGE, OUTDOORPVP_OBJECTIVE_UPDATE_INTERVAL, GameObjectTemplate::radius, SendChangePhase(), TEAM_ALLIANCE, TEAM_HORDE, TEAM_NEUTRAL, and Cell::VisitWorldObjects().

Referenced by OPvPCapturePointNA::Update(), and OPvPCapturePointTF::Update().

Member Data Documentation

m_activePlayers

PlayerSet OPvPCapturePoint::m_activePlayers[2]

protected

Referenced by OPvPCapturePointTF::ChangeState(), HandlePlayerEnter(), HandlePlayerLeave(), IsInsideObjective(), SendObjectiveComplete(), SendUpdateWorldState(), Update(), OPvPCapturePointNA::Update(), and OPvPCapturePointTF::Update().

m_capturePoint

GameObject* OPvPCapturePoint::m_capturePoint

Referenced by DelCapturePoint(), HandlePlayerEnter(), HandlePlayerLeave(), SendChangePhase(), and Update().

m_capturePointSpawnId

ObjectGuid::LowType OPvPCapturePoint::m_capturePointSpawnId

Referenced by OutdoorPvP::AddCapturePoint(), OPvPCapturePointEP_EWT::ChangeState(), OPvPCapturePointEP_NPT::ChangeState(), OPvPCapturePointEP_CGT::ChangeState(), OPvPCapturePointEP_PWT::ChangeState(), OPvPCapturePointGH::ChangeState(), OPvPCapturePointHP::ChangeState(), OPvPCapturePointNA::ChangeState(), OPvPCapturePointTF::ChangeState(), DelCapturePoint(), and SetCapturePointData().

m_Creatures

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

protected

Referenced by AddCre(), DelCreature(), DeleteSpawns(), and OPvPCapturePointNA::GetAliveGuardsCount().

m_CreatureTypes

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

protected

Referenced by AddCre(), OPvPCapturePointZM_GraveYard::CanTalkTo(), DelCreature(), and OPvPCapturePointZM_GraveYard::HandleGossipOption().

m_maxSpeed

float OPvPCapturePoint::m_maxSpeed

protected

Referenced by SetCapturePointData(), and Update().

m_maxValue

float OPvPCapturePoint::m_maxValue

protected

Referenced by HandlePlayerEnter(), OPvPCapturePointEP_EWT::HandlePlayerEnter(), OPvPCapturePointEP_NPT::HandlePlayerEnter(), OPvPCapturePointEP_CGT::HandlePlayerEnter(), OPvPCapturePointEP_PWT::HandlePlayerEnter(), OPvPCapturePointGH::HandlePlayerEnter(), OPvPCapturePointHP::HandlePlayerEnter(), OPvPCapturePointNA::HandlePlayerEnter(), OPvPCapturePointTF::HandlePlayerEnter(), OPvPCapturePointZM_Beacon::HandlePlayerEnter(), SendChangePhase(), OPvPCapturePointEP_EWT::SendChangePhase(), OPvPCapturePointEP_NPT::SendChangePhase(), OPvPCapturePointEP_CGT::SendChangePhase(), OPvPCapturePointEP_PWT::SendChangePhase(), OPvPCapturePointGH::SendChangePhase(), OPvPCapturePointHP::SendChangePhase(), OPvPCapturePointNA::SendChangePhase(), OPvPCapturePointTF::SendChangePhase(), OPvPCapturePointZM_Beacon::SendChangePhase(), SetCapturePointData(), SetSlider(), and Update().

m_minValue

float OPvPCapturePoint::m_minValue

protected

Referenced by SetCapturePointData(), and Update().

m_neutralValuePct

uint32 OPvPCapturePoint::m_neutralValuePct

protected

Referenced by HandlePlayerEnter(), OPvPCapturePointEP_EWT::HandlePlayerEnter(), OPvPCapturePointEP_NPT::HandlePlayerEnter(), OPvPCapturePointEP_CGT::HandlePlayerEnter(), OPvPCapturePointEP_PWT::HandlePlayerEnter(), OPvPCapturePointGH::HandlePlayerEnter(), OPvPCapturePointHP::HandlePlayerEnter(), OPvPCapturePointNA::HandlePlayerEnter(), OPvPCapturePointTF::HandlePlayerEnter(), OPvPCapturePointZM_Beacon::HandlePlayerEnter(), SendChangePhase(), OPvPCapturePointEP_EWT::SendChangePhase(), OPvPCapturePointEP_NPT::SendChangePhase(), OPvPCapturePointEP_CGT::SendChangePhase(), OPvPCapturePointEP_PWT::SendChangePhase(), OPvPCapturePointGH::SendChangePhase(), OPvPCapturePointHP::SendChangePhase(), OPvPCapturePointNA::SendChangePhase(), OPvPCapturePointTF::SendChangePhase(), OPvPCapturePointZM_Beacon::SendChangePhase(), and SetCapturePointData().

m_Objects

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

protected

Referenced by AddGO(), OPvPCapturePointEP_EWT::ChangeState(), OPvPCapturePointEP_NPT::ChangeState(), OPvPCapturePointEP_CGT::ChangeState(), OPvPCapturePointEP_PWT::ChangeState(), OPvPCapturePointHP::ChangeState(), DeleteSpawns(), DelObject(), and OPvPCapturePointEP_NPT::SummonGO().

m_ObjectTypes

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

protected

Referenced by AddGO(), DelObject(), and HandleOpenGo().

m_OldState

ObjectiveStates OPvPCapturePoint::m_OldState

protected

Referenced by OPvPCapturePointEP_EWT::ChangeState(), OPvPCapturePointEP_NPT::ChangeState(), OPvPCapturePointEP_CGT::ChangeState(), OPvPCapturePointEP_PWT::ChangeState(), OPvPCapturePointHP::ChangeState(), OPvPCapturePointTF::ChangeState(), OPvPCapturePointZM_Beacon::ChangeState(), OPvPCapturePointTF::ResetToTeamControlled(), Update(), and OPvPCapturePointZM_GraveYard::Update().

m_PvP

OutdoorPvP* OPvPCapturePoint::m_PvP

protected

Referenced by OPvPCapturePointEP_EWT::ChangeState(), OPvPCapturePointEP_NPT::ChangeState(), OPvPCapturePointEP_CGT::ChangeState(), OPvPCapturePointEP_PWT::ChangeState(), OPvPCapturePointHP::ChangeState(), OPvPCapturePointTF::ChangeState(), OPvPCapturePointZM_Beacon::ChangeState(), DelCreature(), DelObject(), OPvPCapturePointNA::FactionTakeOver(), OPvPCapturePointNA::GetAliveGuardsCount(), OPvPCapturePointZM_GraveYard::HandleOpenGo(), OPvPCapturePointNA::Update(), OPvPCapturePointTF::Update(), OPvPCapturePointNA::UpdateHalaaWorldState(), OPvPCapturePointEP_EWT::UpdateTowerState(), OPvPCapturePointEP_NPT::UpdateTowerState(), OPvPCapturePointEP_CGT::UpdateTowerState(), OPvPCapturePointEP_PWT::UpdateTowerState(), OPvPCapturePointTF::UpdateTowerState(), OPvPCapturePointZM_Beacon::UpdateTowerState(), OPvPCapturePointZM_GraveYard::UpdateTowerState(), and OPvPCapturePointNA::UpdateWyvernRoostWorldState().

m_State

ObjectiveStates OPvPCapturePoint::m_State

protected

Referenced by OPvPCapturePointEP_EWT::ChangeState(), OPvPCapturePointEP_NPT::ChangeState(), OPvPCapturePointEP_CGT::ChangeState(), OPvPCapturePointEP_PWT::ChangeState(), OPvPCapturePointGH::ChangeState(), OPvPCapturePointHP::ChangeState(), OPvPCapturePointNA::ChangeState(), OPvPCapturePointTF::ChangeState(), OPvPCapturePointZM_Beacon::ChangeState(), OPvPCapturePointHP::FillInitialWorldStates(), OPvPCapturePointTF::ResetToTeamControlled(), SendObjectiveComplete(), Update(), and OPvPCapturePointZM_GraveYard::Update().

m_team

TeamId OPvPCapturePoint::m_team

protected

Referenced by OPvPCapturePointTF::ResetToTeamControlled(), and Update().

m_value

float OPvPCapturePoint::m_value

protected

Referenced by GetSlider(), HandlePlayerEnter(), OPvPCapturePointEP_EWT::HandlePlayerEnter(), OPvPCapturePointEP_NPT::HandlePlayerEnter(), OPvPCapturePointEP_CGT::HandlePlayerEnter(), OPvPCapturePointEP_PWT::HandlePlayerEnter(), OPvPCapturePointGH::HandlePlayerEnter(), OPvPCapturePointHP::HandlePlayerEnter(), OPvPCapturePointNA::HandlePlayerEnter(), OPvPCapturePointTF::HandlePlayerEnter(), OPvPCapturePointZM_Beacon::HandlePlayerEnter(), OPvPCapturePointTF::ResetToTeamControlled(), SendChangePhase(), OPvPCapturePointEP_EWT::SendChangePhase(), OPvPCapturePointEP_NPT::SendChangePhase(), OPvPCapturePointEP_CGT::SendChangePhase(), OPvPCapturePointEP_PWT::SendChangePhase(), OPvPCapturePointGH::SendChangePhase(), OPvPCapturePointHP::SendChangePhase(), OPvPCapturePointNA::SendChangePhase(), OPvPCapturePointTF::SendChangePhase(), OPvPCapturePointZM_Beacon::SendChangePhase(), SetSlider(), and Update().