PointMovementGenerator< T > Class Template Reference

#include "PointMovementGenerator.h"

Inheritance diagram for PointMovementGenerator< T >:

Public Member Functions
	PointMovementGenerator (uint32 _id, float _x, float _y, float _z, ForcedMovement forcedMovement, float _speed=0.0f, float orientation=0.0f, const Movement::PointsArray *_path=nullptr, bool generatePath=false, bool forceDestination=false, std::optional< AnimTier > animTier=std::nullopt, ObjectGuid chargeTargetGUID=ObjectGuid::Empty, bool reverseOrientation=false, ObjectGuid facingTargetGuid=ObjectGuid())
void	DoInitialize (T *)
void	DoFinalize (T *)
void	DoReset (T *)
bool	DoUpdate (T *, uint32)
void	MovementInform (T *)
void	Pause (uint32 timer=0) override
void	Resume (uint32 overrideTimer=0) override
void	unitSpeedChanged () override
MovementGeneratorType	GetMovementGeneratorType () override
bool	GetDestination (float &x, float &y, float &z) const
Public Member Functions inherited from MovementGeneratorMedium< T, PointMovementGenerator< 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 bool	GetResetPosition (float &, float &, float &)

Private Attributes
uint32	id
float	i_x
float	i_y
float	i_z
float	speed
float	i_orientation
bool	i_recalculateSpeed {}
Movement::PointsArray	m_precomputedPath
bool	_generatePath
bool	_forceDestination
bool	_reverseOrientation
ObjectGuid	_chargeTargetGUID
ForcedMovement	_forcedMovement
ObjectGuid	_facingTargetGuid
std::optional< AnimTier >	_animTier
bool	_stalled {}
bool	_hasBeenStalled {}
std::optional< int32 >	_pauseTime

Detailed Description

template<class T>
class PointMovementGenerator< T >

Constructor & Destructor Documentation

PointMovementGenerator()

template<class T >

PointMovementGenerator< T >::PointMovementGenerator ( uint32  _id, float  _x, float  _y, float  _z, ForcedMovement  forcedMovement, float  _speed = 0.0f, float  orientation = 0.0f, const Movement::PointsArray *  _path = nullptr, bool  generatePath = false, bool  forceDestination = false, std::optional< AnimTier >  animTier = std::nullopt, ObjectGuid  chargeTargetGUID = ObjectGuid::Empty, bool  reverseOrientation = false, ObjectGuid  facingTargetGuid = ObjectGuid()  )

inline

        : id(_id), i_x(_x), i_y(_y), i_z(_z), speed(_speed), i_orientation(orientation), _generatePath(generatePath), _forceDestination(forceDestination), _reverseOrientation(reverseOrientation),
        _chargeTargetGUID(chargeTargetGUID), _forcedMovement(forcedMovement), _facingTargetGuid(facingTargetGuid), _animTier(animTier)
    {
        if (_path)
            m_precomputedPath = *_path;
    }

References PointMovementGenerator< T >::m_precomputedPath.

Member Function Documentation

DoFinalize()

template<class T >

template void PointMovementGenerator< T >::DoFinalize

(

T *

)

{
    unit->ClearUnitState(UNIT_STATE_ROAMING | UNIT_STATE_ROAMING_MOVE);
    if (id == EVENT_CHARGE || id == EVENT_CHARGE_PREPATH)
    {
        unit->ClearUnitState(UNIT_STATE_CHARGING);
 
        if (_chargeTargetGUID && _chargeTargetGUID == unit->GetTarget())
        {
            if (Unit* target = ObjectAccessor::GetUnit(*unit, _chargeTargetGUID))
            {
                unit->Attack(target, true);
            }
        }
    }
 
    // Only inform AI if this is a real arrival, not a finalize caused by a Pause/Stop
    if (unit->movespline->Finalized() && !_hasBeenStalled)
        MovementInform(unit);
}

References EVENT_CHARGE, EVENT_CHARGE_PREPATH, ObjectAccessor::GetUnit(), UNIT_STATE_CHARGING, UNIT_STATE_ROAMING, and UNIT_STATE_ROAMING_MOVE.

DoInitialize()

template<class T >

template void PointMovementGenerator< T >::DoInitialize

(

T *

)

Todo:

