Movement::MoveSpline Class Reference

#include <MoveSpline.h>

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

Public Member Functions
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
Vector3 const &	FinalDestination () const
Vector3 const &	CurrentDestination () const
int32	currentPathIdx () const
std::string	ToString () const

Public Attributes
bool	onTransport

Protected Member Functions
void	init_spline (const MoveSplineInitArgs &args)
MySpline::ControlArray const &	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
int32	timeElapsed () const
int32	timePassed () 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	WorldPackets::Movement::CommonMovement
class	WorldPackets::Movement::MonsterMove

Member Typedef Documentation

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

Member Enumeration Documentation

enum Movement::MoveSpline::UpdateResult

Enumerator
Result_None
Result_Arrived
Result_NextCycle
Result_NextSegment

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

Constructor & Destructor Documentation

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

Member Function Documentation

int32 Movement::MoveSpline::_currentSplineIdx ( ) const

inline

{ return point_Idx; }

void Movement::MoveSpline::_Finalize

(

)

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

void Movement::MoveSpline::_Interrupt ( )

inline

{ splineflags.done = true; }

Here is the caller graph for this function:

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

inline

{ return spline; }

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());
 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 = Result_NextCycle;
 }
 else
 {
 _Finalize();
 ms_time_diff = 0;
 result = Result_Arrived;
 }
 }
 }

 return result;
}

Here is the call graph for this function:

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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the call graph for this function:

Here is the caller graph for this function:

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 | MoveSplineFlag::Unknown0))
 {
 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Vector3 const& Movement::MoveSpline::CurrentDestination ( ) const

inline

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

Here is the call graph for this function:

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

int32 Movement::MoveSpline::Duration ( ) const

inline

{ return spline.length(); }

Here is the call graph for this function:

Here is the caller graph for this function:

Vector3 const& Movement::MoveSpline::FinalDestination ( ) const

inline

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

Here is the call graph for this function:

Here is the caller graph for this function:

bool Movement::MoveSpline::Finalized ( ) const

inline

{ return splineflags.done; }

Here is the caller graph for this function:

uint32 Movement::MoveSpline::GetId ( void  ) const

inline

{ return m_Id; }

Here is the caller graph for this function:

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

inlineprotected

{ return spline.getPoints(); }

Here is the caller graph for this function:

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)
 {
 TC_LOG_ERROR("misc", "MoveSpline::init_spline: zero length spline, wrong input data?");
 spline.set_length(spline.last(), spline.isCyclic() ? 1000 : 1);
 }
 point_Idx = spline.first();
}

Here is the call graph for this function:

Here is the caller graph for this function:

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);
 }
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool Movement::MoveSpline::Initialized ( ) const

inline

{ return !spline.empty(); }

Here is the caller graph for this function:

bool Movement::MoveSpline::isCyclic ( ) const

inline

{ return splineflags.cyclic; }

Here is the caller graph for this function:

bool Movement::MoveSpline::isFalling ( ) const

inline

{ return splineflags.falling; }

Here is the caller graph for this function:

int32 Movement::MoveSpline::next_timestamp ( ) const

inlineprotected

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

Here is the call graph for this function:

int32 Movement::MoveSpline::segment_time_elapsed ( ) const

inlineprotected

{ return next_timestamp() - time_passed; }

int32 Movement::MoveSpline::timeElapsed ( ) const

inlineprotected

{ return Duration() - time_passed; }

int32 Movement::MoveSpline::timePassed ( ) const

inlineprotected

{ return time_passed; }

Here is the caller graph for this function:

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.ToString();
 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();
}

Here is the call graph for this function:

template<class UpdateHandler >

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

inline

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

Here is the caller graph for this function:

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

inline

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

Friends And Related Function Documentation

friend class WorldPackets::Movement::CommonMovement

friend

friend class WorldPackets::Movement::MonsterMove

friend

Member Data Documentation

int32 Movement::MoveSpline::effect_start_time

protected

FacingInfo Movement::MoveSpline::facing

protected

float Movement::MoveSpline::initialOrientation

protected

uint32 Movement::MoveSpline::m_Id

protected

bool Movement::MoveSpline::onTransport

int32 Movement::MoveSpline::point_Idx

protected

int32 Movement::MoveSpline::point_Idx_offset

protected

MySpline Movement::MoveSpline::spline

protected

MoveSplineFlag Movement::MoveSpline::splineflags

protected

int32 Movement::MoveSpline::time_passed

protected

float Movement::MoveSpline::vertical_acceleration

protected

---

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

• src/server/game/Movement/Spline/MoveSpline.h
• src/server/game/Movement/Spline/MoveSpline.cpp