WaypointMovementGenerator< Creature > Class Reference

#include "WaypointMovementGenerator.h"

Inheritance diagram for WaypointMovementGenerator< Creature >:

Public Member Functions
	WaypointMovementGenerator (uint32 pathId=0, bool repeating=true, PathSource pathSource=PathSource::WAYPOINT_MGR)
	WaypointMovementGenerator (WaypointPath &path, bool repeating=true)
	~WaypointMovementGenerator ()
void	DoInitialize (Creature *)
void	DoFinalize (Creature *)
void	DoReset (Creature *)
bool	DoUpdate (Creature *, uint32 diff)
void	unitSpeedChanged () override
void	Pause (uint32 timer=0) override
void	Resume (uint32 overrideTimer=0) override
bool	GetResetPosition (float &x, float &y, float &z) override
MovementGeneratorType	GetMovementGeneratorType () override
Public Member Functions inherited from MovementGeneratorMedium< Creature, WaypointMovementGenerator< Creature > >
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
Public Member Functions inherited from PathMovementBase< T, P >
	PathMovementBase ()
	PathMovementBase (P path)
virtual	~PathMovementBase ()
uint32	GetCurrentNode () const

Private Member Functions
void	ProcessWaypointArrival (Creature *, WaypointNode const &)
void	StartMove (Creature *, bool relaunch=false)
bool	IsAllowedToMove (Creature *) const
void	UpdateWaypointState (Creature *, WaypointNode const &)

Private Attributes
uint32	_lastSplineId
uint32	_pathId
int32	_waypointDelay
std::optional< int32 >	_pauseTime
bool	_waypointReached
bool	_recalculateSpeed
bool	_repeating
bool	_loadedFromDB
bool	_stalled
bool	_hasBeenStalled
bool	_done
PathSource	_pathSource
bool	_smoothSplineLaunched
int32	_lastPassedSplineIdx

Additional Inherited Members
Protected Attributes inherited from PathMovementBase< T, P >
P	i_path
uint32	i_currentNode

Detailed Description

Constructor & Destructor Documentation

WaypointMovementGenerator() [1/2]

WaypointMovementGenerator< Creature >::WaypointMovementGenerator ( uint32  pathId = 0, bool  repeating = true, PathSource  pathSource = PathSource::WAYPOINT_MGR  )

explicit

                                                                                                                   : PathMovementBase((WaypointPath const*)nullptr),
    _lastSplineId(0), _pathId(pathId), _waypointDelay(0),
    _waypointReached(true), _recalculateSpeed(false), _repeating(repeating), _loadedFromDB(true), _stalled(false), _hasBeenStalled(false), _done(false), _pathSource(pathSource),
    _smoothSplineLaunched(false), _lastPassedSplineIdx(0)
{
}

WaypointMovementGenerator() [2/2]

WaypointMovementGenerator< Creature >::WaypointMovementGenerator ( WaypointPath &  path, bool  repeating = true  )

explicit

                                                                                                 : PathMovementBase((WaypointPath const*)nullptr),
    _lastSplineId(0), _pathId(0), _waypointDelay(0),
    _waypointReached(true), _recalculateSpeed(false), _repeating(repeating), _loadedFromDB(false), _stalled(false), _hasBeenStalled(false), _done(false), _pathSource(PathSource::WAYPOINT_MGR),
    _smoothSplineLaunched(false), _lastPassedSplineIdx(0)
{
    i_path = &path;
}

~WaypointMovementGenerator()

WaypointMovementGenerator< Creature >::~WaypointMovementGenerator ( )

inline

{ i_path = nullptr; }

Member Function Documentation

DoFinalize()

void WaypointMovementGenerator< Creature >::DoFinalize

(

Creature *

creature

)

{
    creature->ClearUnitState(UNIT_STATE_ROAMING | UNIT_STATE_ROAMING_MOVE);
}

