/* * This file is part of the TrinityCore Project. See AUTHORS file for Copyright information * * 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, see . */ #include "SpellPackets.h" #include "Spell.h" #include "SpellInfo.h" ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Spells::SpellHealPrediction const& predict) { data << int32(predict.Points); data << uint8(predict.Type); if (predict.BeaconGUID.has_value()) data << predict.BeaconGUID->WriteAsPacked(); return data; } ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Spells::CreatureImmunities const& immunities) { data << int32(immunities.School); data << int32(immunities.Value); return data; } ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Spells::MissileTrajectoryResult const& missileTrajectory) { data << float(missileTrajectory.Pitch); data << int32(missileTrajectory.TravelTime); return data; } ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Spells::SpellAmmo const& spellAmmo) { data << int32(spellAmmo.DisplayID); data << int32(spellAmmo.InventoryType); return data; } ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Spells::RuneData const& runeData) { data << uint8(runeData.Start); data << uint8(runeData.Count); if (!runeData.Cooldowns.empty()) data.append(runeData.Cooldowns.data(), runeData.Cooldowns.size()); return data; } ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Spells::TargetLocation const& targetLocation) { data << targetLocation.Transport.WriteAsPacked(); data << targetLocation.Location.PositionXYZStream(); return data; } ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Spells::ProjectileVisual const& projectileVisual) { data << int32(projectileVisual.Id[0]); data << int32(projectileVisual.Id[1]); return data; } ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Spells::SpellTargetData const& spellTargetData) { data << uint32(spellTargetData.Flags); if (spellTargetData.Unit.has_value()) data << spellTargetData.Unit->WriteAsPacked(); if (spellTargetData.Item.has_value()) data << spellTargetData.Item->WriteAsPacked(); if (spellTargetData.SrcLocation) data << *spellTargetData.SrcLocation; if (spellTargetData.DstLocation) data << *spellTargetData.DstLocation; if (spellTargetData.Name.has_value()) data << *spellTargetData.Name; return data; } ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Spells::SpellHitInfo const& spellHitInfo) { data << uint8(spellHitInfo.HitTargets.size()); for (ObjectGuid const& hitTarget : spellHitInfo.HitTargets) data << hitTarget; data << uint8(spellHitInfo.MissStatus.size()); for (WorldPackets::Spells::SpellMissStatus const& missTarget : spellHitInfo.MissStatus) { data << missTarget.MissTarget; data << uint8(missTarget.Reason); if (missTarget.Reason == SPELL_MISS_REFLECT) data << uint8(missTarget.ReflectStatus); } return data; } ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Spells::SpellCastData const& spellCastData) { data << spellCastData.CasterGUID.WriteAsPacked(); data << spellCastData.CasterUnit.WriteAsPacked(); data << uint8(spellCastData.CastID); data << uint32(spellCastData.SpellID); data << uint32(spellCastData.CastFlags); data << uint32(spellCastData.CastFlagsEx); data << uint32(spellCastData.CastTime); if (spellCastData.HitInfo) { // Hit and miss target counts are both uint8, that limits us to 255 targets for each // sending more than 255 targets crashes the client (since count sent would be wrong) // Spells like 40647 (with a huge radius) can easily reach this limit (spell might need // target conditions but we still need to limit the number of targets sent and keeping // correct count for both hit and miss). static std::size_t const PACKET_TARGET_LIMIT = std::numeric_limits::max(); if (spellCastData.HitInfo->HitTargets.size() > PACKET_TARGET_LIMIT) spellCastData.HitInfo->HitTargets.resize(PACKET_TARGET_LIMIT); if (spellCastData.HitInfo->MissStatus.size() > PACKET_TARGET_LIMIT) spellCastData.HitInfo->MissStatus.resize(PACKET_TARGET_LIMIT); data << *spellCastData.HitInfo; } data << spellCastData.Target; if (spellCastData.RemainingPower.has_value()) data << uint32(*spellCastData.RemainingPower); if (spellCastData.RemainingRunes) data << *spellCastData.RemainingRunes; if (spellCastData.MissileTrajectory) data << *spellCastData.MissileTrajectory; if (spellCastData.Ammo) data << *spellCastData.Ammo; if (spellCastData.ProjectileVisuals) data << *spellCastData.ProjectileVisuals; if (spellCastData.DestLocSpellCastIndex.has_value()) data << uint8(*spellCastData.DestLocSpellCastIndex); // Todo: TARGET_FLAG_EXTRA_TARGETS (unused as it seems though) if (spellCastData.Immunities) data << *spellCastData.Immunities; if (spellCastData.Predict) data << *spellCastData.Predict; return data; } WorldPacket const* WorldPackets::Spells::SpellStart::Write() { _worldPacket << Cast; return &_worldPacket; } WorldPacket const* WorldPackets::Spells::SpellGo::Write() { _worldPacket << Cast; return &_worldPacket; } ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Spells::TargetedHealPrediction const& predict) { data << predict.TargetGUID.WriteAsPacked(); data << predict.Predict; return data; } ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Spells::ChannelStartInterruptImmunities const& immunity) { data << immunity.SchoolImmunities; data << immunity.Immunities; return data; } WorldPacket const* WorldPackets::Spells::ChannelStart::Write() { _worldPacket << CasterGUID.WriteAsPacked(); _worldPacket << uint32(SpellID); _worldPacket << int32(ChannelDuration); _worldPacket << uint8(InterruptImmunities.has_value()); if (InterruptImmunities) _worldPacket << *InterruptImmunities; _worldPacket << uint8(HealPrediction.has_value()); if (HealPrediction) _worldPacket << *HealPrediction; return &_worldPacket; } WorldPacket const* WorldPackets::Spells::MountResult::Write() { _worldPacket << int32(Result); return &_worldPacket; } ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Spells::AuraDataInfo const& auraData) { data << int32(auraData.SpellID); if (auraData.SpellID <= 0) return data; data << int16(auraData.Flags); data << uint8(auraData.CastLevel); data << uint8(auraData.Applications); if (auraData.CastUnit) data << auraData.CastUnit.value().WriteAsPacked(); if (auraData.Duration) data << int32(*auraData.Duration); if (auraData.Remaining) data << int32(*auraData.Remaining); for (uint8 i = 0; i < 3 /*MAX_SPELL_EFFECTS*/; ++i) if (auraData.Points[i].has_value()) data << int32(*auraData.Points[i]); return data; } ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Spells::AuraInfo const& aura) { data << uint8(aura.Slot); data << aura.AuraData; return data; } WorldPacket const* WorldPackets::Spells::AuraUpdate::Write() { _worldPacket << UnitGUID.WriteAsPacked(); for (AuraInfo const& aura : Auras) _worldPacket << aura; return &_worldPacket; } WorldPacket const* WorldPackets::Spells::AuraUpdateAll::Write() { _worldPacket << UnitGUID.WriteAsPacked(); for (AuraInfo const& aura : Auras) _worldPacket << aura; return &_worldPacket; } WorldPacket const* WorldPackets::Spells::MissileCancel::Write() { _worldPacket.WriteBit(OwnerGUID[7]); _worldPacket.WriteBit(OwnerGUID[2]); _worldPacket.WriteBit(OwnerGUID[4]); _worldPacket.WriteBit(OwnerGUID[6]); _worldPacket.WriteBit(Reverse); _worldPacket.WriteBit(OwnerGUID[1]); _worldPacket.WriteBit(OwnerGUID[0]); _worldPacket.WriteBit(OwnerGUID[3]); _worldPacket.WriteBit(OwnerGUID[5]); _worldPacket.FlushBits(); _worldPacket.WriteByteSeq(OwnerGUID[6]); _worldPacket.WriteByteSeq(OwnerGUID[1]); _worldPacket.WriteByteSeq(OwnerGUID[4]); _worldPacket.WriteByteSeq(OwnerGUID[2]); _worldPacket.WriteByteSeq(OwnerGUID[5]); _worldPacket.WriteByteSeq(OwnerGUID[7]); _worldPacket << uint32(SpellID); _worldPacket.WriteByteSeq(OwnerGUID[0]); _worldPacket.WriteByteSeq(OwnerGUID[3]); return &_worldPacket; } WorldPacket const* WorldPackets::Spells::CategoryCooldown::Write() { _worldPacket.reserve(4 + 8 * CategoryCooldowns.size()); _worldPacket.WriteBits(CategoryCooldowns.size(), 23); _worldPacket.FlushBits(); for (CategoryCooldownInfo const& cooldown : CategoryCooldowns) { _worldPacket << uint32(cooldown.Category); _worldPacket << int32(cooldown.ModCooldown); } return &_worldPacket; } WorldPacket const* WorldPackets::Spells::PlaySpellVisual::Write() { _worldPacket << float(TargetPosition.GetPositionZ()); _worldPacket << int32(SpellVisualID); _worldPacket << uint16(MissReason); _worldPacket << float(TargetPosition.GetOrientation()); _worldPacket << float(TargetPosition.GetPositionX()); _worldPacket << uint16(ReflectStatus); _worldPacket << float(TargetPosition.GetPositionY()); _worldPacket.WriteBit(Target[1]); _worldPacket.WriteBit(Source[3]); _worldPacket.WriteBit(Source[0]); _worldPacket.WriteBit(Target[2]); _worldPacket.WriteBit(Target[5]); _worldPacket.WriteBit(Source[2]); _worldPacket.WriteBit(Source[4]); _worldPacket.WriteBit(Target[6]); _worldPacket.WriteBit(SpeedAsTime); _worldPacket.WriteBit(Source[6]); _worldPacket.WriteBit(Target[7]); _worldPacket.WriteBit(Source[5]); _worldPacket.WriteBit(Source[1]); _worldPacket.WriteBit(Source[7]); _worldPacket.WriteBit(Target[3]); _worldPacket.WriteBit(Target[4]); _worldPacket.FlushBits(); _worldPacket.WriteByteSeq(Source[7]); _worldPacket.WriteByteSeq(Source[4]); _worldPacket.WriteByteSeq(Target[7]); _worldPacket.WriteByteSeq(Source[1]); _worldPacket.WriteByteSeq(Source[3]); _worldPacket.WriteByteSeq(Source[0]); _worldPacket.WriteByteSeq(Source[6]); _worldPacket.WriteByteSeq(Target[0]); _worldPacket.WriteByteSeq(Target[4]); _worldPacket.WriteByteSeq(Source[5]); _worldPacket.WriteByteSeq(Target[1]); _worldPacket.WriteByteSeq(Target[5]); _worldPacket.WriteByteSeq(Target[6]); _worldPacket.WriteByteSeq(Target[2]); _worldPacket.WriteByteSeq(Source[2]); _worldPacket.WriteByteSeq(Target[3]); return &_worldPacket; } WorldPacket const* WorldPackets::Spells::PlaySpellVisualKit::Write() { _worldPacket << uint32(Duration); _worldPacket << int32(KitRecID); _worldPacket << int32(KitType); _worldPacket.WriteBit(Unit[4]); _worldPacket.WriteBit(Unit[7]); _worldPacket.WriteBit(Unit[5]); _worldPacket.WriteBit(Unit[3]); _worldPacket.WriteBit(Unit[1]); _worldPacket.WriteBit(Unit[2]); _worldPacket.WriteBit(Unit[0]); _worldPacket.WriteBit(Unit[6]); _worldPacket.WriteByteSeq(Unit[0]); _worldPacket.WriteByteSeq(Unit[4]); _worldPacket.WriteByteSeq(Unit[1]); _worldPacket.WriteByteSeq(Unit[6]); _worldPacket.WriteByteSeq(Unit[7]); _worldPacket.WriteByteSeq(Unit[2]); _worldPacket.WriteByteSeq(Unit[3]); _worldPacket.WriteByteSeq(Unit[5]); return &_worldPacket; } WorldPacket const* WorldPackets::Spells::SendKnownSpells::Write() { _worldPacket.reserve(1 + 2 + 6 * KnownSpells.size() + 2 + 14 * SpellHistoryEntries.size()); _worldPacket << uint8(InitialLogin); _worldPacket << uint16(KnownSpells.size()); for (uint32 SpellID : KnownSpells) { _worldPacket << uint32(SpellID); _worldPacket << int16(0); // Slot (unused) } _worldPacket << uint16(SpellHistoryEntries.size()); for (SpellHistoryEntry const& entry : SpellHistoryEntries) { _worldPacket << uint32(entry.SpellID); _worldPacket << uint32(entry.ItemID); _worldPacket << uint16(entry.Category); _worldPacket << int32(entry.RecoveryTime); _worldPacket << int32(entry.CategoryRecoveryTime); } return &_worldPacket; } WorldPacket const* WorldPackets::Spells::SendUnlearnSpells::Write() { _worldPacket << uint32(Spells.size()); for (uint32 spellId : Spells) _worldPacket << uint32(spellId); return &_worldPacket; } WorldPacket const* WorldPackets::Spells::UnlearnedSpells::Write() { _worldPacket << uint32(SpellID); return &_worldPacket; } WorldPacket const* WorldPackets::Spells::UpdateActionButtons::Write() { _worldPacket.append(ActionButtons.data(), ActionButtons.size()); _worldPacket << Reason; return &_worldPacket; } ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Spells::SpellModifierData const& spellModifierData) { data << uint8(spellModifierData.ClassIndex); data << float(spellModifierData.ModifierValue); return data; } ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Spells::SpellModifier const& spellModifier) { data << uint32(spellModifier.ModifierData.size()); data << uint8(spellModifier.ModIndex); for (WorldPackets::Spells::SpellModifierData const& modData : spellModifier.ModifierData) data << modData; return data; } WorldPacket const* WorldPackets::Spells::SetSpellModifier::Write() { _worldPacket << uint32(Modifiers.size()); for (WorldPackets::Spells::SpellModifier const& spellMod : Modifiers) _worldPacket << spellMod; return &_worldPacket; } WorldPacket const* WorldPackets::Spells::ConvertRune::Write() { _worldPacket << uint8(Index); _worldPacket << uint8(Rune); return &_worldPacket; } WorldPacket const* WorldPackets::Spells::ResyncRunes::Write() { _worldPacket << uint32(Runes.size()); for (auto const& rune : Runes) { _worldPacket << uint8(rune.RuneType); _worldPacket << uint8(rune.Cooldown); } return &_worldPacket; } WorldPacket const* WorldPackets::Spells::AddRunePower::Write() { _worldPacket << uint32(AddedRunesMask); return &_worldPacket; } WorldPacket const* WorldPackets::Spells::SupercededSpells::Write() { _worldPacket << int32(SpellID); _worldPacket << int32(Superceded); return &_worldPacket; } WorldPacket const* WorldPackets::Spells::AuraPointsDepleted::Write() { _worldPacket.WriteBit(Unit[2]); _worldPacket.WriteBit(Unit[4]); _worldPacket.WriteBit(Unit[1]); _worldPacket.WriteBit(Unit[7]); _worldPacket.WriteBit(Unit[5]); _worldPacket.WriteBit(Unit[0]); _worldPacket.WriteBit(Unit[3]); _worldPacket.WriteBit(Unit[6]); _worldPacket.WriteByteSeq(Unit[5]); _worldPacket.WriteByteSeq(Unit[0]); _worldPacket << uint8(EffectIndex); _worldPacket.WriteByteSeq(Unit[3]); _worldPacket.WriteByteSeq(Unit[7]); _worldPacket.WriteByteSeq(Unit[4]); _worldPacket.WriteByteSeq(Unit[2]); _worldPacket << uint8(Slot); _worldPacket.WriteByteSeq(Unit[6]); _worldPacket.WriteByteSeq(Unit[1]); return &_worldPacket; } WorldPacket const* WorldPackets::Spells::SpellFailure::Write() { _worldPacket << CasterUnit.WriteAsPacked(); _worldPacket << uint8(CastID); _worldPacket << int32(SpellID); _worldPacket << uint8(Reason); return &_worldPacket; } WorldPacket const* WorldPackets::Spells::SpellFailedOther::Write() { _worldPacket << CasterUnit.WriteAsPacked(); _worldPacket << uint8(CastID); _worldPacket << int32(SpellID); _worldPacket << uint8(Reason); return &_worldPacket; } WorldPacket const* WorldPackets::Spells::ResurrectRequest::Write() { _worldPacket << ResurrectOffererGUID; _worldPacket << uint32(Name.length() + 1); _worldPacket << Name; // client expects a null-terminated string _worldPacket << bool(Sickness); _worldPacket << bool(UseTimer); _worldPacket << int32(SpellID); return &_worldPacket; } WorldPacket const* WorldPackets::Spells::SpellDelayed::Write() { _worldPacket << Caster.WriteAsPacked(); _worldPacket << int32(ActualDelay); return &_worldPacket; } ByteBuffer& operator>>(ByteBuffer& data, Optional& location) { location.emplace(); data >> location->Transport.ReadAsPacked(); data >> location->Location.m_positionX; data >> location->Location.m_positionY; data >> location->Location.m_positionZ; return data; } ByteBuffer& operator>>(ByteBuffer& data, WorldPackets::Spells::SpellTargetData& targetData) { data >> targetData.Flags; if (targetData.Flags & (TARGET_FLAG_UNIT | TARGET_FLAG_UNIT_MINIPET | TARGET_FLAG_GAMEOBJECT | TARGET_FLAG_CORPSE_ENEMY | TARGET_FLAG_CORPSE_ALLY)) { targetData.Unit.emplace(); data >> targetData.Unit->ReadAsPacked(); } if (targetData.Flags & (TARGET_FLAG_ITEM | TARGET_FLAG_TRADE_ITEM)) { targetData.Item.emplace(); data >> targetData.Item->ReadAsPacked(); } if (targetData.Flags & TARGET_FLAG_SOURCE_LOCATION) data >> targetData.SrcLocation; if (targetData.Flags & TARGET_FLAG_DEST_LOCATION) data >> targetData.DstLocation; if (targetData.Flags & TARGET_FLAG_STRING) { targetData.Name.emplace(); data >> *targetData.Name; } return data; } ByteBuffer& operator>>(ByteBuffer& data, Optional& movementInfo) { movementInfo.emplace(); data >> movementInfo->pos.m_positionZ; data >> movementInfo->pos.m_positionY; data >> movementInfo->pos.m_positionX; bool hasFallData = data.ReadBit(); bool hasTime = !data.ReadBit(); bool hasFacing = !data.ReadBit(); data.ReadBit(); // HasSpline data.ReadBit(); // HeightChangeFailed movementInfo->guid[6] = data.ReadBit(); movementInfo->guid[4] = data.ReadBit(); bool hasExtraMovementFlags = !data.ReadBit(); movementInfo->guid[3] = data.ReadBit(); movementInfo->guid[5] = data.ReadBit(); bool hasSplineElevation = !data.ReadBit(); bool hasPitch = !data.ReadBit(); movementInfo->guid[7] = data.ReadBit(); bool hasTransportData = data.ReadBit(); movementInfo->guid[2] = data.ReadBit(); bool hasMovementFlags = !data.ReadBit(); movementInfo->guid[1] = data.ReadBit(); movementInfo->guid[0] = data.ReadBit(); bool hasTransportTime2 = false; bool hasVehicleRecId = false; if (hasTransportData) { movementInfo->transport.guid[6] = data.ReadBit(); movementInfo->transport.guid[2] = data.ReadBit(); movementInfo->transport.guid[5] = data.ReadBit(); hasTransportTime2 = data.ReadBit(); movementInfo->transport.guid[7] = data.ReadBit(); movementInfo->transport.guid[4] = data.ReadBit(); hasVehicleRecId = data.ReadBit(); movementInfo->transport.guid[0] = data.ReadBit(); movementInfo->transport.guid[1] = data.ReadBit(); movementInfo->transport.guid[3] = data.ReadBit(); } if (hasExtraMovementFlags) movementInfo->SetExtraMovementFlags(data.ReadBits(12)); if (hasMovementFlags) movementInfo->SetMovementFlags(data.ReadBits(30)); bool hasFallDirection = false; if (hasFallData) hasFallDirection = data.ReadBit(); data.ReadByteSeq(movementInfo->guid[1]); data.ReadByteSeq(movementInfo->guid[4]); data.ReadByteSeq(movementInfo->guid[7]); data.ReadByteSeq(movementInfo->guid[3]); data.ReadByteSeq(movementInfo->guid[0]); data.ReadByteSeq(movementInfo->guid[2]); data.ReadByteSeq(movementInfo->guid[5]); data.ReadByteSeq(movementInfo->guid[6]); if (hasTransportData) { data >> movementInfo->transport.seat; movementInfo->transport.pos.SetOrientation(data.read()); data >> movementInfo->transport.time; data.ReadByteSeq(movementInfo->transport.guid[6]); data.ReadByteSeq(movementInfo->transport.guid[5]); if (hasTransportTime2) data >> movementInfo->transport.time2; data >> movementInfo->transport.pos.m_positionX; data.ReadByteSeq(movementInfo->transport.guid[4]); data >> movementInfo->transport.pos.m_positionZ; data.ReadByteSeq(movementInfo->transport.guid[2]); data.ReadByteSeq(movementInfo->transport.guid[0]); if (hasVehicleRecId) data >> movementInfo->transport.vehicleId; data.ReadByteSeq(movementInfo->transport.guid[1]); data.ReadByteSeq(movementInfo->transport.guid[3]); data >> movementInfo->transport.pos.m_positionY; data.ReadByteSeq(movementInfo->transport.guid[7]); } if (hasFacing) movementInfo->pos.SetOrientation(data.read()); if (hasSplineElevation) data >> movementInfo->splineElevation; if (hasFallData) { data >> movementInfo->jump.fallTime; if (hasFallDirection) { data >> movementInfo->jump.sinAngle; data >> movementInfo->jump.cosAngle; data >> movementInfo->jump.xyspeed; } data >> movementInfo->jump.zspeed; } if (hasTime) data >> movementInfo->time; if (hasPitch) data >> movementInfo->pitch; return data; } ByteBuffer& operator>>(ByteBuffer& data, WorldPackets::Spells::MissileTrajectoryRequest& missileTrajectory) { data >> missileTrajectory.Pitch; data >> missileTrajectory.Speed; return data; } ByteBuffer& operator>>(ByteBuffer& data, WorldPackets::Spells::SpellCastRequest& castRequest) { data >> castRequest.CastID; data >> castRequest.SpellID; data >> castRequest.Misc; data >> castRequest.SendCastFlags; data >> castRequest.Target; if (castRequest.SendCastFlags & CAST_FLAG_HAS_TRAJECTORY) { data >> castRequest.MissileTrajectory; bool hasMovementData = data.read(); if (hasMovementData) data >> castRequest.MoveUpdate; } if (castRequest.SendCastFlags & CAST_FLAG_HAS_WEIGHT) { uint32 weightCount = data.read(); castRequest.Weight.resize(weightCount); for (WorldPackets::Spells::SpellWeight& weight : castRequest.Weight) { data >> weight.Type; data >> weight.ID; data >> weight.Quantity; } } return data; } void WorldPackets::Spells::CastSpell::Read() { _worldPacket >> Cast; } void WorldPackets::Spells::UseItem::Read() { _worldPacket >> PackSlot; _worldPacket >> Slot; _worldPacket >> Cast.CastID; _worldPacket >> Cast.SpellID; _worldPacket >> CastItem; _worldPacket >> Cast.Misc; _worldPacket >> Cast.SendCastFlags; _worldPacket >> Cast.Target; if (Cast.SendCastFlags & CAST_FLAG_HAS_TRAJECTORY) { _worldPacket >> Cast.MissileTrajectory; bool hasMovementData = _worldPacket.read(); if (hasMovementData) _worldPacket >> Cast.MoveUpdate; } if (Cast.SendCastFlags & CAST_FLAG_HAS_WEIGHT) { uint32 weightCount = _worldPacket.read(); Cast.Weight.resize(weightCount); for (WorldPackets::Spells::SpellWeight& weight : Cast.Weight) { _worldPacket >> weight.Type; _worldPacket >> weight.ID; _worldPacket >> weight.Quantity; } } } void WorldPackets::Spells::UpdateMissileTrajectory::Read() { _worldPacket >> FirePos.Pos.m_positionZ; _worldPacket >> FirePos.Pos.m_positionX; _worldPacket >> Pitch; _worldPacket >> ImpactPos.Pos.m_positionX; _worldPacket >> FirePos.Pos.m_positionY; _worldPacket >> Speed; _worldPacket >> ImpactPos.Pos.m_positionY; _worldPacket >> MoveMsgID; _worldPacket >> SpellID; _worldPacket >> ImpactPos.Pos.m_positionZ; Guid[5] = _worldPacket.ReadBit(); Guid[6] = _worldPacket.ReadBit(); Guid[0] = _worldPacket.ReadBit(); Guid[7] = _worldPacket.ReadBit(); Guid[1] = _worldPacket.ReadBit(); Guid[3] = _worldPacket.ReadBit(); Guid[2] = _worldPacket.ReadBit(); Guid[4] = _worldPacket.ReadBit(); bool hasFallData = false; bool hasFallVelocity = false; bool hasFacing = false; bool hasTransportData = false; bool hasTransportTime2 = false; bool hasVehicleId = false; bool hasSplineElevation = false; bool hasPitch = false; bool hasMoveTime = false; // Thanks to Cataclysm's randomized packet structures we now have to read the packet like this instead of using the MovementStructures helper if (_worldPacket.ReadBit()) { Status.emplace(); Status->guid[2] = _worldPacket.ReadBit(); Status->heightChangeFailed = _worldPacket.ReadBit(); bool hasMovementFlags0 = !_worldPacket.ReadBit(); _worldPacket.ReadBit(); // hasSpline Status->guid[4] = _worldPacket.ReadBit(); if (hasMovementFlags0) Status->SetMovementFlags(_worldPacket.ReadBits(30)); Status->guid[3] = _worldPacket.ReadBit(); hasPitch = _worldPacket.ReadBit(); bool hasMovementFlags1 = _worldPacket.ReadBit(); hasTransportData = _worldPacket.ReadBit(); Status->guid[7] = _worldPacket.ReadBit(); if (hasTransportData) { Status->transport.guid[0] = _worldPacket.ReadBit(); Status->transport.guid[7] = _worldPacket.ReadBit(); Status->transport.guid[2] = _worldPacket.ReadBit(); Status->transport.guid[4] = _worldPacket.ReadBit(); hasVehicleId = _worldPacket.ReadBit(); Status->transport.guid[5] = _worldPacket.ReadBit(); Status->transport.guid[3] = _worldPacket.ReadBit(); Status->transport.guid[6] = _worldPacket.ReadBit(); hasTransportTime2 = _worldPacket.ReadBit(); Status->transport.guid[1] = _worldPacket.ReadBit(); } Status->guid[6] = _worldPacket.ReadBit(); hasFacing = !_worldPacket.ReadBit(); hasMoveTime = !_worldPacket.ReadBit(); Status->guid[5] = _worldPacket.ReadBit(); hasSplineElevation = !_worldPacket.ReadBit(); Status->guid[1] = _worldPacket.ReadBit(); hasFallData = _worldPacket.ReadBit(); Status->guid[0] = _worldPacket.ReadBit(); if (hasFallData) hasFallVelocity = _worldPacket.ReadBit(); if (hasMovementFlags1) Status->SetExtraMovementFlags(_worldPacket.ReadBits(12)); } _worldPacket.ReadByteSeq(Guid[2]); _worldPacket.ReadByteSeq(Guid[1]); _worldPacket.ReadByteSeq(Guid[3]); _worldPacket.ReadByteSeq(Guid[7]); _worldPacket.ReadByteSeq(Guid[6]); _worldPacket.ReadByteSeq(Guid[4]); _worldPacket.ReadByteSeq(Guid[0]); _worldPacket.ReadByteSeq(Guid[5]); if (Status.has_value()) { if (hasFallData) { if (hasFallVelocity) { _worldPacket >> Status->jump.cosAngle; _worldPacket >> Status->jump.sinAngle; _worldPacket >> Status->jump.xyspeed; } _worldPacket >> Status->jump.zspeed; _worldPacket >> Status->jump.fallTime; } if (hasFacing) Status->pos.SetOrientation(_worldPacket.read()); if (hasTransportData) { _worldPacket >> Status->transport.pos.m_positionZ; _worldPacket.ReadByteSeq(Status->transport.guid[3]); _worldPacket.ReadByteSeq(Status->transport.guid[7]); _worldPacket >> Status->transport.pos.m_positionX; Status->transport.pos.SetOrientation(_worldPacket.read()); if (hasTransportTime2) _worldPacket >> Status->transport.time2; _worldPacket.ReadByteSeq(Status->transport.guid[2]); _worldPacket >> Status->transport.time; _worldPacket.ReadByteSeq(Status->transport.guid[0]); _worldPacket >> Status->transport.pos.m_positionY; if (hasVehicleId) _worldPacket >> Status->transport.vehicleId; _worldPacket.ReadByteSeq(Status->transport.guid[4]); _worldPacket.ReadByteSeq(Status->transport.guid[6]); _worldPacket.ReadByteSeq(Status->transport.guid[1]); _worldPacket >> Status->transport.seat; _worldPacket.ReadByteSeq(Status->transport.guid[5]); } if (hasSplineElevation) _worldPacket >> Status->splineElevation; _worldPacket.ReadByteSeq(Status->guid[4]); if (hasPitch) _worldPacket >> Status->pitch; _worldPacket.ReadByteSeq(Status->guid[7]); _worldPacket.ReadByteSeq(Status->guid[2]); if (hasMoveTime) _worldPacket >> Status->time; _worldPacket >> Status->pos.m_positionX; _worldPacket.ReadByteSeq(Status->guid[5]); _worldPacket.ReadByteSeq(Status->guid[3]); _worldPacket.ReadByteSeq(Status->guid[1]); _worldPacket.ReadByteSeq(Status->guid[0]); _worldPacket >> Status->pos.m_positionY; _worldPacket >> Status->pos.m_positionZ; _worldPacket.ReadByteSeq(Status->guid[6]); } } WorldPacket const* WorldPackets::Spells::ClearCooldown::Write() { _worldPacket << int32(SpellID); _worldPacket << CasterGUID; return &_worldPacket; } WorldPacket const* WorldPackets::Spells::ClearCooldowns::Write() { _worldPacket.WriteBit(Guid[1]); _worldPacket.WriteBit(Guid[3]); _worldPacket.WriteBit(Guid[6]); _worldPacket.WriteBits(SpellID.size(), 24); _worldPacket.WriteBit(Guid[7]); _worldPacket.WriteBit(Guid[5]); _worldPacket.WriteBit(Guid[2]); _worldPacket.WriteBit(Guid[4]); _worldPacket.WriteBit(Guid[0]); _worldPacket.WriteByteSeq(Guid[7]); _worldPacket.WriteByteSeq(Guid[2]); _worldPacket.WriteByteSeq(Guid[4]); _worldPacket.WriteByteSeq(Guid[5]); _worldPacket.WriteByteSeq(Guid[1]); _worldPacket.WriteByteSeq(Guid[3]); if (!SpellID.empty()) _worldPacket.append(SpellID.data(), SpellID.size()); _worldPacket.WriteByteSeq(Guid[0]); _worldPacket.WriteByteSeq(Guid[6]); return &_worldPacket; }