FollowMovementGenerator< T > Class Template Reference

#include "TargetedMovementGenerator.h"

Inheritance diagram for FollowMovementGenerator< T >:

Public Member Functions
	FollowMovementGenerator (Unit *target, float range, ChaseAngle angle, bool inheritWalkState, bool inheritSpeed)
	~FollowMovementGenerator ()
MovementGeneratorType	GetMovementGeneratorType ()
bool	DoUpdate (T *, uint32)
void	DoInitialize (T *)
void	DoFinalize (T *)
void	DoReset (T *)
void	MovementInform (T *)
Unit *	GetTarget () const
void	unitSpeedChanged ()
bool	PositionOkay (Unit *target, bool isPlayerPet, bool &targetIsMoving, uint32 diff)
float	GetFollowRange () const
Public Member Functions inherited from MovementGeneratorMedium< T, FollowMovementGenerator< T > >
void	Initialize (Unit *u) override
void	Finalize (Unit *u) override
void	Reset (Unit *u) override
bool	Update (Unit *u, uint32 time_diff) override
Public Member Functions inherited from MovementGenerator
virtual	~MovementGenerator ()
virtual uint32	GetSplineId () const
virtual void	Pause (uint32)
virtual void	Resume (uint32)
virtual bool	GetResetPosition (float &, float &, float &)
Public Member Functions inherited from AbstractFollower
	AbstractFollower (Unit *target=nullptr)
virtual	~AbstractFollower ()
void	SetTarget (Unit *unit)
Unit *	GetTarget () const

Static Public Member Functions
static void	_clearUnitStateMove (T *u)
static void	_addUnitStateMove (T *u)

Private Attributes
std::unique_ptr< PathGenerator >	i_path
TimeTrackerSmall	i_recheckPredictedDistanceTimer
bool	i_recheckPredictedDistance
Optional< Position >	_lastTargetPosition
Optional< Position >	_lastPredictedPosition
float	_range
ChaseAngle	_angle
bool	_inheritWalkState
bool	_inheritSpeed

Detailed Description

template<class T>
class FollowMovementGenerator< T >

Constructor & Destructor Documentation

FollowMovementGenerator()

template<class T >

FollowMovementGenerator< T >::FollowMovementGenerator ( Unit *  target, float  range, ChaseAngle  angle, bool  inheritWalkState, bool  inheritSpeed  )

inline

        : AbstractFollower(target), i_path(nullptr), i_recheckPredictedDistanceTimer(0), i_recheckPredictedDistance(false), _range(range), _angle(angle), _inheritWalkState(inheritWalkState), _inheritSpeed(inheritSpeed) {}

~FollowMovementGenerator()

template<class T >

FollowMovementGenerator< T >::~FollowMovementGenerator ( )

inline

{ }

Member Function Documentation

_addUnitStateMove()

template<class T >

static void FollowMovementGenerator< T >::_addUnitStateMove ( T *  u )

inlinestatic

{ u->AddUnitState(UNIT_STATE_FOLLOW_MOVE); }

References UNIT_STATE_FOLLOW_MOVE.

_clearUnitStateMove()

template<class T >

static void FollowMovementGenerator< T >::_clearUnitStateMove ( T *  u )

inlinestatic

{ u->ClearUnitState(UNIT_STATE_FOLLOW_MOVE); }

References UNIT_STATE_FOLLOW_MOVE.

DoFinalize()

template<class T >

template void FollowMovementGenerator< T >::DoFinalize

(

T *

)

{
    owner->ClearUnitState(UNIT_STATE_FOLLOW | UNIT_STATE_FOLLOW_MOVE);
}

References UNIT_STATE_FOLLOW, and UNIT_STATE_FOLLOW_MOVE.

DoInitialize()

template<class T >

template void FollowMovementGenerator< T >::DoInitialize

(

T *

)

{
    i_path = nullptr;
    _lastTargetPosition.reset();
    owner->AddUnitState(UNIT_STATE_FOLLOW);
}

References UNIT_STATE_FOLLOW.

DoReset()

template<class T >

template void FollowMovementGenerator< T >::DoReset

(

T *

)

{
    DoInitialize(owner);
}

DoUpdate()

template<class T >

template bool FollowMovementGenerator< T >::DoUpdate	(	T *	,
		uint32
	)