References Unit::ClearUnitState(), UNIT_STATE_ROAMING, and UNIT_STATE_ROAMING_MOVE.

DoInitialize()

void WaypointMovementGenerator< Creature >::DoInitialize

(

Creature *

creature

)

{
    _done = false;
 
    if (_loadedFromDB)
    {
        if (!_pathId)
            _pathId = creature->GetWaypointPath();
 
        switch (_pathSource)
        {
            default:
            case PathSource::WAYPOINT_MGR:
                i_path = sWaypointMgr->GetPath(_pathId);
                break;
            case PathSource::SMART_WAYPOINT_MGR:
                i_path = sSmartWaypointMgr->GetPath(_pathId);
                break;
        }
    }
 
    if (!i_path)
    {
        LOG_ERROR("sql.sql", "WaypointMovementGenerator::DoInitialize: creature {} ({}) doesn't have waypoint path id: {}",
            creature->GetName(), creature->GetGUID().ToString(), _pathId);
        return;
    }
 
    // Determine our first waypoint from the creature's stored waypoint
    if (CreatureData const* creatureData = creature->GetCreatureData())
    {
        if (i_path->Nodes.size() > creatureData->currentwaypoint)
        {
            creature->UpdateCurrentWaypointInfo(creatureData->currentwaypoint, i_path->Id);
            i_currentNode = creatureData->currentwaypoint;
        }
    }
 
    creature->AddUnitState(UNIT_STATE_ROAMING | UNIT_STATE_ROAMING_MOVE);
 
    // Inform AI
    if (CreatureAI* AI = creature->AI())
        AI->WaypointPathStarted(i_path->Id);
}

References Unit::AddUnitState(), Creature::AI(), creatureData, Creature::GetCreatureData(), Object::GetGUID(), WorldObject::GetName(), Creature::GetWaypointPath(), LOG_ERROR, SMART_WAYPOINT_MGR, sSmartWaypointMgr, sWaypointMgr, ObjectGuid::ToString(), UNIT_STATE_ROAMING, UNIT_STATE_ROAMING_MOVE, Creature::UpdateCurrentWaypointInfo(), and WAYPOINT_MGR.

DoReset()

void WaypointMovementGenerator< Creature >::DoReset

(

Creature *

creature

)

{
    // We did not reach our last waypoint before reset, treat this scenario as resuming movement.
    if (!_done && !_waypointReached)
        _hasBeenStalled = true;
    else if (_done)
    {
        // mimic IdleMovementGenerator
        if (!creature->IsStopped())
            creature->StopMoving();
    }
}

References Unit::IsStopped(), and Unit::StopMoving().

DoUpdate()

bool WaypointMovementGenerator< Creature >::DoUpdate	(	Creature *	creature,
		uint32	diff
	)