: rename this flag to something more appropriate since it is set to true even without speed change now.

{
    _stalled = false;
    _hasBeenStalled = false;
    _pauseTime.reset();
 
    if (unit->HasUnitState(UNIT_STATE_NOT_MOVE) || unit->IsMovementPreventedByCasting())
    {
        // the next line is to ensure that a new spline is created in DoUpdate() once the unit is no longer rooted/stunned
        i_recalculateSpeed = true;
        return;
    }
 
    if (!unit->IsStopped())
        unit->StopMoving();
 
    unit->AddUnitState(UNIT_STATE_ROAMING | UNIT_STATE_ROAMING_MOVE);
    if (id == EVENT_CHARGE || id == EVENT_CHARGE_PREPATH)
    {
        unit->AddUnitState(UNIT_STATE_CHARGING);
    }
 
    i_recalculateSpeed = false;
    Movement::MoveSplineInit init(unit);
    if (m_precomputedPath.size() > 2) // pussywizard: for charge
        init.MovebyPath(m_precomputedPath);
    else if (_generatePath)
    {
        PathGenerator path(unit);
        bool result = path.CalculatePath(i_x, i_y, i_z, _forceDestination);
        if (result && !(path.GetPathType() & PATHFIND_NOPATH) && path.GetPath().size() > 2)
        {
            m_precomputedPath = path.GetPath();
            init.MovebyPath(m_precomputedPath);
        }
        else
        {
            // Xinef: fix strange client visual bug, moving on z coordinate only switches orientation by 180 degrees (visual only)
            if (G3D::fuzzyEq(unit->GetPositionX(), i_x) && G3D::fuzzyEq(unit->GetPositionY(), i_y))
            {
                i_x += 0.2f * cos(unit->GetOrientation());
                i_y += 0.2f * std::sin(unit->GetOrientation());
            }
 
            init.MoveTo(i_x, i_y, i_z, true);
        }
    }
    else
    {
        // Xinef: fix strange client visual bug, moving on z coordinate only switches orientation by 180 degrees (visual only)
        if (G3D::fuzzyEq(unit->GetPositionX(), i_x) && G3D::fuzzyEq(unit->GetPositionY(), i_y))
        {
            i_x += 0.2f * cos(unit->GetOrientation());
            i_y += 0.2f * std::sin(unit->GetOrientation());
        }
 
        init.MoveTo(i_x, i_y, i_z, true);
    }
    if (speed > 0.0f)
        init.SetVelocity(speed);
 
    if (_forcedMovement == FORCED_MOVEMENT_WALK)
        init.SetWalk(true);
    else if (_forcedMovement == FORCED_MOVEMENT_RUN)
        init.SetWalk(false);
 
    if (i_orientation > 0.0f)
    {
        init.SetFacing(i_orientation);
    }
 
    if (_animTier)
        init.SetAnimation(*_animTier);
 
    init.Launch();
}

References UNIT_STATE_NOT_MOVE.

DoReset()

template<class T >

template void PointMovementGenerator< T >::DoReset

(

T *

)

{
    if (!unit->IsStopped())
        unit->StopMoving();
 
    unit->AddUnitState(UNIT_STATE_ROAMING | UNIT_STATE_ROAMING_MOVE);
    if (id == EVENT_CHARGE || id == EVENT_CHARGE_PREPATH)
    {
        unit->AddUnitState(UNIT_STATE_CHARGING);
    }
}

References EVENT_CHARGE, EVENT_CHARGE_PREPATH, UNIT_STATE_CHARGING, UNIT_STATE_ROAMING, and UNIT_STATE_ROAMING_MOVE.

DoUpdate()

template<class T >

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

