#include "PointMovementGenerator.h"

Inheritance diagram for PointMovementGenerator< T >:

Public Member Functions
	PointMovementGenerator (uint32 _id, float _x, float _y, float _z, float _speed=0.0f, float orientation=0.0f, const Movement::PointsArray *_path=nullptr, bool generatePath=false, bool forceDestination=false, ObjectGuid chargeTargetGUID=ObjectGuid::Empty)

void	DoInitialize (T *)

void	DoFinalize (T *)

void	DoReset (T *)

bool	DoUpdate (T *, uint32)

void	MovementInform (T *)

void	unitSpeedChanged ()

MovementGeneratorType	GetMovementGeneratorType ()

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 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
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

ObjectGuid	_chargeTargetGUID

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,
		float	_speed = `0.0f`,
		float	orientation = `0.0f`,
		const Movement::PointsArray *	_path = `nullptr`,
		bool	generatePath = `false`,
		bool	forceDestination = `false`,
		ObjectGuid	chargeTargetGUID = `ObjectGuid::Empty`
	)

inline

        : id(_id), i_x(_x), i_y(_y), i_z(_z), speed(_speed), i_orientation(orientation), _generatePath(generatePath), _forceDestination(forceDestination),
        _chargeTargetGUID(chargeTargetGUID)
    {
        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);
            }
        }
    }
 
    if (unit->movespline->Finalized())
        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.

{
    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 (i_orientation > 0.0f)
    {
        init.SetFacing(i_orientation);
    }
 
    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 (id != EVENT_CHARGE_PREPATH && i_recalculateSpeed && !unit->movespline->Finalized())
    {
        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);
        }
        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 (i_orientation > 0.0f)
        {
            init.SetFacing(i_orientation);
        }
 
        init.Launch();
    }
 
    return !unit->movespline->Finalized();
}