Movement::MoveSpline Class Reference

#include "MoveSpline.h"

Public Types
enum	UpdateResult {   Result_None = 0x01 ,   Result_Arrived = 0x02 ,   Result_NextCycle = 0x04 ,   Result_NextSegment = 0x08 ,   Result_JustArrived = 0x10 }
typedef Spline< int32 >	MySpline

Public Member Functions
int32	timeElapsed () const
int32	timePassed () const
int32	Duration () const
MySpline const &	_Spline () const
int32	_currentSplineIdx () const
void	_Finalize ()
void	_Interrupt ()
void	Initialize (const MoveSplineInitArgs &)
bool	Initialized () const
	MoveSpline ()
template<class UpdateHandler >
void	updateState (int32 difftime, UpdateHandler &handler)
void	updateState (int32 difftime)
Location	ComputePosition () const
uint32	GetId () const
bool	Finalized () const
bool	isCyclic () const
bool	isFalling () const
bool	isWalking () const
Vector3	FinalDestination () const
Vector3	CurrentDestination () const
int32	currentPathIdx () const
bool	HasAnimation () const
uint8	GetAnimationType () const
std::string	ToString () const
bool	HasStarted () const

Public Attributes
bool	onTransport

Protected Member Functions
void	init_spline (const MoveSplineInitArgs &args)
const MySpline::ControlArray &	getPath () const
void	computeParabolicElevation (float &el) const
void	computeFallElevation (float &el) const
UpdateResult	_updateState (int32 &ms_time_diff)
	============================================================================================ More...
int32	next_timestamp () const
int32	segment_time_elapsed () const

Protected Attributes
MySpline	spline
FacingInfo	facing
uint32	m_Id
MoveSplineFlag	splineflags
int32	time_passed
float	vertical_acceleration
float	initialOrientation
int32	effect_start_time
int32	point_Idx
int32	point_Idx_offset

Friends
class	PacketBuilder

Detailed Description

Member Typedef Documentation

MySpline

typedef Spline<int32> Movement::MoveSpline::MySpline

Member Enumeration Documentation

UpdateResult

enum Movement::MoveSpline::UpdateResult

Enumerator
Result_None
Result_Arrived
Result_NextCycle
Result_NextSegment
Result_JustArrived

        {
            Result_None         = 0x01,
            Result_Arrived      = 0x02,
            Result_NextCycle    = 0x04,
            Result_NextSegment  = 0x08,
            Result_JustArrived  = 0x10,
        };

Constructor & Destructor Documentation

MoveSpline()

Movement::MoveSpline::MoveSpline

(

)

                           : m_Id(0), time_passed(0),
        vertical_acceleration(0.f), initialOrientation(0.f), effect_start_time(0), point_Idx(0), point_Idx_offset(0),
        onTransport(false)
    {
        splineflags.done = true;
    }

References Movement::MoveSplineFlag::done, and splineflags.

Member Function Documentation

_currentSplineIdx()

int32 Movement::MoveSpline::_currentSplineIdx ( ) const

inline

{ return point_Idx; }

References point_Idx.

_Finalize()

void Movement::MoveSpline::_Finalize

(

)

    {
        splineflags.done = true;
        point_Idx = spline.last() - 1;
        time_passed = Duration();
    }

References Movement::MoveSplineFlag::done, Duration(), Movement::SplineBase::last(), point_Idx, spline, splineflags, and time_passed.

Referenced by _updateState().

_Interrupt()

void Movement::MoveSpline::_Interrupt ( )

inline

{ splineflags.done = true; }

References Movement::MoveSplineFlag::done, and splineflags.

Referenced by Unit::DisableSpline().

_Spline()

MySpline const & Movement::MoveSpline::_Spline ( ) const

inline

{ return spline; }

References spline.

_updateState()

MoveSpline::UpdateResult Movement::MoveSpline::_updateState ( int32 &  ms_time_diff )

protected

