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 (AnimTier anim)
void	SetFacing (float angle)
void	SetFacing (Vector3 const &point)
void	SetFacing (Unit const *target)
void	MovebyPath (const PointsArray &path, int32 pointId=0)
void	MoveTo (Vector3 const &start, Vector3 const &destination, bool generatePath=true, bool forceDestination=false)
void	MoveTo (const Vector3 &destination, bool generatePath=false, bool forceDestination=false)
void	MoveTo (float x, float y, float z, bool generatePath=false, bool forceDestination=false)
void	SetFirstPointId (int32 pointId)
void	SetSmooth ()
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

Detailed Description

Constructor & Destructor Documentation

MoveSplineInit()

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

explicit

                                          : unit(m)
    {
        args.splineId = splineIdGen.NewId();
        args.TransformForTransport = unit->HasUnitMovementFlag(MOVEMENTFLAG_ONTRANSPORT) && unit->GetTransGUID();
        // mix existing state into new
        args.walk = unit->m_movementInfo.HasMovementFlag(MOVEMENTFLAG_WALKING);
        args.flags.flying = unit->m_movementInfo.HasMovementFlag((MovementFlags)(MOVEMENTFLAG_CAN_FLY | MOVEMENTFLAG_DISABLE_GRAVITY));
    }

References args, Movement::MoveSplineInitArgs::flags, Movement::MoveSplineFlag::flying, Unit::GetTransGUID(), MovementInfo::HasMovementFlag(), Unit::HasUnitMovementFlag(), WorldObject::m_movementInfo, MOVEMENTFLAG_CAN_FLY, MOVEMENTFLAG_DISABLE_GRAVITY, MOVEMENTFLAG_ONTRANSPORT, MOVEMENTFLAG_WALKING, Movement::counter< T, limit >::NewId(), Movement::MoveSplineInitArgs::splineId, Movement::splineIdGen, Movement::MoveSplineInitArgs::TransformForTransport, unit, and Movement::MoveSplineInitArgs::walk.

Member Function Documentation

DisableTransportPathTransformations()

void Movement::MoveSplineInit::DisableTransportPathTransformations ( )

inline

{ args.TransformForTransport = false; }

References args, and Movement::MoveSplineInitArgs::TransformForTransport.

Referenced by Vehicle::AddPassenger(), npc_high_overlord_saurfang_igb::npc_high_overlord_saurfang_igbAI::DoAction(), npc_muradin_bronzebeard_igb::npc_muradin_bronzebeard_igbAI::DoAction(), Unit::SetFacingTo(), and WaypointMovementGenerator< Creature >::StartMove().

Launch()

int32 Movement::MoveSplineInit::Launch

(

)

    {
        MoveSpline& move_spline = *unit->movespline;
 
        bool transport = unit->HasUnitMovementFlag(MOVEMENTFLAG_ONTRANSPORT) && unit->GetTransGUID();
        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 CalculatePath 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;
 
        // corrent first vertex
        args.path[0] = real_position;
        args.initialOrientation = real_position.orientation;
        move_spline.onTransport = transport;
 
        uint32 moveFlags = unit->m_movementInfo.GetMovementFlags();
        moveFlags |= MOVEMENTFLAG_SPLINE_ENABLED;
 
        if (!args.flags.orientationInversed)
        {
            moveFlags = (moveFlags & ~(MOVEMENTFLAG_BACKWARD)) | MOVEMENTFLAG_FORWARD;
        }
        else
        {
            moveFlags = (moveFlags & ~(MOVEMENTFLAG_FORWARD)) | MOVEMENTFLAG_BACKWARD;
        }
 
        bool isOrientationOnly = args.path.size() == 2 && args.path[0] == args.path[1];
 
        if (moveFlags & MOVEMENTFLAG_ROOT) // This case should essentially never occur - hence the trace logging - hints to issues elsewhere
        {
            LOG_TRACE("movement", "Invalid movement during root. Entry: {} IsImmobilized {}, moveflags {}", unit->GetEntry(), unit->IsImmobilizedState() ? "true" : "false", moveFlags);
            moveFlags &= ~MOVEMENTFLAG_MASK_MOVING;
        }
 
        if (isOrientationOnly)
            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.walk)
                moveFlagsForSpeed |= MOVEMENTFLAG_WALKING;
            else
                moveFlagsForSpeed &= ~MOVEMENTFLAG_WALKING;
 
            args.velocity = unit->GetSpeed(SelectSpeedType(moveFlagsForSpeed));
        }
 
        // limit the speed in the same way the client does
        args.velocity = std::min(args.velocity, args.flags.catmullrom || args.flags.flying ? 50.0f : std::max(28.0f, unit->GetSpeed(MOVE_RUN) * 4.0f));
 
        if (!args.Validate(unit))
            return 0;
 
        unit->m_movementInfo.SetMovementFlags(moveFlags);
        move_spline.Initialize(args);
 
        WorldPacket data(SMSG_MONSTER_MOVE, 64);
        data << unit->GetPackGUID();
        if (transport)
        {
            data.SetOpcode(SMSG_MONSTER_MOVE_TRANSPORT);
            data << unit->GetTransGUID().WriteAsPacked();
            data << int8(unit->GetTransSeat());
        }
 
        PacketBuilder::WriteMonsterMove(move_spline, data);
        unit->SendMessageToSet(&data, true);
 
        return move_spline.Duration();
    }

