Movement Namespace Reference

Classes
struct	CommonInitializer
class	counter
union	FacingInfo
struct	FallInitializer
class	HoverMovementTransform
struct	Location
class	MoveSpline
class	MoveSplineFlag
class	MoveSplineInit
struct	MoveSplineInitArgs
class	PacketBuilder
class	Spline
class	SplineBase
class	TransportPathTransform

Typedefs
typedef counter< uint32, 0xFFFFFFFF >	UInt32Counter
typedef std::vector< Vector3 >	PointsArray

Enumerations
enum	MonsterMoveType {   MonsterMoveNormal = 0 ,   MonsterMoveStop = 1 ,   MonsterMoveFacingSpot = 2 ,   MonsterMoveFacingTarget = 3 ,   MonsterMoveFacingAngle = 4 }
enum	{ minimal_duration = 1 }
enum	AnimType {   ToGround = 0 ,   FlyToFly = 1 ,   ToFly = 2 ,   FlyToGround = 3 }

Functions
void	operator<< (ByteBuffer &b, const Vector3 &v)
void	operator>> (ByteBuffer &b, Vector3 &v)
void	WriteLinearPath (const Spline< int32 > &spline, ByteBuffer &data)
void	WriteCatmullRomPath (const Spline< int32 > &spline, ByteBuffer &data)
void	WriteCatmullRomCyclicPath (const Spline< int32 > &spline, ByteBuffer &data, bool flying)
uint32	SecToMS (float sec)
float	MSToSec (uint32 ms)
float	computeFallTime (float path_length, bool isSafeFall)
float	computeFallElevation (float t_passed, bool isSafeFall, float start_velocity=0.0f)
template<class Flags , int N>
void	print_flags (Flags t, char const *(&names)[N], std::string &str)
uint32	computeDuration (float length, float velocity)
UnitMoveType	SelectSpeedType (uint32 moveFlags)
static const Matrix4	s_catmullRomCoeffs (-0.5f, 1.5f, -1.5f, 0.5f, 1.f, -2.5f, 2.f, -0.5f, -0.5f, 0.f, 0.5f, 0.f, 0.f, 1.f, 0.f, 0.f)
static const Matrix4	s_Bezier3Coeffs (-1.f, 3.f, -3.f, 1.f, 3.f, -6.f, 3.f, 0.f, -3.f, 3.f, 0.f, 0.f, 1.f, 0.f, 0.f, 0.f)
void	C_Evaluate (const Vector3 *vertice, float t, const Matrix4 &matr, Vector3 &result)
void	C_Evaluate_Derivative (const Vector3 *vertice, float t, const Matrix4 &matr, Vector3 &result)

Variables
double	gravity = 19.29110527038574
UInt32Counter	splineIdGen
float	terminalVelocity = 60.148003f
	Velocity bounds that makes fall speed limited.
float	terminalSafefallVelocity = 7.0f
const float	terminal_length = float(terminalVelocity* terminalVelocity) / (2.0f * gravity)
const float	terminal_safeFall_length = (terminalSafefallVelocity* terminalSafefallVelocity) / (2.0f * gravity)
const float	terminal_fallTime = float(terminalVelocity / gravity)
const float	terminal_safeFall_fallTime = float(terminalSafefallVelocity / gravity)
char const *	g_MovementFlag_names []
char const *	g_SplineFlag_names [32]

Typedef Documentation

PointsArray

typedef std::vector<Vector3> Movement::PointsArray

UInt32Counter

typedef counter<uint32, 0xFFFFFFFF> Movement::UInt32Counter

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
minimal_duration

    {
        minimal_duration = 1
    };

AnimType

enum Movement::AnimType

Enumerator
ToGround
FlyToFly
ToFly
FlyToGround

    {
        ToGround    = 0, // 460 = ToGround, index of AnimationData.dbc
        FlyToFly    = 1, // 461 = FlyToFly?
        ToFly       = 2, // 458 = ToFly
        FlyToGround = 3  // 463 = FlyToGround
    };

MonsterMoveType

enum Movement::MonsterMoveType

