Movement::PacketBuilder Class Reference

#include "MovementPacketBuilder.h"

Static Public Member Functions
static void	WriteMonsterMove (const MoveSpline &mov, ByteBuffer &data)
static void	WriteStopMovement (Vector3 const &loc, uint32 splineId, ByteBuffer &data)
static void	WriteCreate (const MoveSpline &mov, ByteBuffer &data)

Static Private Member Functions
static void	WriteCommonMonsterMovePart (const MoveSpline &mov, ByteBuffer &data)

Detailed Description

Member Function Documentation

WriteCommonMonsterMovePart()

void Movement::PacketBuilder::WriteCommonMonsterMovePart ( const MoveSpline &  mov, ByteBuffer &  data  )

staticprivate

    {
        MoveSplineFlag splineflags = move_spline.splineflags;
 
        data << uint8(0);                                       // sets/unsets MOVEMENTFLAG2_UNK7 (0x40)
        data << move_spline.spline.getPoint(move_spline.spline.first());
        data << move_spline.GetId();
 
        switch (splineflags & MoveSplineFlag::Mask_Final_Facing)
        {
            case MoveSplineFlag::Final_Target:
                data << uint8(MonsterMoveFacingTarget);
                data << move_spline.facing.target;
                break;
            case MoveSplineFlag::Final_Angle:
                data << uint8(MonsterMoveFacingAngle);
                data << move_spline.facing.angle;
                break;
            case MoveSplineFlag::Final_Point:
                data << uint8(MonsterMoveFacingSpot);
                data << move_spline.facing.f.x << move_spline.facing.f.y << move_spline.facing.f.z;
                break;
            default:
                data << uint8(MonsterMoveNormal);
                break;
        }
 
        // add fake Enter_Cycle flag - needed for client-side cyclic movement (client will erase first spline vertex after first cycle done)
        // Xinef: this flag breaks cycle for ground movement, client teleports npc between last and first point instead of using smooth movement
        if (splineflags & MoveSplineFlag::Flying)
            splineflags.enter_cycle = move_spline.isCyclic();
        data << uint32(splineflags & uint32(~MoveSplineFlag::Mask_No_Monster_Move));
 
        if (splineflags.animation)
        {
            data << splineflags.getAnimationId();
            data << move_spline.effect_start_time;
        }
 
        data << move_spline.Duration();
 
        if (splineflags.parabolic)
        {
            data << move_spline.vertical_acceleration;
            data << move_spline.effect_start_time;
        }
    }

References Movement::FacingInfo::angle, Movement::MoveSplineFlag::animation, Movement::MoveSpline::Duration(), Movement::MoveSpline::effect_start_time, Movement::MoveSplineFlag::enter_cycle, Movement::FacingInfo::f, Movement::MoveSpline::facing, Movement::MoveSplineFlag::Final_Angle, Movement::MoveSplineFlag::Final_Point, Movement::MoveSplineFlag::Final_Target, Movement::SplineBase::first(), Movement::MoveSplineFlag::Flying, Movement::MoveSplineFlag::getAnimationId(), Movement::MoveSpline::GetId(), Movement::SplineBase::getPoint(), Movement::MoveSpline::isCyclic(), Movement::MoveSplineFlag::Mask_Final_Facing, Movement::MoveSplineFlag::Mask_No_Monster_Move, Movement::MonsterMoveFacingAngle, Movement::MonsterMoveFacingSpot, Movement::MonsterMoveFacingTarget, Movement::MonsterMoveNormal, Movement::MoveSplineFlag::parabolic, Movement::MoveSpline::spline, Movement::MoveSpline::splineflags, Movement::FacingInfo::target, Movement::MoveSpline::vertical_acceleration, Movement::FacingInfo::x, Movement::FacingInfo::y, and Movement::FacingInfo::z.

Referenced by WriteMonsterMove().

WriteCreate()

void Movement::PacketBuilder::WriteCreate ( const MoveSpline &  mov, ByteBuffer &  data  )

