OPvPCapturePoint Class Reference

#include "OutdoorPvP.h"

Inheritance diagram for OPvPCapturePoint:

Public Member Functions
	OPvPCapturePoint (OutdoorPvP *pvp)
virtual	~OPvPCapturePoint ()=default
virtual void	FillInitialWorldStates (WorldPackets::WorldState::InitWorldStates &)
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 () const

Public Attributes
ObjectGuid::LowType	m_capturePointSpawnId {}
GameObject *	_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
std::array< PlayerSet, 2 >	_activePlayers
float	_maxValue {}
float	_minValue {}
float	_maxSpeed {}
float	_value {}
TeamId	_team { TEAM_NEUTRAL }
ObjectiveStates	_oldState { OBJECTIVESTATE_NEUTRAL }
ObjectiveStates	_state { OBJECTIVESTATE_NEUTRAL }
uint32	_neutralValuePct {}
OutdoorPvP *	_pvp {}
std::unordered_map< uint32, ObjectGuid::LowType >	_objects
std::unordered_map< uint32, ObjectGuid::LowType >	_creatures
std::unordered_map< ObjectGuid::LowType, uint32 >	_objectTypes
std::unordered_map< ObjectGuid::LowType, uint32 >	_creatureTypes

Detailed Description

Constructor & Destructor Documentation

OPvPCapturePoint()

OPvPCapturePoint::OPvPCapturePoint ( OutdoorPvP *  pvp )

explicit

                                                  :
    _pvp(pvp)
{
}

~OPvPCapturePoint()

virtual OPvPCapturePoint::~OPvPCapturePoint ( )

virtualdefault

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;
    }
 
    _creatures[type] = guid;
    _creatureTypes[_creatures[type]] = type;
}

References _creatures, _creatureTypes, CreatureData::id1, 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(), 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;
    }
 
    _objects[type] = guid;
    _objectTypes[_objects[type]] = type;
}

References _objects, _objectTypes, GameObjectData::id, 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(), and OPvPCapturePointNA::Update().

DelCapturePoint()

bool OPvPCapturePoint::DelCapturePoint ( )

protected

{
    sObjectMgr->DeleteGOData(m_capturePointSpawnId);
    m_capturePointSpawnId = 0;
 
    if (_capturePoint)
    {
        _capturePoint->SetRespawnTime(0);                                 // not save respawn time
        _capturePoint->Delete();
    }
 
    return true;
}

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

Referenced by DeleteSpawns().

DelCreature()

bool OPvPCapturePoint::DelCreature ( uint32  type )

protected

{
    ObjectGuid::LowType spawnId = _creatures[type];
    if (!spawnId)
    {
        LOG_DEBUG("outdoorpvp", "OutdoorPvP: Creature type {} was already deleted", type);
        return false;
    }
 
    auto bounds = _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", "OutdoorPvP: Deleting 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, _pvp->GetMap()->GetId());
    stmt->SetData(2, 0);  // instance id, always 0 for world maps
    CharacterDatabase.Execute(stmt);
 
    sObjectMgr->DeleteCreatureData(spawnId);
    _creatureTypes[_creatures[type]] = 0;
    _creatures[type] = 0;
    return true;
}

References _creatures, _creatureTypes, _pvp, WorldObject::AddObjectToRemoveList(), CHAR_DEL_CREATURE_RESPAWN, CharacterDatabase, Map::GetCreatureBySpawnIdStore(), Map::GetId(), OutdoorPvP::GetMap(), LOG_DEBUG, Creature::RemoveCorpse(), PreparedStatementBase::SetData(), Creature::SetRespawnTime(), and sObjectMgr.

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

DeleteSpawns()

void OPvPCapturePoint::DeleteSpawns ( )

virtual

{
    for (auto const& [type, guid] : _objects)
    {
        DelObject(type);
    }
 
    for (auto const& [type, guid] : _creatures)
    {
        DelCreature(type);
    }
 
    DelCapturePoint();
}

References _creatures, _objects, DelCapturePoint(), DelCreature(), and DelObject().

DelObject()

bool OPvPCapturePoint::DelObject ( uint32  type )

protected