{
    if (!creature || !creature->IsAlive())
        return true;
 
    if (_done || !i_path || i_path->Nodes.empty())
        return true;
 
    // Stop movement if paused, rooted, or casting
    if (!IsAllowedToMove(creature) && !creature->movespline->Finalized())
    {
        creature->StopMoving();
        _lastSplineId = 0;
        _smoothSplineLaunched = false;
    }
 
    // Set home position to current position.
    if (!creature->movespline->Finalized())
    {
        bool transportPath = creature->HasUnitMovementFlag(MOVEMENTFLAG_ONTRANSPORT) && creature->GetTransGUID();
        if (!transportPath)
            creature->SetHomePosition(creature->GetPosition());
    }
 
    // Smooth spline: track waypoint passages without rebuilding
    if (_smoothSplineLaunched && creature->movespline->GetId() == _lastSplineId)
    {
        int32 currentIdx = creature->movespline->currentPathIdx();
 
        // Process passed waypoints
        while (_lastPassedSplineIdx < currentIdx)
        {
            _lastPassedSplineIdx++;
            WaypointNode const& passedWp = i_path->Nodes.at(i_currentNode);
 
            UpdateHomePosition(creature, passedWp);
 
            // Save data before AI callbacks — they can invalidate the reference
            uint32 const wpId = passedWp.Id;
            uint32 const wpPathId = i_path->Id;
            uint32 const wpDelay = passedWp.Delay;
            std::optional<float> const wpOrientation = passedWp.Orientation;
 
            creature->UpdateWaypointID(wpId);
            creature->UpdateCurrentWaypointInfo(wpId, wpPathId);
 
            if (passedWp.EventId && urand(0, 99) < passedWp.EventChance)
            {
                creature->ClearUnitState(UNIT_STATE_ROAMING_MOVE);
                creature->GetMap()->ScriptsStart(sWaypointScripts, passedWp.EventId, creature, nullptr);
            }
 
            if (CreatureAI* AI = creature->AI())
            {
                AI->MovementInform(WAYPOINT_MOTION_TYPE, wpId);
                AI->WaypointReached(wpId, wpPathId);
            }
 
            // Advance node
            if (i_path && !i_path->Nodes.empty())
                i_currentNode = (i_currentNode + 1) % i_path->Nodes.size();
 
            // If this waypoint has a delay, stop the spline and pause
            if (wpDelay > 0)
            {
                creature->StopMoving();
                creature->ClearUnitState(UNIT_STATE_ROAMING_MOVE);
                _waypointDelay = wpDelay;
                _waypointReached = true;
                _smoothSplineLaunched = false;
                if (wpOrientation.has_value())
                    creature->SetFacingTo(*wpOrientation);
 
                return true;
            }
        }
 
        if (creature->movespline->Finalized())
        {
            if (!_repeating)
            {
                // Path ended
                uint32 const endWpId = i_path->Nodes.at(i_currentNode).Id;
                uint32 const endPathId = i_path->Id;
                _done = true;
                _smoothSplineLaunched = false;
                creature->UpdateCurrentWaypointInfo(0, 0);
                if (CreatureAI* AI = creature->AI())
                    AI->PathEndReached(endPathId);
 
                // Re-fetch AI — PathEndReached may have despawned the creature or swapped its AI
                if (CreatureAI* AI = creature->AI())
                    AI->WaypointPathEnded(endWpId, endPathId);
            }
            else
            {
                // Repeating: rebuild spline
                _smoothSplineLaunched = false;
                StartMove(creature);
            }
        }
 
        return true;
    }
 
    // Non-smooth: per-waypoint logic
    WaypointNode const& waypoint = i_path->Nodes.at(i_currentNode);
    UpdateWaypointState(creature, waypoint);
 
    // Process movement preventing timers
    if (_waypointDelay > 0)
    {
        _waypointDelay -= diff;
        if (_waypointDelay > 0)
            return true;
    }
 
    if (_pauseTime.has_value())
    {
        *_pauseTime -= diff;
        if (*_pauseTime > 0)
            return true;
        else
            _pauseTime.reset();
    }
 
    // Timers are ready, let's try to move
    if (IsAllowedToMove(creature) && (_waypointReached || _recalculateSpeed || _hasBeenStalled))
        StartMove(creature, _recalculateSpeed || _hasBeenStalled);
 
    return true;
}

References Creature::AI(), Unit::ClearUnitState(), Movement::MoveSpline::currentPathIdx(), WaypointNode::Delay, WaypointNode::EventChance, WaypointNode::EventId, Movement::MoveSpline::Finalized(), Movement::MoveSpline::GetId(), WorldObject::GetMap(), Position::GetPosition(), Unit::GetTransGUID(), Unit::HasUnitMovementFlag(), WaypointNode::Id, Unit::IsAlive(), MOVEMENTFLAG_ONTRANSPORT, Unit::movespline, WaypointNode::Orientation, Map::ScriptsStart(), Unit::SetFacingTo(), Creature::SetHomePosition(), Unit::StopMoving(), sWaypointScripts, UNIT_STATE_ROAMING_MOVE, Creature::UpdateCurrentWaypointInfo(), UpdateHomePosition(), Creature::UpdateWaypointID(), urand(), and WAYPOINT_MOTION_TYPE.