References args, Movement::MoveSplineFlag::catmullrom, Movement::MoveSpline::ComputePosition(), Movement::MoveSpline::Duration(), Movement::MoveSpline::Finalized(), Movement::MoveSplineInitArgs::flags, Movement::MoveSplineFlag::flying, Object::GetEntry(), MovementInfo::GetMovementFlags(), Position::GetOrientation(), Object::GetPackGUID(), Position::GetPositionX(), Position::GetPositionY(), Position::GetPositionZ(), Unit::GetSpeed(), Unit::GetTransGUID(), WorldObject::GetTransSeat(), Unit::HasUnitMovementFlag(), Movement::MoveSplineInitArgs::HasVelocity, Movement::MoveSpline::Initialize(), Movement::MoveSplineInitArgs::initialOrientation, Unit::IsImmobilizedState(), LOG_TRACE, WorldObject::m_movementInfo, MOVE_RUN, MOVEMENTFLAG_BACKWARD, MOVEMENTFLAG_FORWARD, MOVEMENTFLAG_ONTRANSPORT, MOVEMENTFLAG_ROOT, MOVEMENTFLAG_SPLINE_ENABLED, MOVEMENTFLAG_WALKING, Unit::movespline, Movement::MoveSpline::onTransport, Movement::Location::orientation, Movement::MoveSplineFlag::orientationInversed, Movement::MoveSplineInitArgs::path, MovementInfo::TransportInfo::pos, Movement::SelectSpeedType(), WorldObject::SendMessageToSet(), MovementInfo::SetMovementFlags(), WorldPacket::SetOpcode(), SMSG_MONSTER_MOVE, SMSG_MONSTER_MOVE_TRANSPORT, MovementInfo::transport, unit, Movement::MoveSplineInitArgs::Validate(), Movement::MoveSplineInitArgs::velocity, Movement::MoveSplineInitArgs::walk, ObjectGuid::WriteAsPacked(), and Movement::PacketBuilder::WriteMonsterMove().

Referenced by Unit::_ExitVehicle(), RandomMovementGenerator< T >::_setRandomLocation(), HomeMovementGenerator< Creature >::_setTargetLocation(), Vehicle::AddPassenger(), ChaseMovementGenerator< T >::DispatchSplineToPosition(), npc_high_overlord_saurfang_igb::npc_high_overlord_saurfang_igbAI::DoAction(), npc_muradin_bronzebeard_igb::npc_muradin_bronzebeard_igbAI::DoAction(), boss_algalon_the_observer::DoAction(), EscortMovementGenerator< T >::DoInitialize(), FlightPathMovementGenerator::DoReset(), ConfusedMovementGenerator< T >::DoUpdate(), EscortMovementGenerator< T >::DoUpdate(), PointMovementGenerator< T >::DoUpdate(), FollowMovementGenerator< T >::DoUpdate(), MoveDelayed::Execute(), EffectMovementGenerator::Initialize(), npc_medivh_bm::JustSummoned(), FormationMovementGenerator::LaunchMovement(), Unit::MonsterMoveWithSpeed(), MotionMaster::MoveBackwards(), MotionMaster::MoveCharge(), MotionMaster::MoveCircleTarget(), MotionMaster::MoveForwards(), npc_cosmetic_toy_plane::Reset(), Unit::SetFacingTo(), Unit::SetFacingToObject(), FleeingMovementGenerator< T >::SetTargetLocation(), WaypointMovementGenerator< Creature >::StartMove(), and Unit::StopMovingOnCurrentPos().

MovebyPath()

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

References args, Movement::MoveSplineInitArgs::path, Movement::MoveSplineInitArgs::path_Idx_offset, Movement::MoveSplineInitArgs::TransformForTransport, and unit.

