BfCapturePoint Class Reference

#include "Battlefield.h"

Inheritance diagram for BfCapturePoint:

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 GuidUnorderedSet::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, TeamId team)
GameObject *	GetCapturePointGo ()
GameObject *	GetCapturePointGo (WorldObject *obj)
TeamId	GetTeamId () const

Protected Member Functions
bool	DelCapturePoint ()

Protected Attributes
GuidUnorderedSet	ActivePlayers
float	MaxValue
float	MinValue
float	MaxSpeed
float	Value
TeamId	Team
BattlefieldObjectiveStates	OldState
BattlefieldObjectiveStates	State
uint32	NeutralValuePct
Battlefield *	Bf
uint32	CapturePointEntry
ObjectGuid	CapturePoint

Detailed Description

Constructor & Destructor Documentation

BfCapturePoint()

BfCapturePoint::BfCapturePoint

(

Battlefield *

bf

)

                                              :
    MaxValue(0.0f),
    MinValue(0.0f),
    MaxSpeed(0),
    Value(0),
    Team(TEAM_NEUTRAL),
    OldState(BF_CAPTUREPOINT_OBJECTIVESTATE_NEUTRAL),
    State(BF_CAPTUREPOINT_OBJECTIVESTATE_NEUTRAL),
    NeutralValuePct(0),
    Bf(bf),
    CapturePointEntry(0)
{
}

~BfCapturePoint()

virtual BfCapturePoint::~BfCapturePoint ( )

inlinevirtual

{ }

Member Function Documentation

ChangeTeam()

virtual void BfCapturePoint::ChangeTeam ( TeamId  )

inlinevirtual

Reimplemented in WintergraspCapturePoint.

{}

Referenced by Update().

DelCapturePoint()

bool BfCapturePoint::DelCapturePoint ( )

protected

{
    if (GameObject* capturePoint = GetCapturePointGo())
    {
        capturePoint->SetRespawnTime(0);                  // not save respawn time
        capturePoint->Delete();
        CapturePoint.Clear();
    }
 
    return true;
}

References CapturePoint, ObjectGuid::Clear(), and GetCapturePointGo().

FillInitialWorldStates()

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

inlinevirtual

{ }

GetCapturePointGo() [1/2]

GameObject * BfCapturePoint::GetCapturePointGo

(

)

{
    return Bf->GetGameObject(CapturePoint);
}

References Bf, CapturePoint, and Battlefield::GetGameObject().

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

GetCapturePointGo() [2/2]

GameObject * BfCapturePoint::GetCapturePointGo

(

WorldObject *

obj

)

{
    return ObjectAccessor::GetGameObject(*obj, CapturePoint);
}

References CapturePoint, and ObjectAccessor::GetGameObject().

GetTeamId()

TeamId BfCapturePoint::GetTeamId ( ) const

inline

{ return Team; }

References Team.

HandlePlayerEnter()

bool BfCapturePoint::HandlePlayerEnter ( Player *  player )

virtual

{
    if (GameObject* go = GetCapturePointGo(player))
    {
        player->SendUpdateWorldState(go->GetGOInfo()->capturePoint.worldState1, 1);
        player->SendUpdateWorldState(go->GetGOInfo()->capturePoint.worldstate2, uint32(std::ceil((Value + MaxValue) / (2 * MaxValue) * 100.0f)));
        player->SendUpdateWorldState(go->GetGOInfo()->capturePoint.worldstate3, NeutralValuePct);
    }
    return ActivePlayers.insert(player->GetGUID()).second;
}

References ActivePlayers, GetCapturePointGo(), Object::GetGUID(), MaxValue, NeutralValuePct, Player::SendUpdateWorldState(), and Value.

Referenced by Update().

HandlePlayerLeave()

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

virtual

{
    if (GameObject* go = GetCapturePointGo(player))
        player->SendUpdateWorldState(go->GetGOInfo()->capturePoint.worldState1, 0);
 
    GuidUnorderedSet::iterator current = ActivePlayers.find(player->GetGUID());
 
    if (current == ActivePlayers.end())
        return current; // return end()
 
    return ActivePlayers.erase(current);
}