GetMovementGeneratorType()

MovementGeneratorType WaypointMovementGenerator< Creature >::GetMovementGeneratorType ( )

inlineoverridevirtual

Implements MovementGenerator.

{ return WAYPOINT_MOTION_TYPE; }

References WAYPOINT_MOTION_TYPE.

GetResetPosition()

bool WaypointMovementGenerator< Creature >::GetResetPosition ( float &  x, float &  y, float &  z  )

overridevirtual

Reimplemented from MovementGenerator.

{
    // prevent a crash at empty waypoint path.
    if (!i_path || i_path->Nodes.empty())
        return false;
 
    ASSERT(i_currentNode < i_path->Nodes.size(), "WaypointMovementGenerator::GetResetPos: tried to reference a node id ({}) which is not included in path ({})", i_currentNode, i_path->Id);
    WaypointNode const& waypoint = i_path->Nodes.at(i_currentNode);
 
    x = waypoint.X;
    y = waypoint.Y;
    z = waypoint.Z;
    return true;
}

References ASSERT, WaypointNode::X, WaypointNode::Y, and WaypointNode::Z.

IsAllowedToMove()

bool WaypointMovementGenerator< Creature >::IsAllowedToMove ( Creature *  creature ) const

private

{
    if (_stalled || _done)
        return false;
 
    if (_pauseTime.has_value())
        return false;
 
    if (creature->HasUnitState(UNIT_STATE_NOT_MOVE) || creature->IsMovementPreventedByCasting())
        return false;
 
    return true;
}

References Unit::HasUnitState(), Creature::IsMovementPreventedByCasting(), and UNIT_STATE_NOT_MOVE.

Pause()

void WaypointMovementGenerator< Creature >::Pause ( uint32  timer = 0 )

overridevirtual

Reimplemented from MovementGenerator.

{
    _stalled = timer ? false : true;
    _hasBeenStalled = !_waypointReached;
    _pauseTime = timer;
}

ProcessWaypointArrival()

void WaypointMovementGenerator< Creature >::ProcessWaypointArrival ( Creature *  creature, WaypointNode const &  waypoint  )

private

{
    if (_waypointReached)
        return;
 
    if (waypoint.Delay > 0)
    {
        creature->ClearUnitState(UNIT_STATE_ROAMING_MOVE);
        _waypointDelay = waypoint.Delay;
    }
 
    bool pathEnded = (i_currentNode == i_path->Nodes.size() - 1) && !_repeating && !_done;
    if (pathEnded)
        _done = true;
 
    UpdateHomePosition(creature, waypoint);
 
    if (waypoint.EventId && urand(0, 99) < waypoint.EventChance)
    {
        LOG_DEBUG("maps.script", "Creature movement start script {} at point {} for {}.",
            waypoint.EventId, i_currentNode, creature->GetGUID().ToString());
        creature->ClearUnitState(UNIT_STATE_ROAMING_MOVE);
        creature->GetMap()->ScriptsStart(sWaypointScripts, waypoint.EventId, creature, nullptr);
    }
 
    // scripts can invalidate current path, store what we need
    uint32 const waypointId = waypoint.Id;
    uint32 const pathId = i_path->Id;
 
    creature->UpdateWaypointID(waypointId);
    creature->UpdateCurrentWaypointInfo(waypointId, pathId);
 
    // Inform AI
    if (CreatureAI* AI = creature->AI())
    {
        AI->MovementInform(WAYPOINT_MOTION_TYPE, waypointId);
        AI->WaypointReached(waypointId, pathId);
    }
 
    if (Unit* owner = creature->GetCharmerOrOwner())
    {
        if (UnitAI* AI = owner->GetAI())
            AI->SummonMovementInform(creature, WAYPOINT_MOTION_TYPE, waypointId);
    }
    else
    {
        if (TempSummon* tempSummon = creature->ToTempSummon())
            if (Unit* owner2 = tempSummon->GetSummonerUnit())
                if (UnitAI* AI = owner2->GetAI())
                    AI->SummonMovementInform(creature, WAYPOINT_MOTION_TYPE, waypointId);
    }
 
    // Path end notifications fire after WaypointReached so that m_path_id
    // is still valid when SmartAI checks it for SMART_EVENT_WAYPOINT_REACHED.
    if (pathEnded)
    {
        creature->UpdateCurrentWaypointInfo(0, 0);
 
        if (CreatureAI* AI = creature->AI())
            AI->PathEndReached(pathId);
 
        // Re-fetch AI — PathEndReached may have despawned the creature or swapped its AI
        if (CreatureAI* AI = creature->AI())
            AI->WaypointPathEnded(waypointId, pathId);
    }
 
    // All hooks called and infos updated. Time to increment the waypoint node id
    if (i_path && !i_path->Nodes.empty()) // ensure that the path has not been changed in one of the hooks.
        i_currentNode = (i_currentNode + 1) % i_path->Nodes.size();
 
    _waypointReached = true;
}