{
    if (!unit)
        return false;
 
    if (unit->IsMovementPreventedByCasting())
    {
        unit->StopMoving();
        return true;
    }
 
    if (unit->HasUnitState(UNIT_STATE_NOT_MOVE))
    {
        if (!unit->HasUnitState(UNIT_STATE_CHARGING))
            unit->StopMoving();
        return true;
    }
 
    unit->AddUnitState(UNIT_STATE_ROAMING_MOVE);
 
    if (_pauseTime.has_value())
    {
        if (diff >= static_cast<uint32>(_pauseTime.value()))
            _pauseTime.reset();
        else
        {
            _pauseTime = static_cast<int32>(_pauseTime.value() - diff);
            return true;
        }
 
        _hasBeenStalled = false;
        _stalled = false;
        i_recalculateSpeed = true;
    }
 
    // Relaunch path when speed changed or when resuming from a stall.
    // Keep an indefinitely paused movement stalled until Resume() clears _stalled.
    if (id != EVENT_CHARGE_PREPATH && !_stalled && (i_recalculateSpeed || _hasBeenStalled))
    {
        i_recalculateSpeed = false;
        Movement::MoveSplineInit init(unit);
        auto rebasePrecomputedPath = [this, unit](std::optional<uint32> offset = std::nullopt)
        {
            Movement::PointsArray rebasedPath;
            G3D::Vector3 currentPos(unit->GetPositionX(), unit->GetPositionY(), unit->GetPositionZ());
 
            if (m_precomputedPath.empty())
                return rebasedPath;
 
            if (offset.has_value())
            {
                if (offset.value() >= m_precomputedPath.size())
                {
                    rebasedPath.push_back(currentPos);
                    rebasedPath.push_back(m_precomputedPath.back());
                    return rebasedPath;
                }
 
                rebasedPath.insert(rebasedPath.end(), m_precomputedPath.begin() + offset.value(), m_precomputedPath.end());
            }
            else
            {
                uint32 closestPointIndex = 0;
                float closestPointDist = std::numeric_limits<float>::max();
                for (uint32 pointIndex = 1; pointIndex < m_precomputedPath.size(); ++pointIndex)
                {
                    float const sqDist = (currentPos - m_precomputedPath[pointIndex]).squaredLength();
                    if (sqDist < closestPointDist)
                    {
                        closestPointDist = sqDist;
                        closestPointIndex = pointIndex;
                    }
                }
 
                rebasedPath.insert(rebasedPath.end(), m_precomputedPath.begin() + closestPointIndex, m_precomputedPath.end());
            }
 
            // MovebyPath requires the first point to be the mover's current position.
            rebasedPath.insert(rebasedPath.begin(), currentPos);
            return rebasedPath;
        };
 
        if (m_precomputedPath.size())
        {
            if (!unit->movespline->Finalized())
            {
                uint32 offset = std::min(uint32(unit->movespline->_currentSplineIdx()), uint32(m_precomputedPath.size()));
                m_precomputedPath = rebasePrecomputedPath(offset);
 
                if (m_precomputedPath.size() > 2)
                    init.MovebyPath(m_precomputedPath);
                else if (m_precomputedPath.size() == 2)
                    init.MoveTo(m_precomputedPath[1].x, m_precomputedPath[1].y, m_precomputedPath[1].z, true);
            }
            else
            {
                // Unit was stopped (finalized) due to Pause/StopMoving; trim path from current position.
                m_precomputedPath = rebasePrecomputedPath();
 
                if (m_precomputedPath.size() > 2)
                    init.MovebyPath(m_precomputedPath);
                else if (m_precomputedPath.size() == 2)
                    init.MoveTo(m_precomputedPath[1].x, m_precomputedPath[1].y, m_precomputedPath[1].z, true);
                else
                    init.MoveTo(i_x, i_y, i_z, true);
            }
        }
        else
            init.MoveTo(i_x, i_y, i_z, true);
 
        if (speed > 0.0f) // Default value for point motion type is 0.0, if 0.0 spline will use GetSpeed on unit
            init.SetVelocity(speed);
 
        if (_forcedMovement == FORCED_MOVEMENT_WALK)
            init.SetWalk(true);
        else if (_forcedMovement == FORCED_MOVEMENT_RUN)
            init.SetWalk(false);
 
        if (_animTier)
            init.SetAnimation(*_animTier);
 
        if (i_orientation > 0.0f)
            init.SetFacing(i_orientation);
 
        init.Launch();
    }
 
    // If finalized but we were stalled (paused) keep generator active so Finalize() won't be called
    if (unit->movespline->Finalized())
    {
        if (_hasBeenStalled)
            return true;
 
        return false;
    }
 
    return true;
}

