Classes
struct	CommonInitializer

class	counter

struct	FacingInfo

struct	FallInitializer

struct	Location

class	MoveSpline

class	MoveSplineFlag

class	MoveSplineInit

struct	MoveSplineInitArgs

class	Spline

class	SplineBase

class	TransportPathTransform

Typedefs
typedef counter< uint32, 0xFFFFFFFF >	UInt32Counter

typedef std::vector< Vector3 >	PointsArray

Enumerations
enum	MonsterMoveType { MONSTER_MOVE_NORMAL = 0, MONSTER_MOVE_FACING_SPOT = 1, MONSTER_MOVE_FACING_TARGET = 2, MONSTER_MOVE_FACING_ANGLE = 3 }

enum	{ minimal_duration = 1 }

enum	AnimType { ToGround = 0, FlyToFly = 1, ToFly = 2, FlyToGround = 3 }

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

TC_GAME_API std::string	MovementFlags_ToString (uint32 flags)

TC_GAME_API std::string	MovementFlagsExtra_ToString (uint32 flags)

template<class Flags , int N>
void	PrintFlags (Flags t, char const *(&names)[N], std::string &str)

uint32	computeDuration (float length, float velocity)

UnitMoveType	SelectSpeedType (uint32 moveFlags)

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
TC_GAME_API float	gravity = static_cast<float>(19.29110527038574)

TC_GAME_API UInt32Counter	splineIdGen

float	terminalVelocity = 60.148003f
	Velocity bounds that makes fall speed limited. More...

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 *	MovementFlagNames []

char const *	MovementFlagExtraNames []

char const *	SplineFlagNames [32]

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)

Typedef Documentation

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

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

Enumeration Type Documentation

anonymous enum

Enumerator
minimal_duration

  {
  minimal_duration = 1
 };

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

enum Movement::MonsterMoveType

Enumerator
MONSTER_MOVE_NORMAL
MONSTER_MOVE_FACING_SPOT
MONSTER_MOVE_FACING_TARGET
MONSTER_MOVE_FACING_ANGLE

  {
  MONSTER_MOVE_NORMAL = 0,
  MONSTER_MOVE_FACING_SPOT = 1,
  MONSTER_MOVE_FACING_TARGET = 2,
  MONSTER_MOVE_FACING_ANGLE = 3
  };

Function Documentation

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

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

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

inline

 {
  return SecToMS(length / velocity);
 }

Here is the call graph for this function:

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

Here is the caller graph for this function:

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 = std::sqrt(2.0f * path_length / gravity);
  }
  else
  {
  if (path_length >= terminal_length)
  time = (path_length - terminal_length) / terminalVelocity + terminal_fallTime;
  else
  time = std::sqrt(2.0f * path_length / gravity);
  }
 
  return time;
  }

Here is the caller graph for this function:

std::string Movement::MovementFlags_ToString ( uint32 flags )

  {
  std::string str;
  PrintFlags(flags, MovementFlagNames, str);
  return str;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

std::string Movement::MovementFlagsExtra_ToString ( uint32 flags )

  {
  std::string str;
  PrintFlags(flags, MovementFlagExtraNames, str);
  return str;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

float Movement::MSToSec ( uint32 ms )

inline

  {
  return ms / 1000.f;
  }

Here is the caller graph for this function:

template<class Flags , int N>

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

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

Here is the caller graph for this function:

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

uint32 Movement::SecToMS ( float sec )

inline

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

Here is the caller graph for this function:

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

Here is the caller graph for this function:

Variable Documentation

float Movement::gravity = static_cast<float>(19.29110527038574)

char const* Movement::MovementFlagExtraNames[]

Initial value:

=
 {
 STRINGIZE(NoStrafe ),
 STRINGIZE(NoJump ),
 STRINGIZE(FullSpeedTurning ),
 STRINGIZE(FullSpeedPitching ),
 STRINGIZE(Allow_Pitching ),
 STRINGIZE(Unk6 ),
 STRINGIZE(Unk7 ),
 STRINGIZE(Unk8 ),
 STRINGIZE(Unk9 ),
 STRINGIZE(Unk10 ),
 STRINGIZE(Unk11 ),
 STRINGIZE(Unk12 ),
 STRINGIZE(Unk13 ),
 STRINGIZE(Interpolated_Movement),
 STRINGIZE(Interpolated_Turning ),
 STRINGIZE(Interpolated_Pitching),
 }

char const* Movement::MovementFlagNames[]

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

char const* Movement::SplineFlagNames[32]

UInt32Counter Movement::splineIdGen

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

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

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

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

float Movement::terminalSafefallVelocity = 7.0f

float Movement::terminalVelocity = 60.148003f

Velocity bounds that makes fall speed limited.

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

Enumeration Type Documentation

Function Documentation

Variable Documentation