References Creature::AI(), Unit::ClearUnitState(), WaypointNode::Delay, WaypointNode::EventChance, WaypointNode::EventId, Unit::GetCharmerOrOwner(), Object::GetGUID(), WorldObject::GetMap(), WaypointNode::Id, LOG_DEBUG, Map::ScriptsStart(), sWaypointScripts, ObjectGuid::ToString(), Unit::ToTempSummon(), UNIT_STATE_ROAMING_MOVE, Creature::UpdateCurrentWaypointInfo(), UpdateHomePosition(), Creature::UpdateWaypointID(), urand(), and WAYPOINT_MOTION_TYPE.

Resume()

void WaypointMovementGenerator< Creature >::Resume ( uint32  overrideTimer = 0 )

overridevirtual

Reimplemented from MovementGenerator.

{
    _hasBeenStalled = !_waypointReached;
    _stalled = false;
    if (overrideTimer)
        _pauseTime = overrideTimer;
}

StartMove()

void WaypointMovementGenerator< Creature >::StartMove ( Creature *  creature, bool  relaunch = false  )

private

If the creature is on transport, we assume waypoints set in DB are already transport offsets

{
    // Formation checks. Do not launch a new spline when one of our formation members is currently in combat.
    if (!relaunch)
    {
        if (!IsAllowedToMove(creature) || (creature->IsFormationLeader() && !creature->IsFormationLeaderMoveAllowed()))
        {
            _waypointDelay = 1000;
            return;
        }
    }
 
    // Dont allow dead creatures to move
    if (!creature->IsAlive())
        return;
 
    // Step two: node selection is done, build spline data
    creature->AddUnitState(UNIT_STATE_ROAMING_MOVE);
    WaypointNode const& waypoint = i_path->Nodes.at(i_currentNode);
    bool const useTransportPath = creature->HasUnitMovementFlag(MOVEMENTFLAG_ONTRANSPORT) && creature->GetTransGUID();
 
    Movement::MoveSplineInit init(creature);
    if (useTransportPath)
        init.DisableTransportPathTransformations();
 
    if (waypoint.SmoothTransition && i_path->Nodes.size() > 2)
    {
        // Build a catmullrom spline segment, stopping at delay waypoints
        init.Path().push_back(PositionToVector3(creature->GetPosition()));
 
        bool hasDelayInSegment = false;
        uint32 segmentNodes = 0;
        for (uint32 i = 0; i < i_path->Nodes.size(); ++i)
        {
            uint32 idx = (i_currentNode + i) % i_path->Nodes.size();
            WaypointNode const& node = i_path->Nodes.at(idx);
            init.Path().push_back(G3D::Vector3(node.X, node.Y, node.Z));
            segmentNodes++;
 
            // Stop the segment at a waypoint with a delay
            if (node.Delay > 0)
            {
                hasDelayInSegment = true;
                break;
            }
        }
 
        // If no delays found and repeating, add wrap-around points for seamless loop
        if (!hasDelayInSegment && _repeating)
        {
            for (uint32 i = 0; i < std::min<uint32>(3, i_path->Nodes.size()); ++i)
            {
                uint32 idx = (i_currentNode + i) % i_path->Nodes.size();
                WaypointNode const& node = i_path->Nodes.at(idx);
                init.Path().push_back(G3D::Vector3(node.X, node.Y, node.Z));
            }
        }
 
        // Need at least 3 waypoints for a meaningful catmullrom spline
        if (segmentNodes >= 3)
        {
            init.SetFirstPointId(i_currentNode);
            init.SetSmooth();
            _smoothSplineLaunched = true;
            _lastPassedSplineIdx = i_currentNode;
        }
        else
        {
            // Too few points for catmullrom, fall back to linear point-to-point
            init.Path().clear();
            init.MoveTo(G3D::Vector3(waypoint.X, waypoint.Y, waypoint.Z));
        }
    }
    else if (!waypoint.SplinePoints.empty())
    {
        // We have spline points in waypoint_data_addon table
        int32 splineIndex = 0;
 
        auto itr = waypoint.SplinePoints.begin();
        if (splineIndex)
            std::advance(itr, splineIndex);
 
        init.Path().reserve(waypoint.SplinePoints.size() - splineIndex);
        std::copy(itr, waypoint.SplinePoints.end(), std::back_inserter(init.Path()));
 
        // Add starting vertex and destination
        init.Path().insert(init.Path().begin(), PositionToVector3(creature->GetPosition()));
        init.Path().insert(init.Path().end(), G3D::Vector3(waypoint.X, waypoint.Y, waypoint.Z));
    }
    else
    {
        // Smooth transition for short paths (<=2 nodes): use previous spline endpoint as start
        if (waypoint.SmoothTransition && !creature->movespline->Finalized() && _lastSplineId == creature->movespline->GetId())
        {
            init.MoveTo(creature->movespline->FinalDestination(), G3D::Vector3(waypoint.X, waypoint.Y, waypoint.Z));
            if (!init.Path().empty())
                init.Path().insert(init.Path().begin(), PositionToVector3(creature->GetPosition()));
        }
        else
            init.MoveTo(PositionToVector3(creature->GetPosition()), G3D::Vector3(waypoint.X, waypoint.Y, waypoint.Z));
    }
 
    if (waypoint.Orientation.has_value() && waypoint.Delay > 0)
        init.SetFacing(*waypoint.Orientation);
 
    switch (waypoint.MoveType)
    {
        case WAYPOINT_MOVE_TYPE_LAND:
            init.SetAnimation(AnimTier::Ground);
            break;
        case WAYPOINT_MOVE_TYPE_TAKEOFF:
            init.SetAnimation(AnimTier::Hover);
            break;
        case WAYPOINT_MOVE_TYPE_RUN:
            init.SetWalk(false);
            break;
        case WAYPOINT_MOVE_TYPE_WALK:
            init.SetWalk(true);
            break;
        default:
            break;
    }
 
    if (creature->CanFly())
        init.SetFly();
 
    if (waypoint.Velocity > 0.f)
        init.SetVelocity(waypoint.Velocity);
 
    init.Launch();
 
    if (!creature->movespline->Finalized())
        _lastSplineId = creature->movespline->GetId();
 
    // Inform formation
    creature->SignalFormationMovement();
 
    // Inform AI
    if (!relaunch)
        if (CreatureAI* AI = creature->AI())
            AI->WaypointStarted(waypoint.Id, i_path->Id);
 
    _waypointReached = false;
    _recalculateSpeed = false;
    _hasBeenStalled = false;
}