Referenced by RandomMovementGenerator< T >::_setRandomLocation(), ChaseMovementGenerator< T >::DispatchSplineToPosition(), npc_high_overlord_saurfang_igb::npc_high_overlord_saurfang_igbAI::DoAction(), npc_muradin_bronzebeard_igb::npc_muradin_bronzebeard_igbAI::DoAction(), EscortMovementGenerator< T >::DoInitialize(), EscortMovementGenerator< T >::DoUpdate(), PointMovementGenerator< T >::DoUpdate(), FollowMovementGenerator< T >::DoUpdate(), npc_medivh_bm::JustSummoned(), MotionMaster::MoveCharge(), MoveTo(), MoveTo(), npc_cosmetic_toy_plane::Reset(), boss_kiljaeden::ScheduleBasicAbilities(), and FleeingMovementGenerator< T >::SetTargetLocation().

MoveTo() [1/3]

void Movement::MoveSplineInit::MoveTo	(	const Vector3 &	destination,
		bool	generatePath = false,
		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);
    }

References args, PathGenerator::CalculatePath(), PathGenerator::GetPath(), PathGenerator::GetPathType(), MovebyPath(), Movement::MoveSplineInitArgs::path, Movement::MoveSplineInitArgs::path_Idx_offset, PATHFIND_NOPATH, Movement::MoveSplineInitArgs::TransformForTransport, and unit.

MoveTo() [2/3]

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

inline

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

References MoveTo().