{
    ObjectGuid::LowType spawnId = _objects[type];
    if (!spawnId)
        return false;
 
    auto bounds = _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);
    _objectTypes[_objects[type]] = 0;
    _objects[type] = 0;
    return true;
}

References _objects, _objectTypes, _pvp, GameObject::Delete(), Map::GetGameObjectBySpawnIdStore(), OutdoorPvP::GetMap(), 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 ( WorldPackets::WorldState::InitWorldStates &  )

inlinevirtual

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

{ }

GetSlider()

float OPvPCapturePoint::GetSlider ( ) const

inline

    {
        return _value;
    }

References _value.

HandleCustomSpell()

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

virtual

Reimplemented in OPvPCapturePointNA.

{
    return false;
}

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.

{
    auto const itr = _objectTypes.find(go->GetSpawnId());
    if (itr != _objectTypes.end())
    {
        return (int32)itr->second;
    }
 
    return -1;
}

References _objectTypes, and GameObject::GetSpawnId().

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 (_capturePoint)
    {
        player->SendUpdateWorldState(_capturePoint->GetGOInfo()->capturePoint.worldState1, 1);
        player->SendUpdateWorldState(_capturePoint->GetGOInfo()->capturePoint.worldstate2, (uint32)std::ceil((_value + _maxValue) / (2 * _maxValue) * 100.0f));
        player->SendUpdateWorldState(_capturePoint->GetGOInfo()->capturePoint.worldstate3, _neutralValuePct);
    }
 
    return _activePlayers[player->GetTeamId()].insert(player->GetGUID()).second;
}

References _activePlayers, _capturePoint, _maxValue, _neutralValuePct, _value, GameObjectTemplate::capturePoint, GameObject::GetGOInfo(), Object::GetGUID(), Player::GetTeamId(), 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 (_capturePoint)
    {
        player->SendUpdateWorldState(_capturePoint->GetGOInfo()->capturePoint.worldState1, 0);
    }
 
    _activePlayers[player->GetTeamId()].erase(player->GetGUID());
}

References _activePlayers, _capturePoint, GameObjectTemplate::capturePoint, GameObject::GetGOInfo(), Object::GetGUID(), Player::GetTeamId(), 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 = _activePlayers[player->GetTeamId()];
    return plSet.find(player->GetGUID()) != plSet.end();
}

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

SendChangePhase()

void OPvPCapturePoint::SendChangePhase ( )

virtual

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

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

References _capturePoint, _maxValue, _neutralValuePct, _value, GameObjectTemplate::capturePoint, GameObject::GetGOInfo(), SendUpdateWorldState(), GameObjectTemplate::worldState1, GameObjectTemplate::worldstate2, and GameObjectTemplate::worldstate3.

Referenced by Update().

SendObjectiveComplete()

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

{
    uint32 team;
    switch (_state)
    {
        case OBJECTIVESTATE_ALLIANCE:
            team = 0;
            break;
        case OBJECTIVESTATE_HORDE:
            team = 1;
            break;
        default:
            return;
    }
 
    // send to all players present in the area
    for (auto itr : _activePlayers[team])
        if (Player* const player = ObjectAccessor::FindPlayer(itr))
            player->KilledMonsterCredit(id, guid);
}

References _activePlayers, _state, ObjectAccessor::FindPlayer(), 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 (auto const& activePlayer : _activePlayers)
    {
        // send to all players present in the area
        for (auto itr : activePlayer)
            if (Player* const player = ObjectAccessor::FindPlayer(itr))
                player->SendUpdateWorldState(field, value);
    }
}

References _activePlayers, and ObjectAccessor::FindPlayer().

Referenced by 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 OPvPCapturePointNA::Update().

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
    _maxValue = (float)goinfo->capturePoint.maxTime;
    _maxSpeed = _maxValue / float(goinfo->capturePoint.minTime ? goinfo->capturePoint.minTime : 60);
    _neutralValuePct = goinfo->capturePoint.neutralPercent;
    _minValue = CalculatePct(_maxValue, _neutralValuePct);
    return true;
}