References Unit::AddUnitState(), Creature::AI(), Creature::CanFly(), WaypointNode::Delay, Movement::MoveSplineInit::DisableTransportPathTransformations(), Movement::MoveSpline::FinalDestination(), Movement::MoveSpline::Finalized(), Movement::MoveSpline::GetId(), Position::GetPosition(), Unit::GetTransGUID(), Ground, Unit::HasUnitMovementFlag(), Hover, WaypointNode::Id, Unit::IsAlive(), Creature::IsFormationLeader(), Creature::IsFormationLeaderMoveAllowed(), Movement::MoveSplineInit::Launch(), MOVEMENTFLAG_ONTRANSPORT, Unit::movespline, Movement::MoveSplineInit::MoveTo(), WaypointNode::MoveType, WaypointNode::Orientation, Movement::MoveSplineInit::Path(), PositionToVector3(), Movement::MoveSplineInit::SetAnimation(), Movement::MoveSplineInit::SetFacing(), Movement::MoveSplineInit::SetFirstPointId(), Movement::MoveSplineInit::SetFly(), Movement::MoveSplineInit::SetSmooth(), Movement::MoveSplineInit::SetVelocity(), Movement::MoveSplineInit::SetWalk(), Creature::SignalFormationMovement(), WaypointNode::SmoothTransition, WaypointNode::SplinePoints, UNIT_STATE_ROAMING_MOVE, WaypointNode::Velocity, WAYPOINT_MOVE_TYPE_LAND, WAYPOINT_MOVE_TYPE_RUN, WAYPOINT_MOVE_TYPE_TAKEOFF, WAYPOINT_MOVE_TYPE_WALK, WaypointNode::X, WaypointNode::Y, and WaypointNode::Z.