Enumerator
MonsterMoveNormal
MonsterMoveStop
MonsterMoveFacingSpot
MonsterMoveFacingTarget
MonsterMoveFacingAngle

    {
        MonsterMoveNormal       = 0,
        MonsterMoveStop         = 1,
        MonsterMoveFacingSpot   = 2,
        MonsterMoveFacingTarget = 3,
        MonsterMoveFacingAngle  = 4
    };

Function Documentation

C_Evaluate()

void Movement::C_Evaluate ( const Vector3 *  vertice, float  t, const Matrix4 &  matr, Vector3 &  result  )

inline

    {
        Vector4 tvec(t * t * t, t * t, t, 1.f);
        Vector4 weights(tvec * matr);
 
        result = vertice[0] * weights[0] + vertice[1] * weights[1]
                 + vertice[2] * weights[2] + vertice[3] * weights[3];
    }

Referenced by Movement::SplineBase::EvaluateBezier3(), Movement::SplineBase::EvaluateCatmullRom(), Movement::SplineBase::SegLengthBezier3(), and Movement::SplineBase::SegLengthCatmullRom().

C_Evaluate_Derivative()

void Movement::C_Evaluate_Derivative ( const Vector3 *  vertice, float  t, const Matrix4 &  matr, Vector3 &  result  )

inline

    {
        Vector4 tvec(3.f * t * t, 2.f * t, 1.f, 0.f);
        Vector4 weights(tvec * matr);
 
        result = vertice[0] * weights[0] + vertice[1] * weights[1]
                 + vertice[2] * weights[2] + vertice[3] * weights[3];
    }

Referenced by Movement::SplineBase::EvaluateDerivativeBezier3(), and Movement::SplineBase::EvaluateDerivativeCatmullRom().

computeDuration()

uint32 Movement::computeDuration ( float  length, float  velocity  )

inline

    {
        return SecToMS(length / velocity);
    }

References SecToMS().

computeFallElevation()

float Movement::computeFallElevation	(	float	t_passed,
		bool	isSafeFall,
		float	start_velocity = 0.0f
	)

    {
        float termVel;
        float result;
 
        if (isSafeFall)
            termVel = terminalSafefallVelocity;
        else
            termVel = terminalVelocity;
 
        if (start_velocity > termVel)
            start_velocity = termVel;
 
        float terminal_time = (isSafeFall ? terminal_safeFall_fallTime : terminal_fallTime) - start_velocity / gravity; // the time that needed to reach terminalVelocity
 
        if (t_passed > terminal_time)
        {
            result = termVel * (t_passed - terminal_time) +
                     start_velocity * terminal_time +
                     gravity * terminal_time * terminal_time * 0.5f;
        }
        else
            result = t_passed * (start_velocity + t_passed * gravity * 0.5f);
 
        return result;
    }

References gravity, terminal_fallTime, terminal_safeFall_fallTime, terminalSafefallVelocity, and terminalVelocity.

Referenced by Movement::MoveSpline::computeFallElevation(), MotionMaster::MoveJump(), and MotionMaster::MoveKnockbackFrom().

computeFallTime()

float Movement::computeFallTime	(	float	path_length,
		bool	isSafeFall
	)

    {
        if (path_length < 0.0f)
            return 0.0f;
 
        float time;
        if (isSafeFall)
        {
            if (path_length >= terminal_safeFall_length)
                time = (path_length - terminal_safeFall_length) / terminalSafefallVelocity + terminal_safeFall_fallTime;
            else
                time = sqrtf(2.0f * path_length / gravity);
        }
        else
        {
            if (path_length >= terminal_length)
                time = (path_length - terminal_length) / terminalVelocity + terminal_fallTime;
            else
                time = sqrtf(2.0f * path_length / gravity);
        }
 
        return time;
    }

References gravity, terminal_fallTime, terminal_length, terminal_safeFall_fallTime, terminal_safeFall_length, terminalSafefallVelocity, and terminalVelocity.

Referenced by Movement::FallInitializer::operator()().

MSToSec()

float Movement::MSToSec ( uint32  ms )

inline

    {
        return ms / 1000.f;
    }

Referenced by Movement::MoveSpline::computeFallElevation(), Movement::MoveSpline::computeParabolicElevation(), and Movement::MoveSpline::Initialize().

operator<<()