============================================================================================

    {
        if (Finalized())
        {
            ms_time_diff = 0;
            return Result_Arrived;
        }
 
        UpdateResult result = Result_None;
 
        int32 minimal_diff = std::min(ms_time_diff, segment_time_elapsed());
        if (minimal_diff < 0)
            minimal_diff = 0;
 
        ASSERT(minimal_diff >= 0);
        time_passed += minimal_diff;
        ms_time_diff -= minimal_diff;
 
        if (time_passed >= next_timestamp())
        {
            ++point_Idx;
            if (point_Idx < spline.last())
            {
                result = Result_NextSegment;
            }
            else
            {
                if (spline.isCyclic())
                {
                    point_Idx = spline.first();
                    time_passed = time_passed % Duration();
                    result = Movement::MoveSpline::UpdateResult(Result_NextCycle | Result_JustArrived);
                }
                else
                {
                    _Finalize();
                    ms_time_diff = 0;
                    result = Movement::MoveSpline::UpdateResult(Result_Arrived | Result_JustArrived);
                }
            }
        }
 
        return result;
    }

References _Finalize(), ASSERT, Duration(), Finalized(), Movement::SplineBase::first(), Movement::SplineBase::isCyclic(), Movement::SplineBase::last(), next_timestamp(), point_Idx, Result_Arrived, Result_JustArrived, Result_NextCycle, Result_NextSegment, Result_None, segment_time_elapsed(), spline, and time_passed.

Referenced by updateState().

computeFallElevation()

void Movement::MoveSpline::computeFallElevation ( float &  el ) const

protected

    {
        float z_now = spline.getPoint(spline.first()).z - Movement::computeFallElevation(MSToSec(time_passed), false);
        float final_z = FinalDestination().z;
        el = std::max(z_now, final_z);
    }

References Movement::computeFallElevation(), FinalDestination(), Movement::SplineBase::first(), Movement::SplineBase::getPoint(), Movement::MSToSec(), spline, and time_passed.

Referenced by ComputePosition().

computeParabolicElevation()

void Movement::MoveSpline::computeParabolicElevation ( float &  el ) const

protected

    {
        if (time_passed > effect_start_time)
        {
            float t_passedf = MSToSec(time_passed - effect_start_time);
            float t_durationf = MSToSec(Duration() - effect_start_time); //client use not modified duration here
 
            // -a*x*x + bx + c:
            //(dur * v3->z_acceleration * dt)/2 - (v3->z_acceleration * dt * dt)/2 + Z;
            el += (t_durationf - t_passedf) * 0.5f * vertical_acceleration * t_passedf;
        }
    }

References Duration(), effect_start_time, Movement::MSToSec(), time_passed, and vertical_acceleration.

Referenced by ComputePosition().

ComputePosition()

Location Movement::MoveSpline::ComputePosition

(

)

const

    {
        ASSERT(Initialized());
 
        float u = 1.f;
        int32 seg_time = spline.length(point_Idx, point_Idx + 1);
        if (seg_time > 0)
            u = (time_passed - spline.length(point_Idx)) / (float)seg_time;
        Location c;
        c.orientation = initialOrientation;
        spline.evaluate_percent(point_Idx, u, c);
 
        if (splineflags.animation)
            ;// MoveSplineFlag::Animation disables falling or parabolic movement
        else if (splineflags.parabolic)
            computeParabolicElevation(c.z);
        else if (splineflags.falling)
            computeFallElevation(c.z);
 
        if (splineflags.done && splineflags.isFacing())
        {
            if (splineflags.final_angle)
                c.orientation = facing.angle;
            else if (splineflags.final_point)
                c.orientation = std::atan2(facing.f.y - c.y, facing.f.x - c.x);
            //nothing to do for MoveSplineFlag::Final_Target flag
        }
        else
        {
            if (!splineflags.hasFlag(MoveSplineFlag::OrientationFixed | MoveSplineFlag::Falling))
            {
                Vector3 hermite;
                spline.evaluate_derivative(point_Idx, u, hermite);
                c.orientation = std::atan2(hermite.y, hermite.x);
            }
 
            if (splineflags.orientationInversed)
                c.orientation = -c.orientation;
        }
        return c;
    }