{
    if (!GetTarget() || !GetTarget()->IsInWorld() || !owner->IsInMap(GetTarget()))
        return false;
 
    if (!owner || !owner->IsAlive())
        return false;
 
    Creature* cOwner = owner->ToCreature();
    Unit* target = GetTarget();
 
    // the owner might be unable to move (rooted or casting), or we have lost the target, pause movement
    if (owner->HasUnitState(UNIT_STATE_NOT_MOVE) || (cOwner && owner->ToCreature()->IsMovementPreventedByCasting()))
    {
        i_path = nullptr;
        owner->StopMoving();
        _lastTargetPosition.reset();
        return true;
    }
 
    bool followingMaster = false;
    Pet* oPet = owner->ToPet();
    if (oPet)
    {
        if (target->GetGUID() == oPet->GetOwnerGUID())
            followingMaster = true;
    }
 
    bool forceDest =
        (followingMaster) || // allow pets following their master to cheat while generating paths
        (GetTarget()->IsPlayer() && GetTarget()->ToPlayer()->IsGameMaster()) // for .npc follow
        ; // closes "bool forceDest", that way it is more appropriate, so we can comment out crap whenever we need to
 
    bool targetIsMoving = false;
    bool isPlayerPet = owner->IsGuardian() && target->IsPlayer();
    bool isFollowingPlayer = target->IsPlayer();
 
    if (PositionOkay(target, isPlayerPet, targetIsMoving, time_diff))
    {
        if (owner->HasUnitState(UNIT_STATE_FOLLOW_MOVE) && owner->movespline->Finalized())
        {
            owner->ClearUnitState(UNIT_STATE_FOLLOW_MOVE);
            i_path = nullptr;
            MovementInform(owner);
 
            if (i_recheckPredictedDistance)
            {
                i_recheckPredictedDistanceTimer.Reset(1000);
            }
 
            owner->SetFacingTo(target->GetOrientation());
        }
    }
    else
    {
        Position targetPosition = target->GetPosition();
        _lastTargetPosition = targetPosition;
 
        // If player is moving and their position is not updated, we need to predict position
        if (targetIsMoving)
        {
            Position predictedPosition = PredictPosition(target);
            if (_lastPredictedPosition && _lastPredictedPosition->GetExactDistSq(&predictedPosition) < 0.25f)
                return true;
 
            if (IsValidPredictedPosition(target, predictedPosition))
            {
                _lastPredictedPosition = predictedPosition;
                targetPosition = predictedPosition;
                i_recheckPredictedDistance = true;
            }
            else
            {
                _lastPredictedPosition.reset();
                i_recheckPredictedDistance = false;
            }
        }
        else
        {
            i_recheckPredictedDistance = false;
            i_recheckPredictedDistanceTimer.Reset(0);
            _lastPredictedPosition.reset();
        }
 
        if (!i_path)
            i_path = std::make_unique<PathGenerator>(owner);
        else
            i_path->Clear();
 
        target->MovePositionToFirstCollision(targetPosition, owner->GetCombatReach() + _range, target->ToAbsoluteAngle(_angle.RelativeAngle) - target->GetOrientation());
 
        float x, y, z;
        targetPosition.GetPosition(x, y, z);
 
        if (owner->IsHovering())
            owner->UpdateAllowedPositionZ(x, y, z);
 
        bool success = i_path->CalculatePath(x, y, z, forceDest);
        if (!success || (i_path->GetPathType() & PATHFIND_NOPATH && !followingMaster))
        {
            if (!owner->IsStopped())
                owner->StopMoving();
 
            // Teleport if stuck and too far away
            if (cOwner && isFollowingPlayer)
            {
                float const distance = owner->GetDistance2d(target);
                if (distance > 20.f)
                {
                    float teleX;
                    float teleY;
                    float teleZ;
 
                    target->GetClosePoint(teleX, teleY, teleZ, owner->GetCombatReach());
                    teleZ = owner->GetMapHeight(teleX, teleY, teleZ);
                    owner->NearTeleportTo(teleX, teleY, teleZ, target->GetOrientation());
                    _lastTargetPosition.reset();
                    _lastPredictedPosition.reset();
                }
            }
            return true;
        }
 
        owner->AddUnitState(UNIT_STATE_FOLLOW_MOVE);
 
        Movement::MoveSplineInit init(owner);
        init.MovebyPath(i_path->GetPath());
        if (_inheritWalkState)
            init.SetWalk(target->IsWalking());
 
        if (_inheritSpeed)
            if (Optional<float> velocity = GetVelocity(owner, target, i_path->GetActualEndPosition(), owner->IsGuardian()))
                init.SetVelocity(*velocity);
        init.Launch();
    }
 
    return true;
}

References WorldObject::GetClosePoint(), Object::GetGUID(), Position::GetOrientation(), Unit::GetOwnerGUID(), Position::GetPosition(), GetVelocity(), Unit::IsGuardian(), Creature::IsMovementPreventedByCasting(), Object::IsPlayer(), IsValidPredictedPosition(), Unit::IsWalking(), Movement::MoveSplineInit::Launch(), Movement::MoveSplineInit::MovebyPath(), WorldObject::MovePositionToFirstCollision(), PATHFIND_NOPATH, PredictPosition(), Movement::MoveSplineInit::SetVelocity(), Movement::MoveSplineInit::SetWalk(), Position::ToAbsoluteAngle(), Object::ToCreature(), Unit::ToPet(), UNIT_STATE_FOLLOW_MOVE, and UNIT_STATE_NOT_MOVE.

