/*
* 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"
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;
}