References Movement::FacingInfo::angle, Movement::MoveSplineFlag::animation, ASSERT, computeFallElevation(), computeParabolicElevation(), Movement::MoveSplineFlag::done, Movement::Spline< length_type >::evaluate_derivative(), Movement::Spline< length_type >::evaluate_percent(), Movement::FacingInfo::f, facing, Movement::MoveSplineFlag::Falling, Movement::MoveSplineFlag::falling, Movement::MoveSplineFlag::final_angle, Movement::MoveSplineFlag::final_point, Movement::MoveSplineFlag::hasFlag(), Initialized(), initialOrientation, Movement::MoveSplineFlag::isFacing(), Movement::Spline< length_type >::length(), Movement::Location::orientation, Movement::MoveSplineFlag::OrientationFixed, Movement::MoveSplineFlag::orientationInversed, Movement::MoveSplineFlag::parabolic, point_Idx, spline, splineflags, time_passed, Movement::FacingInfo::x, and Movement::FacingInfo::y.

Referenced by Movement::MoveSplineInit::Launch(), Movement::MoveSplineInit::Stop(), and Unit::UpdateSplinePosition().

CurrentDestination()

Vector3 Movement::MoveSpline::CurrentDestination ( ) const

inline

{ return Initialized() ? spline.getPoint(point_Idx + 1) : Vector3(); }

References Movement::SplineBase::getPoint(), Initialized(), point_Idx, and spline.

currentPathIdx()

int32 Movement::MoveSpline::currentPathIdx

(

)

const

    {
        int32 point = point_Idx_offset + point_Idx - spline.first() + (int)Finalized();
        if (isCyclic())
            point = point % (spline.last() - spline.first());
        return point;
    }

References Finalized(), Movement::SplineBase::first(), isCyclic(), Movement::SplineBase::last(), point_Idx, point_Idx_offset, and spline.

Referenced by FlightPathMovementGenerator::DoUpdate(), SplineHandler::operator()(), and ToString().

Duration()

int32 Movement::MoveSpline::Duration ( ) const

inline

{ return spline.length(); }

References Movement::Spline< length_type >::length(), and spline.

Referenced by _Finalize(), _updateState(), computeParabolicElevation(), Initialize(), Movement::MoveSplineInit::Launch(), timeElapsed(), ToString(), Movement::PacketBuilder::WriteCommonMonsterMovePart(), and Movement::PacketBuilder::WriteCreate().

FinalDestination()

Vector3 Movement::MoveSpline::FinalDestination ( ) const

inline

{ return Initialized() ? spline.getPoint(spline.last()) : Vector3(); }

References Movement::SplineBase::getPoint(), Initialized(), Movement::SplineBase::last(), and spline.

Referenced by computeFallElevation(), MotionMaster::GetDestination(), CharmInfo::SaveStayPosition(), and Movement::PacketBuilder::WriteCreate().

Finalized()

bool Movement::MoveSpline::Finalized ( ) const

inline

{ return splineflags.done; }

References Movement::MoveSplineFlag::done, and splineflags.

Referenced by _updateState(), currentPathIdx(), HomeMovementGenerator< Creature >::DoUpdate(), WaypointMovementGenerator< Creature >::DoUpdate(), RandomMovementGenerator< T >::DoUpdate(), Creature::FocusTarget(), MotionMaster::GetDestination(), WorldSession::HandleMovementOpcodes(), WorldSession::HandleSetRaidDifficultyOpcode(), Unit::IsFalling(), Movement::MoveSplineInit::Launch(), boss_captain_skarloc::MovementInform(), boss_razorscale::boss_razorscaleAI::MovementInform(), boss_alar::MovementInform(), npc_wild_wyrm::npc_wild_wyrmAI::MovementInform(), npc_hor_lich_king::npc_hor_lich_kingAI::MovementInform(), npc_hor_leader_second::npc_hor_leader_secondAI::MovementInform(), npc_freed_protodrake::npc_freed_protodrakeAI::MovementInform(), SmartAI::MovepointReached(), Unit::SetRooted(), Movement::MoveSplineInit::Stop(), Unit::StopMoving(), EffectMovementGenerator::Update(), npc_escortAI::UpdateAI(), SmartAI::UpdatePath(), and Unit::UpdateSplineMovement().

GetAnimationType()

uint8 Movement::MoveSpline::GetAnimationType ( ) const

inline

{ return splineflags.animId; }

References Movement::MoveSplineFlag::animId, and splineflags.