References EVENT_CHARGE_PREPATH, FORCED_MOVEMENT_RUN, FORCED_MOVEMENT_WALK, Movement::MoveSplineInit::Launch(), Movement::MoveSplineInit::MovebyPath(), Movement::MoveSplineInit::MoveTo(), Movement::MoveSplineInit::SetAnimation(), Movement::MoveSplineInit::SetFacing(), Movement::MoveSplineInit::SetVelocity(), Movement::MoveSplineInit::SetWalk(), UNIT_STATE_CHARGING, UNIT_STATE_NOT_MOVE, and UNIT_STATE_ROAMING_MOVE.

GetDestination()

template<class T >

bool PointMovementGenerator< T >::GetDestination ( float &  x, float &  y, float &  z  ) const

inline

{ x = i_x; y = i_y; z = i_z; return true; }

References PointMovementGenerator< T >::i_x, PointMovementGenerator< T >::i_y, and PointMovementGenerator< T >::i_z.

GetMovementGeneratorType()

template<class T >

MovementGeneratorType PointMovementGenerator< T >::GetMovementGeneratorType ( )

inlineoverridevirtual

Implements MovementGenerator.

{ return POINT_MOTION_TYPE; }

References POINT_MOTION_TYPE.

MovementInform()

template<class T >

void PointMovementGenerator< T >::MovementInform

(

T *

)

{
}

Pause()

template<class T >

template void PointMovementGenerator< T >::Pause ( uint32  timer = 0 )

overridevirtual

Reimplemented from MovementGenerator.

{
    _stalled = timer ? false : true;
    _hasBeenStalled = true;
    if (timer)
        _pauseTime = static_cast<int32>(timer);
    else
        _pauseTime.reset();
}

Resume()

template<class T >

template void PointMovementGenerator< T >::Resume ( uint32  overrideTimer = 0 )

overridevirtual

Reimplemented from MovementGenerator.

{
    _hasBeenStalled = false;
    _stalled = false;
    if (overrideTimer)
        _pauseTime = static_cast<int32>(overrideTimer);
    else
        _pauseTime.reset();
 
    i_recalculateSpeed = true;
}

unitSpeedChanged()

template<class T >

void PointMovementGenerator< T >::unitSpeedChanged ( )

inlineoverridevirtual

Reimplemented from MovementGenerator.

{ i_recalculateSpeed = true; }

References PointMovementGenerator< T >::i_recalculateSpeed.

Member Data Documentation

_animTier

template<class T >

std::optional<AnimTier> PointMovementGenerator< T >::_animTier

private

_chargeTargetGUID

template<class T >

ObjectGuid PointMovementGenerator< T >::_chargeTargetGUID

private

_facingTargetGuid

template<class T >

ObjectGuid PointMovementGenerator< T >::_facingTargetGuid

private

_forceDestination

template<class T >

bool PointMovementGenerator< T >::_forceDestination

private

_forcedMovement

template<class T >

ForcedMovement PointMovementGenerator< T >::_forcedMovement

private

_generatePath

template<class T >

bool PointMovementGenerator< T >::_generatePath

private

_hasBeenStalled

template<class T >

bool PointMovementGenerator< T >::_hasBeenStalled {}

private

{};

_pauseTime

template<class T >

std::optional<int32> PointMovementGenerator< T >::_pauseTime

private

_reverseOrientation

template<class T >

bool PointMovementGenerator< T >::_reverseOrientation

private

_stalled

template<class T >

bool PointMovementGenerator< T >::_stalled {}

private

{};

i_orientation

template<class T >

float PointMovementGenerator< T >::i_orientation

private

i_recalculateSpeed

template<class T >

bool PointMovementGenerator< T >::i_recalculateSpeed {}

private

{};

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

i_x

template<class T >

float PointMovementGenerator< T >::i_x

private

Referenced by PointMovementGenerator< T >::GetDestination().

i_y

template<class T >

float PointMovementGenerator< T >::i_y

private

Referenced by PointMovementGenerator< T >::GetDestination().

i_z

template<class T >

float PointMovementGenerator< T >::i_z

private

Referenced by PointMovementGenerator< T >::GetDestination().

id

template<class T >

uint32 PointMovementGenerator< T >::id

private

m_precomputedPath

template<class T >

Movement::PointsArray PointMovementGenerator< T >::m_precomputedPath

private

Referenced by PointMovementGenerator< T >::PointMovementGenerator().

speed

template<class T >

float PointMovementGenerator< T >::speed

private

---

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

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