Movement::MoveSplineInit Class Reference

#include <MoveSplineInit.h>

Public Member Functions
	MoveSplineInit (Unit *m)
int32	Launch ()
void	Stop ()
void	SetParabolic (float amplitude, float start_time)
void	SetAnimation (AnimType anim)
void	SetFacing (float angle)
void	SetFacing (Vector3 const &point)
void	SetFacing (const Unit *target)
void	MovebyPath (const PointsArray &path, int32 pointId=0)
void	MoveTo (const Vector3 &destination, bool generatePath=true, bool forceDestination=false)
void	MoveTo (float x, float y, float z, bool generatePath=true, bool forceDestination=false)
void	SetFirstPointId (int32 pointId)
void	SetSmooth ()
void	SetUncompressed ()
void	SetFly ()
void	SetWalk (bool enable)
void	SetCyclic ()
void	SetFall ()
void	SetTransportEnter ()
void	SetTransportExit ()
void	SetOrientationInversed ()
void	SetOrientationFixed (bool enable)
void	SetVelocity (float velocity)
PointsArray &	Path ()
void	DisableTransportPathTransformations ()

Protected Attributes
MoveSplineInitArgs	args
Unit *	unit

Constructor & Destructor Documentation

Movement::MoveSplineInit::MoveSplineInit ( Unit *  m )

explicit

 : unit(m)
 {
 args.splineId = splineIdGen.NewId();
 // Elevators also use MOVEMENTFLAG_ONTRANSPORT but we do not keep track of their position changes
 args.TransformForTransport = !unit->GetTransGUID().IsEmpty();
 // mix existing state into new
 args.flags.walkmode = unit->m_movementInfo.HasMovementFlag(MOVEMENTFLAG_WALKING);
 args.flags.flying = unit->m_movementInfo.HasMovementFlag(MovementFlags(MOVEMENTFLAG_CAN_FLY | MOVEMENTFLAG_DISABLE_GRAVITY));
 args.flags.smoothGroundPath = true; // enabled by default, CatmullRom mode or client config "pathSmoothing" will disable this
 }

Here is the call graph for this function:

Member Function Documentation

void Movement::MoveSplineInit::DisableTransportPathTransformations ( )

inline

{ args.TransformForTransport = false; }

Here is the caller graph for this function:

int32 Movement::MoveSplineInit::Launch