Referenced by Unit::UpdateSplineMovement().

GetId()

uint32 Movement::MoveSpline::GetId ( ) const

inline

{ return m_Id; }

References m_Id.

Referenced by SplineHandler::operator()(), ToString(), Movement::PacketBuilder::WriteCommonMonsterMovePart(), and Movement::PacketBuilder::WriteCreate().

getPath()

const MySpline::ControlArray & Movement::MoveSpline::getPath ( ) const

inlineprotected

{ return spline.getPoints(); }

References Movement::SplineBase::getPoints(), and spline.

Referenced by Movement::PacketBuilder::WriteCreate().

HasAnimation()

bool Movement::MoveSpline::HasAnimation ( ) const

inline

{ return splineflags.animation; }

References Movement::MoveSplineFlag::animation, and splineflags.

Referenced by Unit::UpdateSplineMovement().

HasStarted()

bool Movement::MoveSpline::HasStarted ( ) const

inline

        {
            return time_passed > 0;
        }

References time_passed.

Referenced by Unit::StopMoving().

init_spline()

void Movement::MoveSpline::init_spline ( const MoveSplineInitArgs &  args )

protected

Todo:

: what to do in such cases? problem is in input data (all points are at same coords)

    {
        const SplineBase::EvaluationMode modes[2] = {SplineBase::ModeLinear, SplineBase::ModeCatmullrom};
        if (args.flags.cyclic)
        {
            uint32 cyclic_point = 0;
            // MoveSplineFlag::Enter_Cycle support dropped
            //if (splineflags & SPLINEFLAG_ENTER_CYCLE)
            //cyclic_point = 1;   // shouldn't be modified, came from client
            spline.init_cyclic_spline(&args.path[0], args.path.size(), modes[args.flags.isSmooth()], cyclic_point);
        }
        else
        {
            spline.init_spline(&args.path[0], args.path.size(), modes[args.flags.isSmooth()]);
        }
 
        // init spline timestamps
        if (splineflags.falling)
        {
            FallInitializer init(spline.getPoint(spline.first()).z);
            spline.initLengths(init);
        }
        else
        {
            CommonInitializer init(args.velocity);
            spline.initLengths(init);
        }
 
        if (spline.length() < minimal_duration)
        {
            spline.set_length(spline.last(), spline.isCyclic() ? 1000 : 1);
        }
        point_Idx = spline.first();
    }

References Movement::MoveSplineFlag::cyclic, Movement::MoveSplineFlag::falling, Movement::SplineBase::first(), Movement::MoveSplineInitArgs::flags, Movement::SplineBase::getPoint(), Movement::Spline< length_type >::init_cyclic_spline(), Movement::Spline< length_type >::init_spline(), Movement::Spline< length_type >::initLengths(), Movement::SplineBase::isCyclic(), Movement::MoveSplineFlag::isSmooth(), Movement::SplineBase::last(), Movement::Spline< length_type >::length(), Movement::minimal_duration, Movement::SplineBase::ModeCatmullrom, Movement::SplineBase::ModeLinear, Movement::MoveSplineInitArgs::path, point_Idx, Movement::Spline< length_type >::set_length(), spline, splineflags, and Movement::MoveSplineInitArgs::velocity.

Referenced by Initialize().

Initialize()

void Movement::MoveSpline::Initialize

(

const MoveSplineInitArgs &

args

)

    {
        splineflags = args.flags;
        facing = args.facing;
        m_Id = args.splineId;
        point_Idx_offset = args.path_Idx_offset;
        initialOrientation = args.initialOrientation;
 
        time_passed = 0;
        vertical_acceleration = 0.f;
        effect_start_time = 0;
 
        // Check if its a stop spline
        if (args.flags.done)
        {
            spline.clear();
            return;
        }
 
        init_spline(args);
 
        // init parabolic / animation
        // spline initialized, duration known and i able to compute parabolic acceleration
        if (args.flags & (MoveSplineFlag::Parabolic | MoveSplineFlag::Animation))
        {
            effect_start_time = Duration() * args.time_perc;
            if (args.flags.parabolic && effect_start_time < Duration())
            {
                float f_duration = MSToSec(Duration() - effect_start_time);
                vertical_acceleration = args.parabolic_amplitude * 8.f / (f_duration * f_duration);
            }
        }
    }

