ChaseMovementGenerator< T > Class Template Reference

#include "TargetedMovementGenerator.h"

Inheritance diagram for ChaseMovementGenerator< T >:

Public Member Functions
	ChaseMovementGenerator (Unit *target, Optional< ChaseRange > range={}, Optional< ChaseAngle > angle={})
	~ChaseMovementGenerator ()
MovementGeneratorType	GetMovementGeneratorType ()
bool	DoUpdate (T *, uint32)
void	DoInitialize (T *)
void	DoFinalize (T *)
void	DoReset (T *)
void	MovementInform (T *)
bool	PositionOkay (T *owner, Unit *target, Optional< float > maxDistance, Optional< ChaseAngle > angle)
void	unitSpeedChanged ()
Unit *	GetTarget () const
bool	EnableWalking () const
bool	HasLostTarget (Unit *unit) const
void	SetOffsetAndAngle (std::optional< ChaseRange > dist, std::optional< ChaseAngle > angle)
void	SetNewTarget (Unit *target)
void	DistanceYourself (T *owner, float distance)
bool	DispatchSplineToPosition (T *owner, float x, float y, float z, bool walk, bool cutPath, float maxTarget, bool forceDest, bool target=false)
void	DoInitialize (Player *owner)
void	DoInitialize (Creature *owner)
Public Member Functions inherited from MovementGeneratorMedium< T, ChaseMovementGenerator< 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 TargetedMovementGeneratorBase
	TargetedMovementGeneratorBase (Unit *target)
void	stopFollowing ()

Private Attributes
TimeTrackerSmall	i_leashExtensionTimer
std::unique_ptr< PathGenerator >	i_path
TimeTrackerSmall	i_recheckDistance
bool	i_recalculateTravel
Optional< Position >	_lastTargetPosition
Optional< ChaseRange >	_range
Optional< ChaseAngle >	_angle
bool	_movingTowards = true
bool	_mutualChase = true
ChaseMovementMode	m_currentMode

Additional Inherited Members
Protected Attributes inherited from TargetedMovementGeneratorBase
FollowerReference	i_target

Detailed Description

template<class T>
class ChaseMovementGenerator< T >

Constructor & Destructor Documentation

ChaseMovementGenerator()

template<class T >

ChaseMovementGenerator< T >::ChaseMovementGenerator ( Unit *  target, Optional< ChaseRange >  range = {}, Optional< ChaseAngle >  angle = {}  )

inline

                                                                      {}, Optional<ChaseAngle> angle = {})
        : TargetedMovementGeneratorBase(target), i_leashExtensionTimer(5000), i_path(nullptr), i_recheckDistance(0), i_recalculateTravel(true), _range(range), _angle(angle), m_currentMode(CHASE_MODE_NORMAL) {}

~ChaseMovementGenerator()

template<class T >

ChaseMovementGenerator< T >::~ChaseMovementGenerator ( )

inline

{ }

Member Function Documentation

DispatchSplineToPosition()

template<class T >

bool ChaseMovementGenerator< T >::DispatchSplineToPosition	(	T *	owner,
		float	x,
		float	y,
		float	z,
		bool	walk,
		bool	cutPath,
		float	maxTarget,
		bool	forceDest,
		bool	target = false
	)

{
    Creature* cOwner = owner->ToCreature();
 
    if (owner->IsHovering())
        owner->UpdateAllowedPositionZ(x, y, z);
 
    bool success = i_path->CalculatePath(x, y, z, forceDest);
    uint32 pathType = i_path->GetPathType();
    bool pathFailed = !success || (pathType & PATHFIND_NOPATH);
 
    // For pets, treat incomplete paths as failures to avoid clipping through geometry
    // Players and Player-controlled units have more erratic movement, skip failure
    if (cOwner && (cOwner->IsPet() || cOwner->IsControlledByPlayer()) && !i_target.getTarget()->IsCharmedOwnedByPlayerOrPlayer())
        if (pathType & PATHFIND_INCOMPLETE)
            pathFailed = true;
 
    if (pathFailed)
    {
        if (cOwner)
        {
            cOwner->SetCannotReachTarget(i_target.getTarget()->GetGUID());
 
            if (cOwner->IsPet() || cOwner->IsControlledByPlayer())
                cOwner->AttackStop();
        }
 
        owner->StopMoving();
        return false;
    }
 
    if (cutPath)
        i_path->ShortenPathUntilDist(G3D::Vector3(x, y, z), maxTarget);
 
    if (cOwner)
    {
        cOwner->SetCannotReachTarget();
    }
 
    owner->AddUnitState(UNIT_STATE_CHASE_MOVE);
    i_recalculateTravel = true;
 
    Movement::MoveSplineInit init(owner);
    init.MovebyPath(i_path->GetPath());
    if (target)
        init.SetFacing(i_target.getTarget());
    init.SetWalk(walk);
    init.Launch();
 
    return true;
}