References ActivePlayers, GetCapturePointGo(), Object::GetGUID(), and Player::SendUpdateWorldState().

Referenced by Update().

IsInsideObjective()

bool BfCapturePoint::IsInsideObjective

(

Player *

player

)

const

{
    return ActivePlayers.find(player->GetGUID()) != ActivePlayers.end();
}

References ActivePlayers, and Object::GetGUID().

SendChangePhase()

void BfCapturePoint::SendChangePhase ( )

virtual

{
    GameObject* capturePoint = GetCapturePointGo();
    if (!capturePoint)
        return;
 
    for (ObjectGuid const& guid : ActivePlayers)  // send to all players present in the area
        if (Player* player = ObjectAccessor::FindPlayer(guid))
        {
            // send this too, sometimes the slider disappears, dunno why :(
            player->SendUpdateWorldState(capturePoint->GetGOInfo()->capturePoint.worldState1, 1);
            // send these updates to only the ones in this objective
            player->SendUpdateWorldState(capturePoint->GetGOInfo()->capturePoint.worldstate2, (uint32) std::ceil((Value + MaxValue) / (2 * MaxValue) * 100.0f));
            // send this too, sometimes it resets :S
            player->SendUpdateWorldState(capturePoint->GetGOInfo()->capturePoint.worldstate3, NeutralValuePct);
        }
}

References ActivePlayers, GameObjectTemplate::capturePoint, ObjectAccessor::FindPlayer(), GetCapturePointGo(), GameObject::GetGOInfo(), MaxValue, NeutralValuePct, Value, GameObjectTemplate::worldState1, GameObjectTemplate::worldstate2, and GameObjectTemplate::worldstate3.

Referenced by Update().

SendObjectiveComplete()

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

{
    TeamId winner;
    switch (State)
    {
        case BF_CAPTUREPOINT_OBJECTIVESTATE_ALLIANCE:
            winner = TEAM_ALLIANCE;
            break;
        case BF_CAPTUREPOINT_OBJECTIVESTATE_HORDE:
            winner = TEAM_HORDE;
            break;
        default:
            return;
    }
 
    // Credit only players on the controlling team. Team is read from the
    // player at iteration time, not at insert time, so players whose
    // GetTeamId() changed mid-stay get credit on their current side.
    for (ObjectGuid const& playerGuid : ActivePlayers)
        if (Player* player = ObjectAccessor::FindPlayer(playerGuid))
            if (player->GetTeamId() == winner)
                player->KilledMonsterCredit(id, guid);
}

References ActivePlayers, BF_CAPTUREPOINT_OBJECTIVESTATE_ALLIANCE, BF_CAPTUREPOINT_OBJECTIVESTATE_HORDE, ObjectAccessor::FindPlayer(), State, TEAM_ALLIANCE, and TEAM_HORDE.

SendUpdateWorldState()

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

{
    for (ObjectGuid const& guid : ActivePlayers)  // send to all players present in the area
        if (Player* player = ObjectAccessor::FindPlayer(guid))
            player->SendUpdateWorldState(field, value);
}

References ActivePlayers, and ObjectAccessor::FindPlayer().

SetCapturePointData()

bool BfCapturePoint::SetCapturePointData	(	GameObject *	capturePoint,
		TeamId	team
	)

{
    ASSERT(capturePoint);
 
    //At first call using TEAM_NEUTRAL as a checker but never using it, after first call we reset the capturepoints to the new winner of the last WG war
    if (team == TEAM_NEUTRAL)
        team = Team;
    LOG_DEBUG("bg.battlefield", "Creating capture point {}", capturePoint->GetEntry());
 
    CapturePoint = capturePoint->GetGUID();
 
    // check info existence
    GameObjectTemplate const* goinfo = capturePoint->GetGOInfo();
    if (goinfo->type != GAMEOBJECT_TYPE_CAPTURE_POINT)
    {
        LOG_ERROR("bg.battlefield", "OutdoorPvP: GO {} is not capture point!", capturePoint->GetEntry());
        return false;
    }
 
    // get the needed values from goinfo
    MaxValue = goinfo->capturePoint.maxTime;
    MaxSpeed = MaxValue / (goinfo->capturePoint.minTime ? goinfo->capturePoint.minTime : 60);
    NeutralValuePct = goinfo->capturePoint.neutralPercent;
    MinValue = MaxValue * goinfo->capturePoint.neutralPercent / 100;
    CapturePointEntry = capturePoint->GetEntry();
    if (team == TEAM_ALLIANCE)
    {
        Value = MaxValue;
        State = BF_CAPTUREPOINT_OBJECTIVESTATE_ALLIANCE;
    }
    else
    {
        Value = -MaxValue;
        State = BF_CAPTUREPOINT_OBJECTIVESTATE_HORDE;
    }
 
    return true;
}

