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 [2]
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[player->GetTeamId()].insert(player->GetGUID()).second;
}

References ActivePlayers, GetCapturePointGo(), Object::GetGUID(), Player::GetTeamId(), 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[player->GetTeamId()].find(player->GetGUID());
 
    if (current == ActivePlayers[player->GetTeamId()].end())
        return current; // return end()
 
    current = ActivePlayers[player->GetTeamId()].erase(current);
    return current;
}

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

Referenced by Update().

IsInsideObjective()

bool BfCapturePoint::IsInsideObjective

(

Player *

player

)

const

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

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

SendChangePhase()

void BfCapturePoint::SendChangePhase ( )

virtual

{
    GameObject* capturePoint = GetCapturePointGo();
    if (!capturePoint)
        return;
 
    for (uint8 team = 0; team < 2; ++team)
        for (ObjectGuid const& guid : ActivePlayers[team])  // 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
	)

{
    uint8 team;
    switch (State)
    {
        case BF_CAPTUREPOINT_OBJECTIVESTATE_ALLIANCE:
            team = 0;
            break;
        case BF_CAPTUREPOINT_OBJECTIVESTATE_HORDE:
            team = 1;
            break;
        default:
            return;
    }
 
    // send to all players present in the area
    for (ObjectGuid const& playerGuid : ActivePlayers[team])
        if (Player* player = ObjectAccessor::FindPlayer(playerGuid))
            player->KilledMonsterCredit(id, guid);
}

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

SendUpdateWorldState()

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

{
    for (uint8 team = 0; team < 2; ++team)
        for (ObjectGuid const& guid : ActivePlayers[team])  // 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;
 
    for (uint8 team = 0; team < 2; ++team)
    {
        for (auto itr = ActivePlayers[team].begin(); itr != ActivePlayers[team].end();)
        {
            if (Player* player = ObjectAccessor::FindPlayer(*itr))
                if (!capturePoint->IsWithinDistInMap(player, radius) || !player->IsOutdoorPvPActive())
                {
                    itr = HandlePlayerLeave(player);
                    continue;
                }
 
            ++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[player->GetTeamId()].insert(player->GetGUID()).second)
                HandlePlayerEnter(player);
 
    // get the difference of numbers
    float factDiff = ((float) ActivePlayers[0].size() - (float) ActivePlayers[1].size()) * 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(), HandlePlayerEnter(), HandlePlayerLeave(), GameObject::IsWithinDistInMap(), MaxSpeed, MaxValue, MinValue, OldState, GameObjectTemplate::radius, SendChangePhase(), State, Team, TEAM_ALLIANCE, TEAM_HORDE, TEAM_NEUTRAL, Value, and Cell::VisitObjects().

Member Data Documentation

ActivePlayers

GuidUnorderedSet BfCapturePoint::ActivePlayers[2]

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