References Unit::AttackStop(), Unit::IsCharmedOwnedByPlayerOrPlayer(), Unit::IsControlledByPlayer(), Unit::IsPet(), Movement::MoveSplineInit::Launch(), Movement::MoveSplineInit::MovebyPath(), PATHFIND_INCOMPLETE, PATHFIND_NOPATH, Creature::SetCannotReachTarget(), Movement::MoveSplineInit::SetFacing(), Movement::MoveSplineInit::SetWalk(), Object::ToCreature(), UNIT_STATE_CHASE_MOVE, and WorldObject::UpdateAllowedPositionZ().

DistanceYourself()

template<class T >

template void ChaseMovementGenerator< T >::DistanceYourself	(	T *	owner,
		float	distance
	)

{
    // make a new path if we have to...
    if (!i_path)
        i_path = std::make_unique<PathGenerator>(owner);
 
    float x, y, z;
    i_target->GetNearPoint(owner, x, y, z, owner->GetBoundaryRadius(), distance, i_target->GetAngle(owner));
    if (DispatchSplineToPosition(owner, x, y, z, false, false, 0.f, false, false))
    {
        m_currentMode = CHASE_MODE_DISTANCING;
        if constexpr (!std::is_same_v<T, Player>)
        {
            owner->AI()->DistancingStarted();
        }
    }
}

References CHASE_MODE_DISTANCING.

Referenced by MotionMaster::DistanceYourself().

DoFinalize()

template<class T >

template void ChaseMovementGenerator< T >::DoFinalize

(

T *

)

{
    owner->ClearUnitState(UNIT_STATE_CHASE | UNIT_STATE_CHASE_MOVE);
    if (Creature* cOwner = owner->ToCreature())
    {
        cOwner->SetCannotReachTarget();
    }
}

References Object::ToCreature(), UNIT_STATE_CHASE, and UNIT_STATE_CHASE_MOVE.

DoInitialize() [1/3]

void ChaseMovementGenerator< Creature >::DoInitialize

(

Creature *

owner

)

{
    i_path = nullptr;
    _lastTargetPosition.reset();
    i_recheckDistance.Reset(0);
    i_leashExtensionTimer.Reset(owner->GetAttackTime(BASE_ATTACK));
    owner->AddUnitState(UNIT_STATE_CHASE);
}

References Unit::AddUnitState(), BASE_ATTACK, Unit::GetAttackTime(), and UNIT_STATE_CHASE.

DoInitialize() [2/3]

void ChaseMovementGenerator< Player >::DoInitialize

(

Player *

owner

)

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

References Unit::AddUnitState(), Unit::StopMoving(), and UNIT_STATE_CHASE.

DoInitialize() [3/3]

template<class T >

void ChaseMovementGenerator< T >::DoInitialize

(

T *

)

DoReset()

template<class T >

template void ChaseMovementGenerator< T >::DoReset

(

T *

)

{
    DoInitialize(owner);
}

DoUpdate()

template<class T >

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

Todo:

: Research how it should actually work.