References ASSERT, BF_CAPTUREPOINT_OBJECTIVESTATE_ALLIANCE, BF_CAPTUREPOINT_OBJECTIVESTATE_HORDE, CapturePoint, GameObjectTemplate::capturePoint, CapturePointEntry, GAMEOBJECT_TYPE_CAPTURE_POINT, Object::GetEntry(), GameObject::GetGOInfo(), Object::GetGUID(), LOG_DEBUG, LOG_ERROR, MaxSpeed, GameObjectTemplate::maxTime, MaxValue, GameObjectTemplate::minTime, MinValue, GameObjectTemplate::neutralPercent, NeutralValuePct, State, Team, TEAM_ALLIANCE, TEAM_NEUTRAL, GameObjectTemplate::type, and Value.

Referenced by BattlefieldWG::OnGameObjectCreate().

Update()

bool BfCapturePoint::Update ( uint32  diff )

virtual

{
    GameObject* capturePoint = GetCapturePointGo();
    if (!capturePoint)
        return false;
 
    float radius = capturePoint->GetGOInfo()->capturePoint.radius;
 
    // Single pass over the existing set: drop leavers, count survivors per team.
    uint32 counts[PVP_TEAMS_COUNT] = { 0, 0 };
    for (auto itr = ActivePlayers.begin(); itr != ActivePlayers.end();)
    {
        Player* player = ObjectAccessor::FindPlayer(*itr);
        if (player && capturePoint->IsWithinDistInMap(player, radius) && player->IsOutdoorPvPActive())
        {
            ++counts[player->GetTeamId()];
            ++itr;
            continue;
        }
 
        itr = (player ? HandlePlayerLeave(player) : ActivePlayers.erase(itr));
    }
 
    std::list<Player*> players;
    Acore::AnyPlayerInObjectRangeCheck checker(capturePoint, radius);
    Acore::PlayerListSearcher<Acore::AnyPlayerInObjectRangeCheck> searcher(capturePoint, players, checker);
    Cell::VisitObjects(capturePoint, searcher, radius);
 
    for (Player* player : players)
        if (player->IsOutdoorPvPActive())
            if (ActivePlayers.insert(player->GetGUID()).second)
            {
                HandlePlayerEnter(player);
                ++counts[player->GetTeamId()];
            }
 
    // get the difference of numbers
    float factDiff = ((float)counts[TEAM_ALLIANCE] - (float)counts[TEAM_HORDE]) * diff / BATTLEFIELD_OBJECTIVE_UPDATE_INTERVAL;
    if (G3D::fuzzyEq(factDiff, 0.0f))
        return false;
 
    TeamId challengerId = TEAM_NEUTRAL;
    float maxDiff = MaxSpeed * diff;
 
    if (factDiff < 0)
    {
        // horde is in majority, but it's already horde-controlled -> no change
        if (State == BF_CAPTUREPOINT_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 == BF_CAPTUREPOINT_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 = BF_CAPTUREPOINT_OBJECTIVESTATE_HORDE;
        Team = TEAM_HORDE;
    }
    else if (Value > MinValue)                          // blue
    {
        if (Value > MaxValue)
            Value = MaxValue;
        State = BF_CAPTUREPOINT_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 = BF_CAPTUREPOINT_OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE;
        // if challenger is horde, then n->h challenge
        else if (challengerId == TEAM_HORDE)
            State = BF_CAPTUREPOINT_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 == BF_CAPTUREPOINT_OBJECTIVESTATE_HORDE || OldState == BF_CAPTUREPOINT_OBJECTIVESTATE_NEUTRAL_HORDE_CHALLENGE))
            State = BF_CAPTUREPOINT_OBJECTIVESTATE_HORDE_ALLIANCE_CHALLENGE;
        else if (challengerId == TEAM_HORDE && (OldState == BF_CAPTUREPOINT_OBJECTIVESTATE_ALLIANCE || OldState == BF_CAPTUREPOINT_OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE))
            State = BF_CAPTUREPOINT_OBJECTIVESTATE_ALLIANCE_HORDE_CHALLENGE;
        Team = TEAM_NEUTRAL;
    }
 
    if (G3D::fuzzyNe(Value, oldValue))
        SendChangePhase();
 
    if (OldState != State)
    {
        if (oldTeam != Team)
            ChangeTeam(oldTeam);
        return true;
    }
 
    return false;
}