(

)

 {
 MoveSpline& move_spline = *unit->movespline;

 bool transport = !unit->GetTransGUID().IsEmpty();
 Location real_position;
 // there is a big chance that current position is unknown if current state is not finalized, need compute it
 // this also allows calculate spline position and update map position in much greater intervals
 // Don't compute for transport movement if the unit is in a motion between two transports
 if (!move_spline.Finalized() && move_spline.onTransport == transport)
 real_position = move_spline.ComputePosition();
 else
 {
 Position const* pos;
 if (!transport)
 pos = unit;
 else
 pos = &unit->m_movementInfo.transport.pos;

 real_position.x = pos->GetPositionX();
 real_position.y = pos->GetPositionY();
 real_position.z = pos->GetPositionZ();
 real_position.orientation = unit->GetOrientation();
 }

 // should i do the things that user should do? - no.
 if (args.path.empty())
 return 0;

 // correct first vertex
 args.path[0] = real_position;
 args.initialOrientation = real_position.orientation;
 move_spline.onTransport = !unit->GetTransGUID().IsEmpty();

 uint32 moveFlags = unit->m_movementInfo.GetMovementFlags();
 moveFlags |= MOVEMENTFLAG_FORWARD;

 if (moveFlags & MOVEMENTFLAG_ROOT)
 moveFlags &= ~MOVEMENTFLAG_MASK_MOVING;

 if (!args.HasVelocity)
 {
 // If spline is initialized with SetWalk method it only means we need to select
 // walk move speed for it but not add walk flag to unit
 uint32 moveFlagsForSpeed = moveFlags;
 if (args.flags.walkmode)
 moveFlagsForSpeed |= MOVEMENTFLAG_WALKING;
 else
 moveFlagsForSpeed &= ~MOVEMENTFLAG_WALKING;

 args.velocity = unit->GetSpeed(SelectSpeedType(moveFlagsForSpeed));
 }

 if (!args.Validate(unit))
 return 0;

 unit->m_movementInfo.SetMovementFlags(moveFlags);
 move_spline.Initialize(args);

 WorldPackets::Movement::MonsterMove packet;
 packet.MoverGUID = unit->GetGUID();
 packet.Pos = real_position;
 packet.InitializeSplineData(move_spline);
 if (transport)
 {
 packet.SplineData.Move.TransportGUID = unit->GetTransGUID();
 packet.SplineData.Move.VehicleSeat = unit->GetTransSeat();
 }

 unit->SendMessageToSet(packet.Write(), true);

 return move_spline.Duration();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Movement::MoveSplineInit::MovebyPath ( const PointsArray &  path, int32  pointId = 0  )

inline

 {
 args.path_Idx_offset = path_offset;
 args.path.resize(controls.size());
 std::transform(controls.begin(), controls.end(), args.path.begin(), TransportPathTransform(unit, args.TransformForTransport));
 }

Here is the caller graph for this function:

void Movement::MoveSplineInit::MoveTo	(	const Vector3 &	destination,
		bool	generatePath = true,
		bool	forceDestination = false
	)

 {
 if (generatePath)
 {
 PathGenerator path(unit);
 bool result = path.CalculatePath(dest.x, dest.y, dest.z, forceDestination);
 if (result && !(path.GetPathType() & PATHFIND_NOPATH))
 {
 MovebyPath(path.GetPath());
 return;
 }
 }

 args.path_Idx_offset = 0;
 args.path.resize(2);
 TransportPathTransform transform(unit, args.TransformForTransport);
 args.path[1] = transform(dest);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Movement::MoveSplineInit::MoveTo ( float  x, float  y, float  z, bool  generatePath = true, bool  forceDestination = false  )

inline

 {
 MoveTo(G3D::Vector3(x, y, z), generatePath, forceDestination);
 }

Here is the call graph for this function:

PointsArray& Movement::MoveSplineInit::Path ( )

inline

{ return args.path; }

Here is the caller graph for this function:

void Movement::MoveSplineInit::SetAnimation ( AnimType  anim )

inline

 {
 args.time_perc = 0.f;
 args.flags.EnableAnimation((uint8)anim);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Movement::MoveSplineInit::SetCyclic ( )

inline

{ args.flags.cyclic = true; }

Here is the caller graph for this function:

void Movement::MoveSplineInit::SetFacing

(

float

angle

)

 {
 if (args.TransformForTransport)
 {
 if (Unit* vehicle = unit->GetVehicleBase())
 angle -= vehicle->GetOrientation();
 else if (Transport* transport = unit->GetTransport())
 angle -= transport->GetOrientation();
 }

 args.facing.angle = G3D::wrap(angle, 0.f, (float)G3D::twoPi());
 args.flags.EnableFacingAngle();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Movement::MoveSplineInit::SetFacing ( Vector3 const &  point )

inline

 {
 TransportPathTransform transform(unit, args.TransformForTransport);
 Vector3 finalSpot = transform(spot);
 args.facing.f.x = finalSpot.x;
 args.facing.f.y = finalSpot.y;
 args.facing.f.z = finalSpot.z;
 args.flags.EnableFacingPoint();
 }

Here is the call graph for this function:

void Movement::MoveSplineInit::SetFacing

(

const Unit *

target

)

 {
 args.flags.EnableFacingTarget();
 args.facing.target = target->GetGUID();
 }

Here is the call graph for this function:

void Movement::MoveSplineInit::SetFall

(

)

 {
 args.flags.EnableFalling();
 args.flags.fallingSlow = unit->HasUnitMovementFlag(MOVEMENTFLAG_FALLING_SLOW);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Movement::MoveSplineInit::SetFirstPointId ( int32  pointId )

inline

{ args.path_Idx_offset = pointId; }

Here is the caller graph for this function:

void Movement::MoveSplineInit::SetFly ( )

inline

{ args.flags.EnableFlying(); }

Here is the call graph for this function:

Here is the caller graph for this function:

void Movement::MoveSplineInit::SetOrientationFixed ( bool  enable )

inline

{ args.flags.orientationFixed = enable; }

Here is the caller graph for this function:

void Movement::MoveSplineInit::SetOrientationInversed ( )

inline

{ args.flags.orientationInversed = true;}

void Movement::MoveSplineInit::SetParabolic ( float  amplitude, float  start_time  )

inline

 {
 args.time_perc = time_shift;
 args.parabolic_amplitude = amplitude;
 args.flags.EnableParabolic();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Movement::MoveSplineInit::SetSmooth ( )

inline

{ args.flags.EnableCatmullRom(); }

Here is the call graph for this function:

Here is the caller graph for this function:

void Movement::MoveSplineInit::SetTransportEnter ( )

inline

{ args.flags.EnableTransportEnter(); }

Here is the call graph for this function:

Here is the caller graph for this function:

void Movement::MoveSplineInit::SetTransportExit ( )

inline

{ args.flags.EnableTransportExit(); }

Here is the call graph for this function:

Here is the caller graph for this function:

void Movement::MoveSplineInit::SetUncompressed ( )

inline

{ args.flags.uncompressedPath = true; }

Here is the caller graph for this function:

void Movement::MoveSplineInit::SetVelocity ( float  velocity )

inline

{ args.velocity = vel; args.HasVelocity = true; }

Here is the caller graph for this function:

void Movement::MoveSplineInit::SetWalk ( bool  enable )

inline

{ args.flags.walkmode = enable; }

Here is the caller graph for this function:

void Movement::MoveSplineInit::Stop

(

)

 {
 MoveSpline& move_spline = *unit->movespline;

 // No need to stop if we are not moving
 if (move_spline.Finalized())
 return;

 bool transport = !unit->GetTransGUID().IsEmpty();
 Location loc;
 if (move_spline.onTransport == transport)
 loc = move_spline.ComputePosition();
 else
 {
 Position const* pos;
 if (!transport)
 pos = unit;
 else
 pos = &unit->m_movementInfo.transport.pos;

 loc.x = pos->GetPositionX();
 loc.y = pos->GetPositionY();
 loc.z = pos->GetPositionZ();
 loc.orientation = unit->GetOrientation();
 }

 args.flags = MoveSplineFlag::Done;
 unit->m_movementInfo.RemoveMovementFlag(MOVEMENTFLAG_FORWARD);
 move_spline.onTransport = transport;
 move_spline.Initialize(args);

 WorldPackets::Movement::MonsterMove packet;
 packet.MoverGUID = unit->GetGUID();
 packet.Pos = loc;
 packet.SplineData.ID = move_spline.GetId();

 if (transport)
 {
 packet.SplineData.Move.TransportGUID = unit->GetTransGUID();
 packet.SplineData.Move.VehicleSeat = unit->GetTransSeat();
 }

 unit->SendMessageToSet(packet.Write(), true);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

MoveSplineInitArgs Movement::MoveSplineInit::args

protected

Unit* Movement::MoveSplineInit::unit

protected

---

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

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