#include "EscortMovementGenerator.h"

Inheritance diagram for EscortMovementGenerator< T >:

Public Member Functions
	EscortMovementGenerator (Movement::PointsArray *_path=nullptr)

void	DoInitialize (T *)

void	DoFinalize (T *)

void	DoReset (T *)

bool	DoUpdate (T *, uint32)

void	unitSpeedChanged ()

MovementGeneratorType	GetMovementGeneratorType ()

uint32	GetSplineId () const

Public Member Functions inherited from MovementGeneratorMedium< T, EscortMovementGenerator< 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 void	Initialize (Unit *)=0

virtual void	Finalize (Unit *)=0

virtual void	Reset (Unit *)=0

virtual bool	Update (Unit *, uint32 time_diff)=0

virtual MovementGeneratorType	GetMovementGeneratorType ()=0

virtual uint32	GetSplineId () const

virtual void	unitSpeedChanged ()

virtual void	Pause (uint32)

virtual void	Resume (uint32)

virtual bool	GetResetPosition (float &, float &, float &)

Private Attributes
bool	i_recalculateSpeed

Movement::PointsArray	m_precomputedPath

uint32	_splineId

Detailed Description

template<class T>
class EscortMovementGenerator< T >

Constructor & Destructor Documentation

◆ EscortMovementGenerator()

template<class T >

EscortMovementGenerator< T >::EscortMovementGenerator ( Movement::PointsArray * _path = nullptr )

inline

                                                                  : i_recalculateSpeed(false)
    {
        if (_path)
            m_precomputedPath = *_path;
    }

References EscortMovementGenerator< T >::m_precomputedPath.

Member Function Documentation

◆ DoFinalize()

template<class T >

template void EscortMovementGenerator< T >::DoFinalize ( T * )

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

References UNIT_STATE_ROAMING, and UNIT_STATE_ROAMING_MOVE.

◆ DoInitialize()

template<class T >

template void EscortMovementGenerator< T >::DoInitialize ( T * )

{
    if (!unit->IsStopped())
        unit->StopMoving();
 
    unit->AddUnitState(UNIT_STATE_ROAMING | UNIT_STATE_ROAMING_MOVE);
    i_recalculateSpeed = false;
    Movement::MoveSplineInit init(unit);
 
    if (m_precomputedPath.size() == 2) // xinef: simple case, just call move to
        init.MoveTo(m_precomputedPath[1].x, m_precomputedPath[1].y, m_precomputedPath[1].z, true);
    else if (m_precomputedPath.size())
        init.MovebyPath(m_precomputedPath);
 
    init.Launch();
 
    _splineId = unit->movespline->GetId();
}

References Movement::MoveSplineInit::Launch(), Movement::MoveSplineInit::MovebyPath(), Movement::MoveSplineInit::MoveTo(), UNIT_STATE_ROAMING, and UNIT_STATE_ROAMING_MOVE.

◆ DoReset()

template<class T >

template void EscortMovementGenerator< T >::DoReset ( T * )

{
    if (!unit->IsStopped())
        unit->StopMoving();
 
    unit->AddUnitState(UNIT_STATE_ROAMING | UNIT_STATE_ROAMING_MOVE);
}

References UNIT_STATE_ROAMING, and UNIT_STATE_ROAMING_MOVE.

◆ DoUpdate()

template<class T >

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

{
    if (!unit)
        return false;
 
    if (unit->HasUnitState(UNIT_STATE_NOT_MOVE) || unit->IsMovementPreventedByCasting())
    {
        unit->ClearUnitState(UNIT_STATE_ROAMING_MOVE);
        return true;
    }
 
    unit->AddUnitState(UNIT_STATE_ROAMING_MOVE);
 
    bool arrived = unit->movespline->Finalized();
 
    if (i_recalculateSpeed && !arrived)
    {
        i_recalculateSpeed = false;
        Movement::MoveSplineInit init(unit);
 
        // xinef: speed changed during path execution, calculate remaining path and launch it once more
        if (m_precomputedPath.size())
        {
            uint32 offset = std::min(uint32(unit->movespline->_currentSplineIdx()), uint32(m_precomputedPath.size()));
            Movement::PointsArray::iterator offsetItr = m_precomputedPath.begin();
            std::advance(offsetItr, offset);
            m_precomputedPath.erase(m_precomputedPath.begin(), offsetItr);
 
            // restore 0 element (current position)
            m_precomputedPath.insert(m_precomputedPath.begin(), G3D::Vector3(unit->GetPositionX(), unit->GetPositionY(), unit->GetPositionZ()));
 
            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);
        }
 
        init.Launch();
        // Xinef: Override spline Id on recalculate launch
        _splineId = unit->movespline->GetId();
    }
 
    return !arrived;
}