MoveTo() [3/3]

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

    {
        if (generatePath)
        {
            PathGenerator path(unit);
            bool result = path.CalculatePath(start.x, start.y, start.z, 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);
    }

References args, PathGenerator::CalculatePath(), PathGenerator::GetPath(), PathGenerator::GetPathType(), MovebyPath(), Movement::MoveSplineInitArgs::path, Movement::MoveSplineInitArgs::path_Idx_offset, PATHFIND_NOPATH, Movement::MoveSplineInitArgs::TransformForTransport, and unit.

Referenced by Unit::_ExitVehicle(), RandomMovementGenerator< T >::_setRandomLocation(), HomeMovementGenerator< Creature >::_setTargetLocation(), Vehicle::AddPassenger(), boss_algalon_the_observer::DoAction(), EscortMovementGenerator< T >::DoInitialize(), ConfusedMovementGenerator< T >::DoUpdate(), EscortMovementGenerator< T >::DoUpdate(), PointMovementGenerator< T >::DoUpdate(), MoveDelayed::Execute(), FormationMovementGenerator::LaunchMovement(), Unit::MonsterMoveWithSpeed(), MotionMaster::MoveBackwards(), MotionMaster::MoveCircleTarget(), MotionMaster::MoveFall(), MotionMaster::MoveForwards(), MotionMaster::MoveJump(), MotionMaster::MoveKnockbackFrom(), MotionMaster::MoveLand(), MotionMaster::MoveTakeoff(), MoveTo(), Unit::SetFacingTo(), Unit::SetFacingToObject(), WaypointMovementGenerator< Creature >::StartMove(), and Unit::StopMovingOnCurrentPos().

Path()

PointsArray & Movement::MoveSplineInit::Path ( )

inline

{ return args.path; }

References args, and Movement::MoveSplineInitArgs::path.

Referenced by FlightPathMovementGenerator::DoReset(), and WaypointMovementGenerator< Creature >::StartMove().

SetAnimation()

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

inline

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

References args, Movement::MoveSplineFlag::EnableAnimation(), Movement::MoveSplineInitArgs::flags, and Movement::MoveSplineInitArgs::time_perc.

Referenced by PointMovementGenerator< T >::DoUpdate(), MotionMaster::MoveLand(), MotionMaster::MoveTakeoff(), and WaypointMovementGenerator< Creature >::StartMove().

SetCyclic()

void Movement::MoveSplineInit::SetCyclic ( )

inline

{ args.flags.cyclic = true; }

References args, Movement::MoveSplineFlag::cyclic, and Movement::MoveSplineInitArgs::flags.

Referenced by npc_medivh_bm::JustSummoned(), and npc_cosmetic_toy_plane::Reset().

SetFacing() [1/3]

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

References Movement::FacingInfo::angle, args, Movement::MoveSplineFlag::EnableFacingAngle(), Movement::MoveSplineInitArgs::facing, Movement::MoveSplineInitArgs::flags, WorldObject::GetTransport(), Unit::GetVehicleBase(), Movement::MoveSplineInitArgs::TransformForTransport, and unit.

Referenced by Unit::_ExitVehicle(), HomeMovementGenerator< Creature >::_setTargetLocation(), Vehicle::AddPassenger(), ChaseMovementGenerator< T >::DispatchSplineToPosition(), PointMovementGenerator< T >::DoUpdate(), MoveDelayed::Execute(), MotionMaster::MoveBackwards(), MotionMaster::MoveCircleTarget(), MotionMaster::MoveForwards(), MotionMaster::MoveJump(), Unit::SetFacingTo(), Unit::SetFacingToObject(), WaypointMovementGenerator< Creature >::StartMove(), and Unit::StopMovingOnCurrentPos().

SetFacing() [2/3]

void Movement::MoveSplineInit::SetFacing

(

Unit const *

target

)

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

References args, Movement::MoveSplineFlag::EnableFacingTarget(), Movement::MoveSplineInitArgs::facing, Movement::MoveSplineInitArgs::flags, Object::GetGUID(), ObjectGuid::GetRawValue(), and Movement::FacingInfo::target.

SetFacing() [3/3]

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

References args, Movement::MoveSplineFlag::EnableFacingPoint(), Movement::FacingInfo::f, Movement::MoveSplineInitArgs::facing, Movement::MoveSplineInitArgs::flags, Movement::MoveSplineInitArgs::TransformForTransport, unit, Movement::FacingInfo::x, Movement::FacingInfo::y, and Movement::FacingInfo::z.

SetFall()

void Movement::MoveSplineInit::SetFall ( )

inline

{ args.flags.EnableFalling(); }

References args, Movement::MoveSplineFlag::EnableFalling(), and Movement::MoveSplineInitArgs::flags.

Referenced by MotionMaster::MoveFall().

SetFirstPointId()

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

inline

{ args.path_Idx_offset = pointId; }

References args, and Movement::MoveSplineInitArgs::path_Idx_offset.

Referenced by FlightPathMovementGenerator::DoReset(), and WaypointMovementGenerator< Creature >::StartMove().

SetFly()

void Movement::MoveSplineInit::SetFly ( )

inline

{ args.flags.EnableFlying(); }

References args, Movement::MoveSplineFlag::EnableFlying(), and Movement::MoveSplineInitArgs::flags.

Referenced by FlightPathMovementGenerator::DoReset(), npc_cosmetic_toy_plane::Reset(), and WaypointMovementGenerator< Creature >::StartMove().

SetOrientationFixed()

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

inline

{ args.flags.orientationFixed = enable; }

References args, Movement::MoveSplineInitArgs::flags, and Movement::MoveSplineFlag::orientationFixed.

Referenced by boss_algalon_the_observer::DoAction(), and MotionMaster::MoveKnockbackFrom().

SetOrientationInversed()

void Movement::MoveSplineInit::SetOrientationInversed ( )

inline

{ args.flags.orientationInversed = true;}

References args, Movement::MoveSplineInitArgs::flags, and Movement::MoveSplineFlag::orientationInversed.

Referenced by MotionMaster::MoveBackwards().

SetParabolic()

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

inline

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

References args, Movement::MoveSplineFlag::EnableParabolic(), Movement::MoveSplineInitArgs::flags, Movement::MoveSplineInitArgs::parabolic_amplitude, and Movement::MoveSplineInitArgs::time_perc.

Referenced by MotionMaster::MoveJump(), and MotionMaster::MoveKnockbackFrom().

SetSmooth()

void Movement::MoveSplineInit::SetSmooth ( )

inline

{ args.flags.EnableCatmullRom(); }

References args, Movement::MoveSplineFlag::EnableCatmullRom(), and Movement::MoveSplineInitArgs::flags.

Referenced by WaypointMovementGenerator< Creature >::StartMove().

SetTransportEnter()

void Movement::MoveSplineInit::SetTransportEnter ( )

inline

{ args.flags.EnableTransportEnter(); }

References args, Movement::MoveSplineFlag::EnableTransportEnter(), and Movement::MoveSplineInitArgs::flags.

Referenced by Vehicle::AddPassenger().

SetTransportExit()

void Movement::MoveSplineInit::SetTransportExit ( )

inline

{ args.flags.EnableTransportExit(); }

References args, Movement::MoveSplineFlag::EnableTransportExit(), and Movement::MoveSplineInitArgs::flags.

Referenced by Unit::_ExitVehicle().

SetVelocity()

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

inline

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

References args, Movement::MoveSplineInitArgs::HasVelocity, and Movement::MoveSplineInitArgs::velocity.

Referenced by FlightPathMovementGenerator::DoReset(), PointMovementGenerator< T >::DoUpdate(), FollowMovementGenerator< T >::DoUpdate(), FormationMovementGenerator::LaunchMovement(), Unit::MonsterMoveWithSpeed(), MotionMaster::MoveCharge(), MotionMaster::MoveJump(), MotionMaster::MoveKnockbackFrom(), MotionMaster::MoveLand(), MotionMaster::MoveTakeoff(), npc_cosmetic_toy_plane::Reset(), and WaypointMovementGenerator< Creature >::StartMove().

SetWalk()

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

inline

{ args.walk = enable; }

References args, and Movement::MoveSplineInitArgs::walk.

Referenced by RandomMovementGenerator< T >::_setRandomLocation(), HomeMovementGenerator< Creature >::_setTargetLocation(), ChaseMovementGenerator< T >::DispatchSplineToPosition(), EscortMovementGenerator< T >::DoInitialize(), ConfusedMovementGenerator< T >::DoUpdate(), EscortMovementGenerator< T >::DoUpdate(), PointMovementGenerator< T >::DoUpdate(), FollowMovementGenerator< T >::DoUpdate(), MotionMaster::MoveBackwards(), MotionMaster::MoveCircleTarget(), FleeingMovementGenerator< T >::SetTargetLocation(), and WaypointMovementGenerator< Creature >::StartMove().

Stop()

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->HasUnitMovementFlag(MOVEMENTFLAG_ONTRANSPORT) && unit->GetTransGUID();
        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 | MOVEMENTFLAG_BACKWARD | MOVEMENTFLAG_SPLINE_ENABLED);
        move_spline.onTransport = transport;
        move_spline.Initialize(args);
 
        WorldPacket data(SMSG_MONSTER_MOVE, 64);
        data << unit->GetPackGUID();
        if (transport)
        {
            data.SetOpcode(SMSG_MONSTER_MOVE_TRANSPORT);
            data << unit->GetTransGUID().WriteAsPacked();
            data << int8(unit->GetTransSeat());
        }
 
        PacketBuilder::WriteStopMovement(loc, args.splineId, data);
        unit->SendMessageToSet(&data, true);
    }