References Movement::MoveSplineFlag::Animation, Movement::Spline< length_type >::clear(), Movement::MoveSplineFlag::done, Duration(), effect_start_time, facing, Movement::MoveSplineInitArgs::facing, Movement::MoveSplineInitArgs::flags, init_spline(), initialOrientation, Movement::MoveSplineInitArgs::initialOrientation, m_Id, Movement::MSToSec(), Movement::MoveSplineFlag::Parabolic, Movement::MoveSplineFlag::parabolic, Movement::MoveSplineInitArgs::parabolic_amplitude, Movement::MoveSplineInitArgs::path_Idx_offset, point_Idx_offset, spline, splineflags, Movement::MoveSplineInitArgs::splineId, time_passed, Movement::MoveSplineInitArgs::time_perc, and vertical_acceleration.

Referenced by Movement::MoveSplineInit::Launch(), and Movement::MoveSplineInit::Stop().

Initialized()

bool Movement::MoveSpline::Initialized ( ) const

inline

{ return !spline.empty(); }

References Movement::SplineBase::empty(), and spline.

Referenced by ComputePosition(), CurrentDestination(), FinalDestination(), Unit::IsFalling(), Unit::SendMovementFeatherFall(), Unit::SendMovementHover(), Unit::SendMovementWaterWalking(), Unit::UpdateSplineMovement(), and updateState().

isCyclic()

bool Movement::MoveSpline::isCyclic ( ) const

inline

{ return splineflags.cyclic; }

References Movement::MoveSplineFlag::cyclic, and splineflags.

Referenced by currentPathIdx(), Movement::PacketBuilder::WriteCommonMonsterMovePart(), and Movement::PacketBuilder::WriteCreate().

isFalling()

bool Movement::MoveSpline::isFalling ( ) const

inline

{ return splineflags.falling; }

References Movement::MoveSplineFlag::falling, and splineflags.

Referenced by EffectMovementGenerator::Finalize(), and Unit::IsFalling().

isWalking()

bool Movement::MoveSpline::isWalking ( ) const

inline

{ return splineflags.walkmode; }

References splineflags, and Movement::MoveSplineFlag::walkmode.

Referenced by FollowMovementGenerator< T >::DoUpdate(), and GetVelocity().

next_timestamp()

int32 Movement::MoveSpline::next_timestamp ( ) const

inlineprotected

{ return spline.length(point_Idx + 1); }

References Movement::Spline< length_type >::length(), point_Idx, and spline.

Referenced by _updateState(), and segment_time_elapsed().

segment_time_elapsed()

int32 Movement::MoveSpline::segment_time_elapsed ( ) const

inlineprotected

{ return next_timestamp() - time_passed; }

References next_timestamp(), and time_passed.

Referenced by _updateState().

timeElapsed()

int32 Movement::MoveSpline::timeElapsed ( ) const

inline

{ return Duration() - time_passed; }  // xinef: moved to public for waypoint movegen

References Duration(), and time_passed.

timePassed()

int32 Movement::MoveSpline::timePassed ( ) const

inline

{ return time_passed; }                // xinef: moved to public for waypoint movegen

References time_passed.

Referenced by Movement::PacketBuilder::WriteCreate().

ToString()

std::string Movement::MoveSpline::ToString

(

)

const

    {
        std::stringstream str;
        str << "MoveSpline" << std::endl;
        str << "spline Id: " << GetId() << std::endl;
        str << "flags: " << splineflags.ToString() << std::endl;
        if (splineflags.final_angle)
            str << "facing  angle: " << facing.angle;
        else if (splineflags.final_target)
            str << "facing target: " << facing.target;
        else if (splineflags.final_point)
            str << "facing  point: " << facing.f.x << " " << facing.f.y << " " << facing.f.z;
        str << std::endl;
        str << "time passed: " << time_passed << std::endl;
        str << "total  time: " << Duration() << std::endl;
        str << "spline point Id: " << point_Idx << std::endl;
        str << "path  point  Id: " << currentPathIdx() << std::endl;
        str << spline.ToString();
        return str.str();
    }