void Movement::operator<< ( ByteBuffer &  b, const Vector3 &  v  )

inline

    {
        b << v.x << v.y << v.z;
    }

operator>>()

void Movement::operator>> ( ByteBuffer &  b, Vector3 &  v  )

inline

    {
        b >> v.x >> v.y >> v.z;
    }

print_flags()

template<class Flags , int N>

void Movement::print_flags	(	Flags	t,
		char const *(&)	names[N],
		std::string &	str
	)

    {
        for (int i = 0; i < N; ++i)
        {
            if ((t & Flags(1 << i)) && names[i] != nullptr)
                str.append(" ").append(names[i]);
        }
    }

Referenced by Movement::MoveSplineFlag::ToString().

s_Bezier3Coeffs()

static const Matrix4 Movement::s_Bezier3Coeffs ( -1.  f, 3.  f, -3.  f, 1.  f, 3.  f, -6.  f, 3.  f, 0.  f, -3.  f, 3.  f, 0.  f, 0.  f, 1.  f, 0.  f, 0.  f, 0.  f  )

static

Referenced by Movement::SplineBase::EvaluateBezier3(), Movement::SplineBase::EvaluateDerivativeBezier3(), and Movement::SplineBase::SegLengthBezier3().

s_catmullRomCoeffs()

static const Matrix4 Movement::s_catmullRomCoeffs ( -0.  5f, 1.  5f, -1.  5f, 0.  5f, 1.  f, -2.  5f, 2.  f, -0.  5f, -0.  5f, 0.  f, 0.  5f, 0.  f, 0.  f, 1.  f, 0.  f, 0.  f  )

static

Referenced by Movement::SplineBase::EvaluateCatmullRom(), Movement::SplineBase::EvaluateDerivativeCatmullRom(), and Movement::SplineBase::SegLengthCatmullRom().

SecToMS()

uint32 Movement::SecToMS ( float  sec )

inline

    {
        return static_cast<uint32>(sec * 1000.f);
    }

Referenced by computeDuration().

SelectSpeedType()

UnitMoveType Movement::SelectSpeedType

(

uint32

moveFlags

)

    {
        if (moveFlags & MOVEMENTFLAG_FLYING)
        {
            if (moveFlags & MOVEMENTFLAG_BACKWARD /*&& speed_obj.flight >= speed_obj.flight_back*/)
                return MOVE_FLIGHT_BACK;
            else
                return MOVE_FLIGHT;
        }
        else if (moveFlags & MOVEMENTFLAG_SWIMMING)
        {
            if (moveFlags & MOVEMENTFLAG_BACKWARD /*&& speed_obj.swim >= speed_obj.swim_back*/)
                return MOVE_SWIM_BACK;
            else
                return MOVE_SWIM;
        }
        else if (moveFlags & MOVEMENTFLAG_WALKING)
        {
            //if (speed_obj.run > speed_obj.walk)
            return MOVE_WALK;
        }
        else if (moveFlags & MOVEMENTFLAG_BACKWARD /*&& speed_obj.run >= speed_obj.run_back*/)
            return MOVE_RUN_BACK;
 
        // Flying creatures use MOVEMENTFLAG_CAN_FLY or MOVEMENTFLAG_DISABLE_GRAVITY
        // Run speed is their default flight speed.
        return MOVE_RUN;
    }

References MOVE_FLIGHT, MOVE_FLIGHT_BACK, MOVE_RUN, MOVE_RUN_BACK, MOVE_SWIM, MOVE_SWIM_BACK, MOVE_WALK, MOVEMENTFLAG_BACKWARD, MOVEMENTFLAG_FLYING, MOVEMENTFLAG_SWIMMING, and MOVEMENTFLAG_WALKING.

Referenced by GetVelocity(), Movement::MoveSplineInit::Launch(), CreatureGroup::LeaderMoveTo(), and PredictPosition().

WriteCatmullRomCyclicPath()