References _maxSpeed, _maxValue, _minValue, _neutralValuePct, CalculatePct(), GameObjectTemplate::capturePoint, GAMEOBJECT_TYPE_CAPTURE_POINT, LOG_DEBUG, LOG_ERROR, m_capturePointSpawnId, 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

)

{
    _value = std::clamp<float>(slider, -_maxValue, _maxValue);
}

References _maxValue, and _value.

Update()

bool OPvPCapturePoint::Update ( uint32  diff )

virtual

Reimplemented in OPvPCapturePointNA, OPvPCapturePointTF, and OPvPCapturePointZM_Graveyard.

{
    if (!_capturePoint)
        return false;
 
    auto radius = (float)_capturePoint->GetGOInfo()->capturePoint.radius;
 
    for (auto const& activePlayer : _activePlayers)
    {
        for (auto itr = activePlayer.begin(); itr != activePlayer.end();)
        {
            ObjectGuid playerGuid = *itr;
            ++itr;
 
            if (Player* player = ObjectAccessor::FindPlayer(playerGuid))
                if (!_capturePoint->IsWithinDistInMap(player, radius) || !player->IsOutdoorPvPActive())
                    HandlePlayerLeave(player);
        }
    }
 
    std::list<Player*> players;
    Acore::AnyPlayerInObjectRangeCheck checker(_capturePoint, radius);
    Acore::PlayerListSearcher<Acore::AnyPlayerInObjectRangeCheck> searcher(_capturePoint, players, checker);
    Cell::VisitObjects(_capturePoint, searcher, radius);
 
    for (auto& itr : players)
    {
        Player* const player = itr;
        if (player->IsOutdoorPvPActive())
        {
            if (_activePlayers[player->GetTeamId()].insert(player->GetGUID()).second)
                HandlePlayerEnter(itr);
        }
    }
 
    // get the difference of numbers
    float factDiff = (((float)_activePlayers[0].size() - (float)_activePlayers[1].size()) * float(diff) / OUTDOORPVP_OBJECTIVE_UPDATE_INTERVAL) * sWorld->getFloatConfig(CONFIG_OUTDOOR_PVP_CAPTURE_RATE);
    if (factDiff == 0.f)
        return false;
 
    TeamId ChallengerId = TEAM_NEUTRAL;
    float maxDiff = (_maxSpeed * float(diff)) * sWorld->getFloatConfig(CONFIG_OUTDOOR_PVP_CAPTURE_RATE);
 
    if (factDiff < 0.f)
    {
        // horde is in majority, but it's already horde-controlled -> no change
        if (_state == OBJECTIVESTATE_HORDE && _value <= -_maxValue)
            return false;
 
        if (factDiff < -maxDiff)
            factDiff = -maxDiff;
 
        ChallengerId = TEAM_HORDE;
    }
    else
    {
        // ally is in majority, but it's already ally-controlled -> no change
        if (_state == OBJECTIVESTATE_ALLIANCE && _value >= _maxValue)
            return false;
 
        if (factDiff > maxDiff)
            factDiff = maxDiff;
 
        ChallengerId = TEAM_ALLIANCE;
    }
 
    float oldValue = _value;
    TeamId oldTeam = _team;
 
    _oldState = _state;
    _value += factDiff;
 
    if (_value < -_minValue) // red
    {
        if (_value < -_maxValue)
        {
            _value = -_maxValue;
        }
 
        _state = OBJECTIVESTATE_HORDE;
        _team = TEAM_HORDE;
    }
    else if (_value > _minValue) // blue
    {
        if (_value > _maxValue)
        {
            _value = _maxValue;
        }
 
        _state = OBJECTIVESTATE_ALLIANCE;
        _team = TEAM_ALLIANCE;
    }
    else if (oldValue * _value <= 0) // grey, go through mid-point
    {
        // if challenger is ally, then n->a challenge
        if (ChallengerId == TEAM_ALLIANCE)
        {
            _state = OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE;
        }
        else if (ChallengerId == TEAM_HORDE) // if challenger is horde, then n->h challenge
        {
            _state = OBJECTIVESTATE_NEUTRAL_HORDE_CHALLENGE;
        }
 
        _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 && (_oldState == OBJECTIVESTATE_HORDE || _oldState == OBJECTIVESTATE_NEUTRAL_HORDE_CHALLENGE))
        {
            _state = OBJECTIVESTATE_HORDE_ALLIANCE_CHALLENGE;
        }
        else if (ChallengerId == TEAM_HORDE && (_oldState == OBJECTIVESTATE_ALLIANCE || _oldState == OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE))
        {
            _state = OBJECTIVESTATE_ALLIANCE_HORDE_CHALLENGE;
        }
 
        _team = TEAM_NEUTRAL;
    }
 
    if (_value != oldValue)
    {
        SendChangePhase();
    }
 
    if (_oldState != _state)
    {
        if (oldTeam != _team)
        {
            ChangeTeam(oldTeam);
        }
 
        ChangeState();
        return true;
    }
 
    return false;
}