References args, Movement::MoveSpline::ComputePosition(), Movement::MoveSplineFlag::Done, Movement::MoveSpline::Finalized(), Movement::MoveSplineInitArgs::flags, Position::GetOrientation(), Object::GetPackGUID(), Position::GetPositionX(), Position::GetPositionY(), Position::GetPositionZ(), Unit::GetTransGUID(), WorldObject::GetTransSeat(), Unit::HasUnitMovementFlag(), Movement::MoveSpline::Initialize(), WorldObject::m_movementInfo, MOVEMENTFLAG_BACKWARD, MOVEMENTFLAG_FORWARD, MOVEMENTFLAG_ONTRANSPORT, MOVEMENTFLAG_SPLINE_ENABLED, Unit::movespline, Movement::MoveSpline::onTransport, Movement::Location::orientation, MovementInfo::TransportInfo::pos, MovementInfo::RemoveMovementFlag(), WorldObject::SendMessageToSet(), WorldPacket::SetOpcode(), SMSG_MONSTER_MOVE, SMSG_MONSTER_MOVE_TRANSPORT, Movement::MoveSplineInitArgs::splineId, MovementInfo::transport, unit, ObjectGuid::WriteAsPacked(), and Movement::PacketBuilder::WriteStopMovement().

Referenced by Unit::StopMoving().

Member Data Documentation

args

MoveSplineInitArgs Movement::MoveSplineInit::args

protected

Referenced by DisableTransportPathTransformations(), Launch(), MovebyPath(), MoveSplineInit(), MoveTo(), MoveTo(), Path(), SetAnimation(), SetCyclic(), SetFacing(), SetFacing(), SetFacing(), SetFall(), SetFirstPointId(), SetFly(), SetOrientationFixed(), SetOrientationInversed(), SetParabolic(), SetSmooth(), SetTransportEnter(), SetTransportExit(), SetVelocity(), SetWalk(), and Stop().

unit

Unit* Movement::MoveSplineInit::unit

protected

Referenced by Launch(), MovebyPath(), MoveSplineInit(), MoveTo(), MoveTo(), SetFacing(), SetFacing(), and Stop().

---

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

• azerothcore-wotlk/src/server/game/Movement/Spline/MoveSplineInit.h
• azerothcore-wotlk/src/server/game/Movement/Spline/MoveSplineInit.cpp