void Movement::WriteCatmullRomCyclicPath	(	const Spline< int32 > &	spline,
		ByteBuffer &	data,
		bool	flying
	)

    {
        uint32 count = spline.getPointCount() - 3;
        data << uint32(count + 1);
        if (flying)
        {
            data << spline.getPoint(1); // fake point, client will erase it from the spline after first cycle done
            data.append<Vector3>(&spline.getPoint(2), count);
        }
        else
        {
            data.append<Vector3>(&spline.getPoint(2), count);
            data << Vector3::zero(); //Xinef: fake point
        }
    }

References ByteBuffer::append(), Movement::SplineBase::getPoint(), and Movement::SplineBase::getPointCount().

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

WriteCatmullRomPath()

void Movement::WriteCatmullRomPath	(	const Spline< int32 > &	spline,
		ByteBuffer &	data
	)

    {
        uint32 count = spline.getPointCount() - 3;
        data << count;
        data.append<Vector3>(&spline.getPoint(2), count);
    }

References ByteBuffer::append(), Movement::SplineBase::getPoint(), and Movement::SplineBase::getPointCount().

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

WriteLinearPath()

void Movement::WriteLinearPath	(	const Spline< int32 > &	spline,
		ByteBuffer &	data
	)

    {
        uint32 last_idx = spline.getPointCount() - 3;
        const Vector3* real_path = &spline.getPoint(1);
 
        data << last_idx;
        data << real_path[last_idx];   // destination
        if (last_idx > 1)
        {
            Vector3 middle = (real_path[0] + real_path[last_idx]) / 2.f;
            Vector3 offset;
            // first and last points already appended
            for (uint32 i = 1; i < last_idx; ++i)
            {
                offset = middle - real_path[i];
                data.appendPackXYZ(offset.x, offset.y, offset.z);
            }
        }
    }

References ByteBuffer::appendPackXYZ(), Movement::SplineBase::getPoint(), and Movement::SplineBase::getPointCount().

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

Variable Documentation

g_MovementFlag_names

char const* Movement::g_MovementFlag_names[]

    {
        STR(Forward            ), // 0x00000001,
        STR(Backward           ), // 0x00000002,
        STR(Strafe_Left        ), // 0x00000004,
        STR(Strafe_Right       ), // 0x00000008,
        STR(Turn_Left          ), // 0x00000010,
        STR(Turn_Right         ), // 0x00000020,
        STR(Pitch_Up           ), // 0x00000040,
        STR(Pitch_Down         ), // 0x00000080,
 
        STR(Walk               ), // 0x00000100,               // Walking
        STR(Ontransport        ), // 0x00000200,
        STR(Levitation         ), // 0x00000400,
        STR(Root               ), // 0x00000800,
        STR(Falling            ), // 0x00001000,
        STR(Fallingfar         ), // 0x00002000,
        STR(Pendingstop        ), // 0x00004000,
        STR(PendingSTRafestop  ), // 0x00008000,
        STR(Pendingforward     ), // 0x00010000,
        STR(Pendingbackward    ), // 0x00020000,
        STR(PendingSTRafeleft  ), // 0x00040000,
        STR(PendingSTRaferight ), // 0x00080000,
        STR(Pendingroot        ), // 0x00100000,
        STR(Swimming           ), // 0x00200000,               // Appears With Fly Flag Also
        STR(Ascending          ), // 0x00400000,               // Swim Up Also
        STR(Descending         ), // 0x00800000,               // Swim Down Also
        STR(Can_Fly            ), // 0x01000000,               // Can Fly In 3.3?
        STR(Flying             ), // 0x02000000,               // Actual Flying Mode
        STR(Spline_Elevation   ), // 0x04000000,               // Used For Flight Paths
        STR(Spline_Enabled     ), // 0x08000000,               // Used For Flight Paths
        STR(Waterwalking       ), // 0x10000000,               // Prevent Unit From Falling Through Water
        STR(Safe_Fall          ), // 0x20000000,               // Active Rogue Safe Fall Spell (Passive)
        STR(Hover              ), // 0x40000000
        STR(Unknown13          ), // 0x80000000
        STR(Unk1               ),
        STR(Unk2               ),
        STR(Unk3               ),
        STR(Fullspeedturning   ),
        STR(Fullspeedpitching  ),
        STR(Allow_Pitching     ),
        STR(Unk4               ),
        STR(Unk5               ),
        STR(Unk6               ),
        STR(Unk7               ),
        STR(Interp_Move        ),
        STR(Interp_Turning     ),
        STR(Interp_Pitching    ),
        STR(Unk8               ),
        STR(Unk9               ),
        STR(Unk10              ),
    };