{
    if (!i_target.isValid() || !i_target->IsInWorld() || !owner->IsInMap(i_target.getTarget()))
        return false;
 
    if (!owner || !owner->IsAlive())
        return false;
 
    if (owner->HasUnitState(UNIT_STATE_NO_COMBAT_MOVEMENT)) // script paused combat movement
    {
        owner->StopMoving();
        _lastTargetPosition.reset();
        return true;
    }
 
    Creature* cOwner = owner->ToCreature();
    bool isStoppedBecauseOfCasting = cOwner && cOwner->IsMovementPreventedByCasting();
 
    // 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) || HasLostTarget(owner) || isStoppedBecauseOfCasting)
    {
        owner->StopMoving();
        _lastTargetPosition.reset();
        if (cOwner)
        {
            if (isStoppedBecauseOfCasting)
            {
                // Don't reset leash timer if it's a spell like Shoot with a short cast time.
                Spell *spell = cOwner->GetFirstCurrentCastingSpell();
                bool spellHasLongCast = spell && spell->GetCastTime() > 1 * SECOND * IN_MILLISECONDS;
                if (spellHasLongCast)
                    cOwner->UpdateLeashExtensionTime();
            }
            else
                cOwner->UpdateLeashExtensionTime();
 
            cOwner->SetCannotReachTarget();
        }
        return true;
    }
 
    bool forceDest =
        //(cOwner && (cOwner->isWorldBoss() || cOwner->IsDungeonBoss())) || // force for all bosses, even not in instances
        (i_target->IsPlayer() && i_target->ToPlayer()->IsGameMaster()) || // for .npc follow
        (owner->CanFly())
        ; // closes "bool forceDest", that way it is more appropriate, so we can comment out crap whenever we need to
 
    Unit* target = i_target.getTarget();
 
    bool mutualChase = IsMutualChase(owner, target);
    bool const mutualTarget = target->GetVictim() == owner;
    float const chaseRange = GetChaseRange(owner, target);
    float const meleeRange = owner->GetMeleeRange(target);
    float const minTarget = (_range ? _range->MinTolerance : 0.0f) + chaseRange;
    float const maxRange = _range ? _range->MaxRange + chaseRange : meleeRange; // melee range already includes hitboxes
    float const maxTarget = _range ? _range->MaxTolerance + chaseRange : CONTACT_DISTANCE + chaseRange;
 
    Optional<ChaseAngle> angle = mutualChase ? Optional<ChaseAngle>() : _angle;
 
    // Prevent almost infinite spinning of mutual targets.
    if (angle && !mutualChase && _mutualChase && mutualTarget && chaseRange < meleeRange)
    {
        angle = Optional<ChaseAngle>();
        mutualChase = true;
    }
 
    // Prevent almost infinite spinning for pets with mutualTarget
    // _mutualChase is false for previous check
    if (angle && !mutualChase && !_mutualChase && mutualTarget && chaseRange < meleeRange && cOwner && cOwner->IsPet())
    {
        angle = Optional<ChaseAngle>();
        mutualChase = true;
    }
 
    // periodically check if we're already in the expected range...
    i_recheckDistance.Update(time_diff);
    if (i_recheckDistance.Passed())
    {
        i_recheckDistance.Reset(400); // Sniffed value
 
        if (m_currentMode != CHASE_MODE_DISTANCING)
        {
            if (i_recalculateTravel && PositionOkay(owner, target, _movingTowards ? maxTarget : Optional<float>(), angle))
            {
                if ((owner->HasUnitState(UNIT_STATE_CHASE_MOVE) && !target->isMoving() && !mutualChase) || _range)
                {
                    i_recalculateTravel = false;
                    i_path = nullptr;
                    if (cOwner)
                        cOwner->SetCannotReachTarget();
                    owner->StopMoving();
                    owner->SetInFront(target);
                    MovementInform(owner);
                    return true;
                }
            }
        }
    }
 
    // if we're done moving, we want to clean up
    if (owner->HasUnitState(UNIT_STATE_CHASE_MOVE) && owner->movespline->Finalized())
    {
        i_recalculateTravel = false;
        i_path = nullptr;
        if (cOwner)
            cOwner->SetCannotReachTarget();
        owner->ClearUnitState(UNIT_STATE_CHASE_MOVE);
        owner->SetInFront(target);
        MovementInform(owner);
    }
 
    if (cOwner)
    {
        if (owner->movespline->Finalized() && cOwner->IsWithinMeleeRange(target))
        { // Mobs should chase you infinitely if you stop and wait every few seconds.
            i_leashExtensionTimer.Update(time_diff);
            if (i_leashExtensionTimer.Passed())
            {
                i_leashExtensionTimer.Reset(cOwner->GetAttackTime(BASE_ATTACK));
                cOwner->UpdateLeashExtensionTime();
            }
        }
        else if (i_recalculateTravel)
            i_leashExtensionTimer.Reset(cOwner->GetAttackTime(BASE_ATTACK));
    }
 
    if (m_currentMode == CHASE_MODE_DISTANCING)
        return true;
 
    // if the target moved, we have to consider whether to adjust
    if (!_lastTargetPosition || target->GetPosition() != _lastTargetPosition.value() || mutualChase != _mutualChase || !owner->IsWithinLOSInMap(target))
    {
        _lastTargetPosition = target->GetPosition();
        _mutualChase = mutualChase;
        if (owner->HasUnitState(UNIT_STATE_CHASE_MOVE) || !PositionOkay(owner, target, maxTarget, angle))
        {
            // can we get to the target?
            if (cOwner && !target->isInAccessiblePlaceFor(cOwner))
            {
                cOwner->SetCannotReachTarget(target->GetGUID());
                cOwner->StopMoving();
                i_path = nullptr;
                return true;
            }
 
            // figure out which way we want to move
            float x, y, z;
            target->GetPosition(x, y, z);
            bool withinRange = owner->IsInDist(target, maxRange);
            bool withinLOS = owner->IsWithinLOS(x, y, z);
            bool moveToward = !(withinRange && withinLOS);
 
            // make a new path if we have to...
            if (!i_path || moveToward != _movingTowards)
                i_path = std::make_unique<PathGenerator>(owner);
            else
                i_path->Clear();
 
            // Predict chase destination to keep up with chase target
            float additionalRange = 0;
            bool predictDestination = !mutualChase && target->isMoving();
            if (predictDestination)
            {
                UnitMoveType moveType = MOVE_RUN;
                if (target->CanFly())
                    moveType = target->HasUnitMovementFlag(MOVEMENTFLAG_BACKWARD) ? MOVE_FLIGHT_BACK : MOVE_FLIGHT;
                else
                {
                    if (target->IsWalking())
                        moveType = MOVE_WALK;
                    else
                        moveType = target->HasUnitMovementFlag(MOVEMENTFLAG_BACKWARD) ? MOVE_RUN_BACK : MOVE_RUN;
                }
                float speed = target->GetSpeed(moveType) * 0.5f;
                additionalRange = owner->GetExactDistSq(target) < G3D::square(speed) ? 0 : speed;
            }
 
            bool shortenPath;
 
            // if we want to move toward the target and there's no fixed angle...
            if (moveToward && !angle)
            {
                // ...we'll pathfind to the center, then shorten the path
                shortenPath = true;
            }
            else
            {
                // otherwise, we fall back to nearpoint finding
                target->GetNearPoint(owner, x, y, z, (moveToward ? maxTarget : minTarget) - chaseRange - additionalRange, 0, angle ? target->ToAbsoluteAngle(angle->RelativeAngle) : target->GetAngle(owner));
                shortenPath = false;
            }
 
            bool walk = false;
            if (cOwner && !cOwner->IsPet())
            {
                switch (cOwner->GetMovementTemplate().GetChase())
                {
                    case CreatureChaseMovementType::CanWalk:
                        walk = owner->IsWalking();
                        break;
                    case CreatureChaseMovementType::AlwaysWalk:
                        walk = true;
                        break;
                    default:
                        break;
                }
            }
 
            DispatchSplineToPosition(owner, x, y, z, walk, shortenPath, maxTarget, forceDest, true);
        }
    }
 
    return true;
}