References _activePlayers, _capturePoint, _maxSpeed, _maxValue, _minValue, _oldState, _state, _team, _value, GameObjectTemplate::capturePoint, ChangeState(), ChangeTeam(), CONFIG_OUTDOOR_PVP_CAPTURE_RATE, ObjectAccessor::FindPlayer(), GameObject::GetGOInfo(), Object::GetGUID(), Player::GetTeamId(), HandlePlayerEnter(), HandlePlayerLeave(), Player::IsOutdoorPvPActive(), GameObject::IsWithinDistInMap(), 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(), sWorld, TEAM_ALLIANCE, TEAM_HORDE, TEAM_NEUTRAL, and Cell::VisitObjects().

Referenced by OPvPCapturePointTF::Update().

Member Data Documentation

_activePlayers

std::array<PlayerSet, 2> OPvPCapturePoint::_activePlayers

protected

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

_capturePoint

GameObject* OPvPCapturePoint::_capturePoint {}

{};

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

_creatures

std::unordered_map<uint32, ObjectGuid::LowType> OPvPCapturePoint::_creatures

protected

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

_creatureTypes

std::unordered_map<ObjectGuid::LowType, uint32> OPvPCapturePoint::_creatureTypes

protected

Referenced by AddCre(), OPvPCapturePointZM_Graveyard::CanTalkTo(), DelCreature(), OPvPCapturePointNA::DespawnCreatures(), OPvPCapturePointZM_Graveyard::HandleGossipOption(), and OPvPCapturePointNA::SpawnNPCsForTeam().

_maxSpeed

float OPvPCapturePoint::_maxSpeed {}

protected

{};

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

_maxValue

float OPvPCapturePoint::_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(), Update(), and OPvPCapturePointNA::Update().

_minValue

float OPvPCapturePoint::_minValue {}

protected

{};

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

_neutralValuePct

uint32 OPvPCapturePoint::_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().

_objects

std::unordered_map<uint32, ObjectGuid::LowType> OPvPCapturePoint::_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().

_objectTypes

std::unordered_map<ObjectGuid::LowType, uint32> OPvPCapturePoint::_objectTypes

protected

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

_oldState

ObjectiveStates OPvPCapturePoint::_oldState { OBJECTIVESTATE_NEUTRAL }

protected

{ OBJECTIVESTATE_NEUTRAL };

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

_pvp

OutdoorPvP* OPvPCapturePoint::_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::DespawnCreatures(), OPvPCapturePointNA::FactionTakeOver(), OPvPCapturePointNA::GetAliveGuardsCount(), OPvPCapturePointZM_Graveyard::HandleOpenGo(), OPvPCapturePointNA::SpawnNPCsForTeam(), 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().

_state

ObjectiveStates OPvPCapturePoint::_state { OBJECTIVESTATE_NEUTRAL }

protected

{ OBJECTIVESTATE_NEUTRAL };

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(), OPvPCapturePointNA::Update(), and OPvPCapturePointZM_Graveyard::Update().

_team

TeamId OPvPCapturePoint::_team { TEAM_NEUTRAL }

protected

{ TEAM_NEUTRAL };

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

_value

float OPvPCapturePoint::_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(), Update(), and OPvPCapturePointNA::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().

---

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

• azerothcore-wotlk/src/server/game/OutdoorPvP/OutdoorPvP.h
• azerothcore-wotlk/src/server/game/OutdoorPvP/OutdoorPvP.cpp