References ActivePlayers, BATTLEFIELD_OBJECTIVE_UPDATE_INTERVAL, BF_CAPTUREPOINT_OBJECTIVESTATE_ALLIANCE, BF_CAPTUREPOINT_OBJECTIVESTATE_ALLIANCE_HORDE_CHALLENGE, BF_CAPTUREPOINT_OBJECTIVESTATE_HORDE, BF_CAPTUREPOINT_OBJECTIVESTATE_HORDE_ALLIANCE_CHALLENGE, BF_CAPTUREPOINT_OBJECTIVESTATE_NEUTRAL_ALLIANCE_CHALLENGE, BF_CAPTUREPOINT_OBJECTIVESTATE_NEUTRAL_HORDE_CHALLENGE, GameObjectTemplate::capturePoint, ChangeTeam(), ObjectAccessor::FindPlayer(), GetCapturePointGo(), GameObject::GetGOInfo(), Player::GetTeamId(), HandlePlayerEnter(), HandlePlayerLeave(), Player::IsOutdoorPvPActive(), GameObject::IsWithinDistInMap(), MaxSpeed, MaxValue, MinValue, OldState, PVP_TEAMS_COUNT, GameObjectTemplate::radius, SendChangePhase(), State, Team, TEAM_ALLIANCE, TEAM_HORDE, TEAM_NEUTRAL, Value, and Cell::VisitObjects().

Member Data Documentation

ActivePlayers

GuidUnorderedSet BfCapturePoint::ActivePlayers

protected

Referenced by HandlePlayerEnter(), HandlePlayerLeave(), IsInsideObjective(), SendChangePhase(), SendObjectiveComplete(), SendUpdateWorldState(), and Update().

Bf

Battlefield* BfCapturePoint::Bf

protected

Referenced by GetCapturePointGo(), and WintergraspCapturePoint::WintergraspCapturePoint().

CapturePoint

ObjectGuid BfCapturePoint::CapturePoint

protected

Referenced by DelCapturePoint(), GetCapturePointGo(), GetCapturePointGo(), and SetCapturePointData().

CapturePointEntry

uint32 BfCapturePoint::CapturePointEntry

protected

Referenced by SetCapturePointData().

MaxSpeed

float BfCapturePoint::MaxSpeed

protected

Referenced by SetCapturePointData(), and Update().

MaxValue

float BfCapturePoint::MaxValue

protected

Referenced by HandlePlayerEnter(), SendChangePhase(), SetCapturePointData(), and Update().

MinValue

float BfCapturePoint::MinValue

protected

Referenced by SetCapturePointData(), and Update().

NeutralValuePct

uint32 BfCapturePoint::NeutralValuePct

protected

Referenced by HandlePlayerEnter(), SendChangePhase(), and SetCapturePointData().

OldState

BattlefieldObjectiveStates BfCapturePoint::OldState

protected

Referenced by Update().

State

BattlefieldObjectiveStates BfCapturePoint::State

protected

Referenced by SendObjectiveComplete(), SetCapturePointData(), and Update().

Team

TeamId BfCapturePoint::Team

protected

Referenced by WintergraspCapturePoint::GetTeam(), GetTeamId(), SetCapturePointData(), and Update().

Value

float BfCapturePoint::Value

protected

Referenced by HandlePlayerEnter(), SendChangePhase(), SetCapturePointData(), and Update().

---

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

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