References AlwaysWalk, BASE_ATTACK, Unit::CanFly(), CanWalk, CHASE_MODE_DISTANCING, CONTACT_DISTANCE, Position::GetAngle(), Unit::GetAttackTime(), Spell::GetCastTime(), CreatureMovementData::GetChase(), GetChaseRange(), Unit::GetFirstCurrentCastingSpell(), Object::GetGUID(), Creature::GetMovementTemplate(), WorldObject::GetNearPoint(), Position::GetPosition(), Unit::GetSpeed(), Unit::GetVictim(), Unit::HasUnitMovementFlag(), IN_MILLISECONDS, Unit::isInAccessiblePlaceFor(), Creature::IsMovementPreventedByCasting(), Unit::isMoving(), IsMutualChase(), Unit::IsPet(), Unit::IsWalking(), Unit::IsWithinMeleeRange(), MOVE_FLIGHT, MOVE_FLIGHT_BACK, MOVE_RUN, MOVE_RUN_BACK, MOVE_WALK, MOVEMENTFLAG_BACKWARD, SECOND, Creature::SetCannotReachTarget(), Unit::StopMoving(), Position::ToAbsoluteAngle(), Object::ToCreature(), UNIT_STATE_CHASE_MOVE, UNIT_STATE_NO_COMBAT_MOVEMENT, UNIT_STATE_NOT_MOVE, and Creature::UpdateLeashExtensionTime().

EnableWalking()

template<class T >