unitSpeedChanged()

void WaypointMovementGenerator< Creature >::unitSpeedChanged ( )

inlineoverridevirtual

Reimplemented from MovementGenerator.

{ _recalculateSpeed = true; }

UpdateWaypointState()

void WaypointMovementGenerator< Creature >::UpdateWaypointState ( Creature *  creature, WaypointNode const &  waypointNode  )

private

{
    if (creature->movespline->GetId() != _lastSplineId)
        return;
 
    if (creature->movespline->Finalized())
        ProcessWaypointArrival(creature, waypointNode);
}

References Movement::MoveSpline::Finalized(), Movement::MoveSpline::GetId(), and Unit::movespline.

Member Data Documentation

_done

bool WaypointMovementGenerator< Creature >::_done

private

_hasBeenStalled

bool WaypointMovementGenerator< Creature >::_hasBeenStalled

private

_lastPassedSplineIdx

int32 WaypointMovementGenerator< Creature >::_lastPassedSplineIdx

private

_lastSplineId

uint32 WaypointMovementGenerator< Creature >::_lastSplineId

private

_loadedFromDB

bool WaypointMovementGenerator< Creature >::_loadedFromDB

private

_pathId

uint32 WaypointMovementGenerator< Creature >::_pathId

private

_pathSource

PathSource WaypointMovementGenerator< Creature >::_pathSource

private

_pauseTime

std::optional<int32> WaypointMovementGenerator< Creature >::_pauseTime

private

_recalculateSpeed

bool WaypointMovementGenerator< Creature >::_recalculateSpeed

private

_repeating

bool WaypointMovementGenerator< Creature >::_repeating

private

_smoothSplineLaunched

bool WaypointMovementGenerator< Creature >::_smoothSplineLaunched

private

_stalled

bool WaypointMovementGenerator< Creature >::_stalled

private

_waypointDelay

int32 WaypointMovementGenerator< Creature >::_waypointDelay

private

_waypointReached

bool WaypointMovementGenerator< Creature >::_waypointReached

private

---

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

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