g_SplineFlag_names

char const* Movement::g_SplineFlag_names[32]

    {
        STR(AnimBit1     ), // 0x00000001,
        STR(AnimBit2     ), // 0x00000002,
        STR(AnimBit3     ), // 0x00000004,
        STR(AnimBit4     ), // 0x00000008,
        STR(AnimBit5     ), // 0x00000010,
        STR(AnimBit6     ), // 0x00000020,
        STR(AnimBit7     ), // 0x00000040,
        STR(AnimBit8     ), // 0x00000080,
        STR(Done         ), // 0x00000100,
        STR(Falling      ), // 0x00000200,           // Not Compartible With Trajectory Movement
        STR(No_Spline    ), // 0x00000400,
        STR(Trajectory   ), // 0x00000800,           // Not Compartible With Fall Movement
        STR(Walkmode     ), // 0x00001000,
        STR(Flying       ), // 0x00002000,           // Smooth Movement(Catmullrom Interpolation Mode), Flying Animation
        STR(Knockback    ), // 0x00004000,           // Model Orientation Fixed
        STR(Final_Point  ), // 0x00008000,
        STR(Final_Target ), // 0x00010000,
        STR(Final_Angle  ), // 0x00020000,
        STR(Catmullrom   ), // 0x00040000,           // Used Catmullrom Interpolation Mode
        STR(Cyclic       ), // 0x00080000,           // Movement By Cycled Spline
        STR(Enter_Cycle  ), // 0x00100000,           // Everytime Appears With Cyclic Flag In Monster Move Packet
        STR(Animation    ), // 0x00200000,           // Animationid (0...3), Uint32 Time, Not Compartible With Trajectory And Fall Movement
        STR(Unknown4     ), // 0x00400000,           // Disables Movement By Path
        STR(Unknown5     ), // 0x00800000,
        STR(Unknown6     ), // 0x01000000,
        STR(Unknown7     ), // 0x02000000,
        STR(Unknown8     ), // 0x04000000,
        STR(OrientationInversed ), // 0x08000000,           // Appears With Runmode Flag, Nodes ), // 1, Handles Orientation
        STR(Unknown10    ), // 0x10000000,
        STR(Unknown11    ), // 0x20000000,
        STR(Unknown12    ), // 0x40000000,
        STR(Unknown13    ), // 0x80000000,
    };

Referenced by Movement::MoveSplineFlag::ToString().

gravity

double Movement::gravity = 19.29110527038574

Referenced by Spell::CalculateJumpSpeeds(), computeFallElevation(), computeFallTime(), Spell::EffectPullTowards(), spell_entropius_black_hole_effect::HandlePull(), spell_boss_magus_telestra_gravity_well::HandlePull(), MotionMaster::MoveJump(), MotionMaster::MoveJumpTo(), and MotionMaster::MoveKnockbackFrom().

splineIdGen

UInt32Counter Movement::splineIdGen

Referenced by Movement::MoveSplineInit::MoveSplineInit().

terminal_fallTime

const float Movement::terminal_fallTime = float(terminalVelocity / gravity)

Referenced by computeFallElevation(), and computeFallTime().

terminal_length

const float Movement::terminal_length = float(terminalVelocity* terminalVelocity) / (2.0f * gravity)

Referenced by computeFallTime().

terminal_safeFall_fallTime

const float Movement::terminal_safeFall_fallTime = float(terminalSafefallVelocity / gravity)

Referenced by computeFallElevation(), and computeFallTime().

terminal_safeFall_length

const float Movement::terminal_safeFall_length = (terminalSafefallVelocity* terminalSafefallVelocity) / (2.0f * gravity)

Referenced by computeFallTime().

terminalSafefallVelocity

float Movement::terminalSafefallVelocity = 7.0f

Referenced by computeFallElevation(), and computeFallTime().

terminalVelocity

float Movement::terminalVelocity = 60.148003f

Velocity bounds that makes fall speed limited.

Referenced by computeFallElevation(), and computeFallTime().