bool ChaseMovementGenerator< T >::EnableWalking ( ) const

inline

{ return false; }

GetMovementGeneratorType()

template<class T >

MovementGeneratorType ChaseMovementGenerator< T >::GetMovementGeneratorType ( )

inlinevirtual

Implements MovementGenerator.

{ return CHASE_MOTION_TYPE; }

References CHASE_MOTION_TYPE.

GetTarget()

template<class T >

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

inline

{ return i_target.getTarget(); }

References Reference< TO, FROM >::getTarget(), and TargetedMovementGeneratorBase::i_target.

Referenced by ChaseMovementGenerator< T >::HasLostTarget().

HasLostTarget()

template<class T >

bool ChaseMovementGenerator< T >::HasLostTarget ( Unit *  unit ) const

inline

{ return unit->GetVictim() != this->GetTarget(); }

References ChaseMovementGenerator< T >::GetTarget(), and Unit::GetVictim().

MovementInform()

template<class T >

template void ChaseMovementGenerator< T >::MovementInform

(

T *

)

{
    if (!owner->IsCreature())
        return;
 
    switch (m_currentMode)
    {
        default:
        {
            // 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(CHASE_MOTION_TYPE, i_target.getTarget()->GetGUID().GetCounter());
            break;
        }
        case CHASE_MODE_DISTANCING:
        {
            if (CreatureAI* AI = owner->ToCreature()->AI())
                AI->DistancingEnded();
            break;
        }
    }
 
    m_currentMode = CHASE_MODE_NORMAL;
}

References CHASE_MODE_DISTANCING, CHASE_MODE_NORMAL, and CHASE_MOTION_TYPE.

PositionOkay()

template<class T >

bool ChaseMovementGenerator< T >::PositionOkay	(	T *	owner,
		Unit *	target,
		Optional< float >	maxDistance,
		Optional< ChaseAngle >	angle
	)

{
    float const distSq = owner->GetExactDistSq(target);
 
    // Distance between owner(chaser) and target is greater than the allowed distance.
    if (maxDistance && distSq > G3D::square(*maxDistance))
        return false;
 
    // owner's relative angle to its target is not within boundaries
    if (angle && !angle->IsAngleOkay(target->GetRelativeAngle(owner)))
        return false;
 
    // owner cannot see its target
    if (!owner->IsWithinLOSInMap(target))
        return false;
    return true;
}

References Position::GetRelativeAngle().

SetNewTarget()

template<class T >

template void ChaseMovementGenerator< T >::SetNewTarget

(

Unit *

target

)

{
    i_target.link(target, this);
    _lastTargetPosition.reset();
}

Referenced by MotionMaster::MoveChase().

SetOffsetAndAngle()

template<class T >

template void ChaseMovementGenerator< T >::SetOffsetAndAngle	(	std::optional< ChaseRange >	dist,
		std::optional< ChaseAngle >	angle
	)

{
    _range = dist;
    _angle = angle;
    _lastTargetPosition.reset();
}

Referenced by MotionMaster::MoveChase().

unitSpeedChanged()

template<class T >

void ChaseMovementGenerator< T >::unitSpeedChanged ( )

inlinevirtual

Reimplemented from MovementGenerator.

{ _lastTargetPosition.reset(); }

References ChaseMovementGenerator< T >::_lastTargetPosition.

Member Data Documentation

_angle

template<class T >

Optional<ChaseAngle> ChaseMovementGenerator< T >::_angle

private

_lastTargetPosition

template<class T >

Optional<Position> ChaseMovementGenerator< T >::_lastTargetPosition

private

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

_movingTowards

template<class T >

bool ChaseMovementGenerator< T >::_movingTowards = true

private

_mutualChase

template<class T >

bool ChaseMovementGenerator< T >::_mutualChase = true

private

_range

template<class T >

Optional<ChaseRange> ChaseMovementGenerator< T >::_range

private

i_leashExtensionTimer

template<class T >

TimeTrackerSmall ChaseMovementGenerator< T >::i_leashExtensionTimer

private

i_path

template<class T >

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

private

i_recalculateTravel

template<class T >

bool ChaseMovementGenerator< T >::i_recalculateTravel

private

i_recheckDistance

template<class T >

TimeTrackerSmall ChaseMovementGenerator< T >::i_recheckDistance

private

m_currentMode

template<class T >

ChaseMovementMode ChaseMovementGenerator< T >::m_currentMode

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