GetFollowRange()

template<class T >

float FollowMovementGenerator< T >::GetFollowRange ( ) const

inline

{ return _range; }

References FollowMovementGenerator< T >::_range.

GetMovementGeneratorType()

template<class T >

MovementGeneratorType FollowMovementGenerator< T >::GetMovementGeneratorType ( )

inlinevirtual

Implements MovementGenerator.

{ return FOLLOW_MOTION_TYPE; }

References FOLLOW_MOTION_TYPE.

GetTarget()

template<class T >

Unit * FollowMovementGenerator< T >::GetTarget ( ) const

inline

{ return AbstractFollower::GetTarget(); }

References AbstractFollower::GetTarget().

Referenced by npc_commandscript::HandleNpcUnFollowCommand().

MovementInform()

template<class T >

void FollowMovementGenerator< T >::MovementInform

(

T *

owner

)

{
    if (!owner->IsCreature())
        return;
 
    // Pass back the GUIDLow of the target. If it is pet's owner then PetAI will handle
    if (CreatureAI* AI = owner->ToCreature()->AI())
        AI->MovementInform(FOLLOW_MOTION_TYPE, GetTarget()->GetGUID().GetCounter());
}

References FOLLOW_MOTION_TYPE.

PositionOkay()

template<class T >

bool FollowMovementGenerator< T >::PositionOkay	(	Unit *	target,
		bool	isPlayerPet,
		bool &	targetIsMoving,
		uint32	diff
	)

{
    if (!_lastTargetPosition)
        return false;
 
    float exactDistSq = target->GetExactDistSq(_lastTargetPosition->GetPositionX(), _lastTargetPosition->GetPositionY(), _lastTargetPosition->GetPositionZ());
    float distanceTolerance = 0.25f;
    // For creatures, increase tolerance
    if (target->IsCreature())
    {
        distanceTolerance += _range + _range;
    }
 
    if (isPlayerPet)
    {
        targetIsMoving = target->m_movementInfo.HasMovementFlag(MOVEMENTFLAG_FORWARD | MOVEMENTFLAG_BACKWARD | MOVEMENTFLAG_STRAFE_LEFT | MOVEMENTFLAG_STRAFE_RIGHT);
    }
 
    if (exactDistSq > distanceTolerance)
        return false;
 
    if (isPlayerPet)
    {
        if (!targetIsMoving)
        {
            if (i_recheckPredictedDistanceTimer.GetExpiry())
            {
                i_recheckPredictedDistanceTimer.Update(diff);
                if (i_recheckPredictedDistanceTimer.Passed())
                {
                    i_recheckPredictedDistanceTimer = 0;
                    return false;
                }
            }
 
            return true;
        }
 
        return false;
    }
 
    return true;
}

References Position::GetExactDistSq(), MovementInfo::HasMovementFlag(), Object::IsCreature(), WorldObject::m_movementInfo, MOVEMENTFLAG_BACKWARD, MOVEMENTFLAG_FORWARD, MOVEMENTFLAG_STRAFE_LEFT, and MOVEMENTFLAG_STRAFE_RIGHT.

unitSpeedChanged()

template<class T >

void FollowMovementGenerator< T >::unitSpeedChanged ( )

inlinevirtual

Reimplemented from MovementGenerator.

{ _lastTargetPosition.reset(); }

References FollowMovementGenerator< T >::_lastTargetPosition.

Member Data Documentation

_angle

template<class T >

ChaseAngle FollowMovementGenerator< T >::_angle

private

_inheritSpeed

template<class T >

bool FollowMovementGenerator< T >::_inheritSpeed

private

_inheritWalkState

template<class T >

bool FollowMovementGenerator< T >::_inheritWalkState

private

_lastPredictedPosition

template<class T >

Optional<Position> FollowMovementGenerator< T >::_lastPredictedPosition

private

_lastTargetPosition

template<class T >

Optional<Position> FollowMovementGenerator< T >::_lastTargetPosition

private

Referenced by FollowMovementGenerator< T >::unitSpeedChanged().

_range

template<class T >

float FollowMovementGenerator< T >::_range

private

Referenced by FollowMovementGenerator< T >::GetFollowRange().

i_path

template<class T >

std::unique_ptr<PathGenerator> FollowMovementGenerator< T >::i_path

private

i_recheckPredictedDistance

template<class T >

bool FollowMovementGenerator< T >::i_recheckPredictedDistance

private

i_recheckPredictedDistanceTimer

template<class T >

TimeTrackerSmall FollowMovementGenerator< T >::i_recheckPredictedDistanceTimer

private

---

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

• azerothcore-wotlk/src/server/game/Movement/MovementGenerators/TargetedMovementGenerator.h
• azerothcore-wotlk/src/server/game/Movement/MovementGenerators/TargetedMovementGenerator.cpp