static

    {
        //WriteClientStatus(mov, data);
        //data.append<float>(&mov.m_float_values[SpeedWalk], SpeedMaxCount);
        //if (mov.SplineEnabled())
        {
            MoveSplineFlag const& splineFlags = move_spline.splineflags;
 
            data << splineFlags.raw();
 
            if (splineFlags.final_angle)
            {
                data << move_spline.facing.angle;
            }
            else if (splineFlags.final_target)
            {
                data << move_spline.facing.target;
            }
            else if (splineFlags.final_point)
            {
                data << move_spline.facing.f.x << move_spline.facing.f.y << move_spline.facing.f.z;
            }
 
            data << move_spline.timePassed();
            data << move_spline.Duration();
            data << move_spline.GetId();
 
            data << float(1.f);                             // splineInfo.duration_mod; added in 3.1
            data << float(1.f);                             // splineInfo.duration_mod_next; added in 3.1
 
            data << move_spline.vertical_acceleration;      // added in 3.1
            data << move_spline.effect_start_time;          // added in 3.1
 
            uint32 nodes = move_spline.getPath().size();
            data << nodes;
            if (nodes)
            {
                data.append<Vector3>(&move_spline.getPath()[0], nodes);
            }
            data << uint8(move_spline.spline.mode());       // added in 3.1
            data << (move_spline.isCyclic() ? Vector3::zero() : move_spline.FinalDestination());
        }
    }

References Movement::FacingInfo::angle, ByteBuffer::append(), Movement::MoveSpline::Duration(), Movement::MoveSpline::effect_start_time, Movement::FacingInfo::f, Movement::MoveSpline::facing, Movement::MoveSplineFlag::final_angle, Movement::MoveSplineFlag::final_point, Movement::MoveSplineFlag::final_target, Movement::MoveSpline::FinalDestination(), Movement::MoveSpline::GetId(), Movement::MoveSpline::getPath(), Movement::MoveSpline::isCyclic(), Movement::SplineBase::mode(), Movement::MoveSplineFlag::raw(), Movement::MoveSpline::spline, Movement::MoveSpline::splineflags, Movement::FacingInfo::target, Movement::MoveSpline::timePassed(), Movement::MoveSpline::vertical_acceleration, Movement::FacingInfo::x, Movement::FacingInfo::y, and Movement::FacingInfo::z.

Referenced by Object::BuildMovementUpdate().

WriteMonsterMove()

void Movement::PacketBuilder::WriteMonsterMove ( const MoveSpline &  mov, ByteBuffer &  data  )

static

    {
        WriteCommonMonsterMovePart(move_spline, data);
 
        const Spline<int32>& spline = move_spline.spline;
        MoveSplineFlag splineflags = move_spline.splineflags;
        if (splineflags & MoveSplineFlag::Mask_CatmullRom)
        {
            if (splineflags.cyclic)
                WriteCatmullRomCyclicPath(spline, data, splineflags & MoveSplineFlag::Flying);
            else
                WriteCatmullRomPath(spline, data);
        }
        else
            WriteLinearPath(spline, data);
    }

References Movement::MoveSplineFlag::cyclic, Movement::MoveSplineFlag::Flying, Movement::MoveSplineFlag::Mask_CatmullRom, Movement::MoveSpline::spline, Movement::MoveSpline::splineflags, Movement::WriteCatmullRomCyclicPath(), Movement::WriteCatmullRomPath(), WriteCommonMonsterMovePart(), and Movement::WriteLinearPath().

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

WriteStopMovement()

void Movement::PacketBuilder::WriteStopMovement ( Vector3 const &  loc, uint32  splineId, ByteBuffer &  data  )

static

    {
        data << uint8(0);                                       // sets/unsets MOVEMENTFLAG2_UNK7 (0x40)
        data << pos;
        data << splineId;
        data << uint8(MonsterMoveStop);
    }

References Movement::MonsterMoveStop.

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