References Movement::FacingInfo::angle, currentPathIdx(), Duration(), Movement::FacingInfo::f, facing, Movement::MoveSplineFlag::final_angle, Movement::MoveSplineFlag::final_point, Movement::MoveSplineFlag::final_target, GetId(), point_Idx, spline, splineflags, Movement::FacingInfo::target, time_passed, Movement::MoveSplineFlag::ToString(), Movement::SplineBase::ToString(), Movement::FacingInfo::x, Movement::FacingInfo::y, and Movement::FacingInfo::z.

updateState() [1/2]

void Movement::MoveSpline::updateState ( int32  difftime )

inline

        {
            ASSERT(Initialized());
            do _updateState(difftime);
            while (difftime > 0);
        }

References _updateState(), ASSERT, and Initialized().

updateState() [2/2]

template<class UpdateHandler >

void Movement::MoveSpline::updateState ( int32  difftime, UpdateHandler &  handler  )

inline

        {
            ASSERT(Initialized());
            do
                handler(_updateState(difftime));
            while (difftime > 0);
        }

References _updateState(), ASSERT, and Initialized().

Referenced by Unit::UpdateSplineMovement().

Friends And Related Function Documentation

PacketBuilder

friend class PacketBuilder

friend

Member Data Documentation

effect_start_time

int32 Movement::MoveSpline::effect_start_time

protected

Referenced by computeParabolicElevation(), Initialize(), Movement::PacketBuilder::WriteCommonMonsterMovePart(), and Movement::PacketBuilder::WriteCreate().

facing

FacingInfo Movement::MoveSpline::facing

protected

Referenced by ComputePosition(), Initialize(), ToString(), Movement::PacketBuilder::WriteCommonMonsterMovePart(), and Movement::PacketBuilder::WriteCreate().

initialOrientation

float Movement::MoveSpline::initialOrientation

protected

Referenced by ComputePosition(), and Initialize().

m_Id

uint32 Movement::MoveSpline::m_Id

protected

Referenced by GetId(), and Initialize().

onTransport

bool Movement::MoveSpline::onTransport

Referenced by Movement::MoveSplineInit::Launch(), CharmInfo::SaveStayPosition(), Movement::MoveSplineInit::Stop(), and Unit::UpdateSplinePosition().

point_Idx

int32 Movement::MoveSpline::point_Idx

protected

Referenced by _currentSplineIdx(), _Finalize(), _updateState(), ComputePosition(), CurrentDestination(), currentPathIdx(), init_spline(), next_timestamp(), and ToString().

point_Idx_offset

int32 Movement::MoveSpline::point_Idx_offset

protected

Referenced by currentPathIdx(), and Initialize().

spline

MySpline Movement::MoveSpline::spline

protected

Referenced by _Finalize(), _Spline(), _updateState(), computeFallElevation(), ComputePosition(), CurrentDestination(), currentPathIdx(), Duration(), FinalDestination(), getPath(), init_spline(), Initialize(), Initialized(), next_timestamp(), ToString(), Movement::PacketBuilder::WriteCommonMonsterMovePart(), Movement::PacketBuilder::WriteCreate(), and Movement::PacketBuilder::WriteMonsterMove().

splineflags

MoveSplineFlag Movement::MoveSpline::splineflags

protected

Referenced by _Finalize(), _Interrupt(), ComputePosition(), Finalized(), GetAnimationType(), HasAnimation(), init_spline(), Initialize(), isCyclic(), isFalling(), isWalking(), MoveSpline(), ToString(), Movement::PacketBuilder::WriteCommonMonsterMovePart(), Movement::PacketBuilder::WriteCreate(), and Movement::PacketBuilder::WriteMonsterMove().

time_passed

int32 Movement::MoveSpline::time_passed

protected

Referenced by _Finalize(), _updateState(), computeFallElevation(), computeParabolicElevation(), ComputePosition(), HasStarted(), Initialize(), segment_time_elapsed(), timeElapsed(), timePassed(), and ToString().

vertical_acceleration

float Movement::MoveSpline::vertical_acceleration

protected

Referenced by computeParabolicElevation(), Initialize(), Movement::PacketBuilder::WriteCommonMonsterMovePart(), and Movement::PacketBuilder::WriteCreate().