/* * Copyright (C) 2008-2020 TrinityCore * Copyright (C) 2005-2011 MaNGOS * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include "MovementPacketBuilder.h" #include "MoveSpline.h" #include "WorldPacket.h" #include "Object.h" namespace Movement { inline void operator << (ByteBuffer& b, const Vector3& v) { b << v.x << v.y << v.z; } inline void operator >> (ByteBuffer& b, Vector3& v) { b >> v.x >> v.y >> v.z; } enum MonsterMoveType { MonsterMoveNormal = 0, MonsterMoveStop = 1, MonsterMoveFacingSpot = 2, MonsterMoveFacingTarget = 3, MonsterMoveFacingAngle = 4 }; void PacketBuilder::WriteCommonMonsterMovePart(const MoveSpline& move_spline, WorldPacket& data) { 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; } 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; } } void PacketBuilder::WriteStopMovement(Vector3 const& pos, uint32 splineId, ByteBuffer& data) { data << uint8(0); // sets/unsets MOVEMENTFLAG2_UNK7 (0x40) data << pos; data << splineId; data << uint8(MonsterMoveStop); } void WriteLinearPath(Spline const& spline, ByteBuffer& data) { uint32 last_idx = spline.getPointCount() - 3; Vector3 const* 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); } } } void WriteUncompressedPath(Spline const& spline, ByteBuffer& data) { uint32 count = spline.getPointCount() - 3; data << count; data.append(&spline.getPoint(2), count); } void WriteUncompressedCyclicPath(Spline const& spline, ByteBuffer& data) { uint32 count = spline.getPointCount() - 4; data << count; data.append(&spline.getPoint(2), count); } void PacketBuilder::WriteMonsterMove(const MoveSpline& move_spline, WorldPacket& data) { WriteCommonMonsterMovePart(move_spline, data); Spline const& spline = move_spline.spline; MoveSplineFlag splineflags = move_spline.splineflags; if (splineflags & MoveSplineFlag::UncompressedPath) { if (!splineflags.cyclic) WriteUncompressedPath(spline, data); else WriteUncompressedCyclicPath(spline, data); } else WriteLinearPath(spline, data); } void PacketBuilder::WriteCreateBits(MoveSpline const& moveSpline, ByteBuffer& data) { if (!data.WriteBit(!moveSpline.Finalized())) return; data.WriteBits(uint8(moveSpline.spline.mode()), 2); data.WriteBit(moveSpline.splineflags & (MoveSplineFlag::Parabolic | MoveSplineFlag::Animation)); data.WriteBits(moveSpline.getPath().size(), 22); switch (moveSpline.splineflags & MoveSplineFlag::Mask_Final_Facing) { case MoveSplineFlag::Final_Target: { ObjectGuid targetGuid(moveSpline.facing.target); data.WriteBits(2, 2); data.WriteBit(targetGuid[4]); data.WriteBit(targetGuid[3]); data.WriteBit(targetGuid[7]); data.WriteBit(targetGuid[2]); data.WriteBit(targetGuid[6]); data.WriteBit(targetGuid[1]); data.WriteBit(targetGuid[0]); data.WriteBit(targetGuid[5]); break; } case MoveSplineFlag::Final_Angle: data.WriteBits(0, 2); break; case MoveSplineFlag::Final_Point: data.WriteBits(1, 2); break; default: data.WriteBits(3, 2); break; } data.WriteBit((moveSpline.splineflags & MoveSplineFlag::Parabolic) && moveSpline.effect_start_time < moveSpline.Duration()); data.WriteBits(moveSpline.splineflags.raw(), 25); } void PacketBuilder::WriteCreateData(MoveSpline const& moveSpline, ByteBuffer& data) { if (!moveSpline.Finalized()) { MoveSplineFlag const& splineFlags = moveSpline.splineflags; if ((splineFlags & MoveSplineFlag::Parabolic) && moveSpline.effect_start_time < moveSpline.Duration()) data << moveSpline.vertical_acceleration; // added in 3.1 data << moveSpline.timePassed(); if (splineFlags.final_angle) data << moveSpline.facing.angle; else if (splineFlags.final_target) { ObjectGuid facingGuid(moveSpline.facing.target); data.WriteByteSeq(facingGuid[5]); data.WriteByteSeq(facingGuid[3]); data.WriteByteSeq(facingGuid[7]); data.WriteByteSeq(facingGuid[1]); data.WriteByteSeq(facingGuid[6]); data.WriteByteSeq(facingGuid[4]); data.WriteByteSeq(facingGuid[2]); data.WriteByteSeq(facingGuid[0]); } uint32 nodes = moveSpline.getPath().size(); for (uint32 i = 0; i < nodes; ++i) { data << float(moveSpline.getPath()[i].z); data << float(moveSpline.getPath()[i].x); data << float(moveSpline.getPath()[i].y); } if (splineFlags.final_point) data << moveSpline.facing.f.x << moveSpline.facing.f.z << moveSpline.facing.f.y; data << float(1.f); // splineInfo.duration_mod_next; added in 3.1 data << moveSpline.Duration(); if (splineFlags & (MoveSplineFlag::Parabolic | MoveSplineFlag::Animation)) data << moveSpline.effect_start_time; // added in 3.1 data << float(1.f); // splineInfo.duration_mod; added in 3.1 } if (!moveSpline.isCyclic()) { Vector3 dest = moveSpline.FinalDestination(); data << float(dest.z); data << float(dest.x); data << float(dest.y); } else data << Vector3::zero(); data << moveSpline.GetId(); } void PacketBuilder::WriteSplineSync(MoveSpline const& moveSpline, ByteBuffer& data) { data << (float)moveSpline.timePassed() / moveSpline.Duration(); } }