Core/PacketIO: Updated spell packets

5 files changed, 245 insertions, 144 deletions

diff --git a/src/server/game/Server/Packets/MovementPackets.cpp b/src/server/game/Server/Packets/MovementPackets.cpp
index 209aab0af00..fde1b1bf875 100644
--- a/src/server/game/Server/Packets/MovementPackets.cpp
+++ b/src/server/game/Server/Packets/MovementPackets.cpp
@@ -89,11 +89,11 @@ ByteBuffer& operator>>(ByteBuffer& data, MovementInfo& movementInfo)
     data >> movementInfo.pitch;
     data >> movementInfo.splineElevation;
 
-    uint32 removeMovementForcesCount = 0;
+    uint32 removeMovementForcesCount;
     data >> removeMovementForcesCount;
 
-    uint32 int168;
-    data >> int168;
+    uint32 moveIndex;
+    data >> moveIndex;
 
     for (uint32 i = 0; i < removeMovementForcesCount; ++i)
     {
diff --git a/src/server/game/Server/Packets/SpellPackets.cpp b/src/server/game/Server/Packets/SpellPackets.cpp
index 59d39183cea..36ce28478f0 100644
--- a/src/server/game/Server/Packets/SpellPackets.cpp
+++ b/src/server/game/Server/Packets/SpellPackets.cpp
@@ -52,7 +52,7 @@ WorldPacket const* WorldPackets::Spells::CategoryCooldown::Write()
 
 WorldPacket const* WorldPackets::Spells::SendKnownSpells::Write()
 {
-    _worldPacket.reserve(1 + 4 * KnownSpells.size());
+    _worldPacket.reserve(1 + 4 * KnownSpells.size() + 4 * FavoriteSpells.size());
 
     _worldPacket.WriteBit(InitialLogin);
     _worldPacket << uint32(KnownSpells.size());
@@ -102,64 +102,95 @@ void WorldPackets::Spells::SpellCastLogData::Initialize(Unit const* unit)
 
 ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Spells::SpellCastLogData const& spellCastLogData)
 {
-    data << spellCastLogData.Health;
-    data << spellCastLogData.AttackPower;
-    data << spellCastLogData.SpellPower;
-    data << int32(spellCastLogData.PowerData.size());
+    data << int64(spellCastLogData.Health);
+    data << int32(spellCastLogData.AttackPower);
+    data << int32(spellCastLogData.SpellPower);
+    data.WriteBits(spellCastLogData.PowerData.size(), 9);
+    data.FlushBits();
+
     for (WorldPackets::Spells::SpellLogPowerData const& powerData : spellCastLogData.PowerData)
     {
-        data << powerData.PowerType;
-        data << powerData.Amount;
+        data << int32(powerData.PowerType);
+        data << int32(powerData.Amount);
     }
-    data.WriteBit(false);
-    // data << float // Unk data if bit is true
+
+    return data;
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Spells::SandboxScalingData const& unknown)
+{
+    data.WriteBits(unknown.Type, 3);
+    data << int16(unknown.PlayerLevelDelta);
+    data << uint8(unknown.TargetLevel);
+    data << uint8(unknown.Expansion);
+    data << uint8(unknown.Class);
+    data << uint8(unknown.TargetMinScalingLevel);
+    data << uint8(unknown.TargetMaxScalingLevel);
+    data << int8(unknown.TargetScalingLevelDelta);
+    return data;
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Spells::AuraDataInfo const& auraData)
+{
+    data << auraData.CastID;
+    data << int32(auraData.SpellID);
+    data << int32(auraData.SpellXSpellVisualID);
+    data << uint8(auraData.Flags);
+    data << uint32(auraData.ActiveFlags);
+    data << uint16(auraData.CastLevel);
+    data << uint8(auraData.Applications);
+    data.WriteBit(auraData.CastUnit.is_initialized());
+    data.WriteBit(auraData.Duration.is_initialized());
+    data.WriteBit(auraData.Remaining.is_initialized());
+    data.WriteBit(auraData.TimeMod.is_initialized());
+    data.WriteBits(auraData.Points.size(), 6);
+    data.WriteBits(auraData.EstimatedPoints.size(), 6);
+    data.WriteBit(auraData.SandboxScaling.is_initialized());
+
+    if (auraData.CastUnit)
+        data << *auraData.CastUnit;
+
+    if (auraData.Duration)
+        data << uint32(*auraData.Duration);
+
+    if (auraData.Remaining)
+        data << uint32(*auraData.Remaining);
+
+    if (auraData.TimeMod)
+        data << float(*auraData.TimeMod);
+
+    if (!auraData.Points.empty())
+        data.append(auraData.Points.data(), auraData.Points.size());
+
+    if (!auraData.EstimatedPoints.empty())
+        data.append(auraData.EstimatedPoints.data(), auraData.EstimatedPoints.size());
+
+    if (auraData.SandboxScaling)
+        data << *auraData.SandboxScaling;
+
+    return data;
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Spells::AuraInfo const& aura)
+{
+    data << aura.Slot;
+    data.WriteBit(aura.AuraData.is_initialized());
     data.FlushBits();
 
+    if (aura.AuraData)
+        data << *aura.AuraData;
+
     return data;
 }
 
 WorldPacket const* WorldPackets::Spells::AuraUpdate::Write()
 {
     _worldPacket.WriteBit(UpdateAll);
+    _worldPacket.WriteBits(Auras.size(), 9);
+    for (AuraInfo const& aura : Auras)
+        _worldPacket << aura;
+
     _worldPacket << UnitGUID;
-    _worldPacket << uint32(Auras.size());
-    for (auto& aura : Auras)
-    {
-        _worldPacket << aura.Slot;
-        if (_worldPacket.WriteBit(aura.AuraData.is_initialized()))
-        {
-            AuraDataInfo const& data = *aura.AuraData;
-            _worldPacket << uint32(data.SpellID);
-            _worldPacket << uint32(data.SpellXSpellVisualID);
-            _worldPacket << uint8(data.Flags);
-            _worldPacket << uint32(data.ActiveFlags);
-            _worldPacket << uint16(data.CastLevel);
-            _worldPacket << uint8(data.Applications);
-            _worldPacket << uint32(data.Points.size());
-            _worldPacket << uint32(data.EstimatedPoints.size());
-
-            if (!data.Points.empty())
-                _worldPacket.append(data.Points.data(), data.Points.size());
-
-            if (!data.EstimatedPoints.empty())
-                _worldPacket.append(data.EstimatedPoints.data(), data.EstimatedPoints.size());
-
-            _worldPacket.WriteBit(data.CastUnit.is_initialized());
-            _worldPacket.WriteBit(data.Duration.is_initialized());
-            _worldPacket.WriteBit(data.Remaining.is_initialized());
-
-            if (data.CastUnit)
-                _worldPacket << *data.CastUnit;
-
-            if (data.Duration)
-                _worldPacket << uint32(*data.Duration);
-
-            if (data.Remaining)
-                _worldPacket << uint32(*data.Remaining);
-        }
-
-        _worldPacket.FlushBits();
-    }
 
     return &_worldPacket;
 }
@@ -178,10 +209,11 @@ ByteBuffer& operator>>(ByteBuffer& buffer, WorldPackets::Spells::SpellTargetData
 {
     buffer.ResetBitPos();
 
-    targetData.Flags = buffer.ReadBits(23);
-    bool const hasSrcLocation = buffer.ReadBit();
-    bool const hasDstLocation = buffer.ReadBit();
-    bool const hasOrientation = buffer.ReadBit();
+    targetData.Flags = buffer.ReadBits(25);
+    bool hasSrcLocation = buffer.ReadBit();
+    bool hasDstLocation = buffer.ReadBit();
+    bool hasOrientation = buffer.ReadBit();
+    bool hasMapID = buffer.ReadBit();
     uint32 nameLength = buffer.ReadBits(7);
 
     buffer >> targetData.Unit;
@@ -196,6 +228,9 @@ ByteBuffer& operator>>(ByteBuffer& buffer, WorldPackets::Spells::SpellTargetData
     if (hasOrientation)
         targetData.Orientation = buffer.read<float>();
 
+    if (hasMapID)
+        targetData.MapID = buffer.read<int32>();
+
     targetData.Name = buffer.ReadString(nameLength);
 
     return buffer;
@@ -215,20 +250,17 @@ ByteBuffer& operator>>(ByteBuffer& buffer, WorldPackets::Spells::SpellCastReques
     buffer >> request.Misc[1];
     buffer >> request.SpellID;
     buffer >> request.SpellXSpellVisualID;
-    buffer >> request.Target;
     buffer >> request.MissileTrajectory;
     buffer >> request.Charmer;
-
-    buffer.ResetBitPos();
     request.SendCastFlags = buffer.ReadBits(5);
-    bool const hasMoveUpdate = buffer.ReadBit();
+    bool hasMoveUpdate = buffer.ReadBit();
     request.Weight.resize(buffer.ReadBits(2));
+    buffer >> request.Target;
 
     if (hasMoveUpdate)
     {
-        MovementInfo movementInfo;
-        buffer >> movementInfo;
-        request.MoveUpdate = movementInfo;
+        request.MoveUpdate = boost::in_place();
+        buffer >> *request.MoveUpdate;
     }
 
     for (WorldPackets::Spells::SpellWeight& weight : request.Weight)
@@ -261,6 +293,14 @@ void WorldPackets::Spells::UseItem::Read()
     _worldPacket >> Cast;
 }
 
+WorldPacket const* WorldPackets::Spells::SpellPrepare::Write()
+{
+    _worldPacket << ClientCastID;
+    _worldPacket << ServerCastID;
+
+    return &_worldPacket;
+}
+
 ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Spells::TargetLocation const& targetLocation)
 {
     data << targetLocation.Transport;
@@ -272,10 +312,11 @@ ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Spells::TargetLocation co
 
 ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Spells::SpellTargetData const& spellTargetData)
 {
-    data.WriteBits(spellTargetData.Flags, 23);
+    data.WriteBits(spellTargetData.Flags, 25);
     data.WriteBit(spellTargetData.SrcLocation.is_initialized());
     data.WriteBit(spellTargetData.DstLocation.is_initialized());
     data.WriteBit(spellTargetData.Orientation.is_initialized());
+    data.WriteBit(spellTargetData.MapID.is_initialized());
     data.WriteBits(spellTargetData.Name.size(), 7);
     data.FlushBits();
 
@@ -291,6 +332,9 @@ ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Spells::SpellTargetData c
     if (spellTargetData.Orientation)
         data << *spellTargetData.Orientation;
 
+    if (spellTargetData.MapID)
+        data << *spellTargetData.MapID;
+
     data.WriteString(spellTargetData.Name);
 
     return data;
@@ -299,8 +343,10 @@ ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Spells::SpellTargetData c
 ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Spells::SpellMissStatus const& spellMissStatus)
 {
     data.WriteBits(spellMissStatus.Reason, 4);
-    data.WriteBits(spellMissStatus.ReflectStatus, 4);
-    // No need to flush bits as we written exactly 8 bits (1 byte)
+    if (spellMissStatus.Reason == SPELL_MISS_REFLECT)
+        data.WriteBits(spellMissStatus.ReflectStatus, 4);
+
+    data.FlushBits();
     return data;
 }
 
@@ -315,12 +361,9 @@ ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Spells::RuneData const& r
 {
     data << uint8(runeData.Start);
     data << uint8(runeData.Count);
-
-    data.WriteBits(runeData.Cooldowns.size(), 3);
-    data.FlushBits();
-
-    for (uint8 cd : runeData.Cooldowns)
-        data << cd;
+    data << uint32(runeData.Cooldowns.size());
+    if (!runeData.Cooldowns.empty())
+        data.append(runeData.Cooldowns.data(), runeData.Cooldowns.size());
 
     return data;
 }
@@ -359,21 +402,29 @@ ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Spells::SpellCastData con
     data << spellCastData.CasterGUID;
     data << spellCastData.CasterUnit;
     data << spellCastData.CastID;
+    data << spellCastData.OriginalCastID;
     data << int32(spellCastData.SpellID);
     data << uint32(spellCastData.SpellXSpellVisualID);
     data << uint32(spellCastData.CastFlags);
     data << uint32(spellCastData.CastTime);
-    data << uint32(spellCastData.HitTargets.size());
-    data << uint32(spellCastData.MissTargets.size());
-    data << uint32(spellCastData.MissStatus.size());
-    data << spellCastData.Target;
-    data << uint32(spellCastData.RemainingPower.size());
     data << spellCastData.MissileTrajectory;
-    data << spellCastData.Ammo;
+    data << int32(spellCastData.Ammo.DisplayID);
     data << uint8(spellCastData.DestLocSpellCastIndex);
-    data << uint32(spellCastData.TargetPoints.size());
     data << spellCastData.Immunities;
     data << spellCastData.Predict;
+    data.WriteBits(spellCastData.CastFlagsEx, 22);
+    data.WriteBits(spellCastData.HitTargets.size(), 16);
+    data.WriteBits(spellCastData.MissTargets.size(), 16);
+    data.WriteBits(spellCastData.MissStatus.size(), 16);
+    data.WriteBits(spellCastData.RemainingPower.size(), 9);
+    data.WriteBit(spellCastData.RemainingRunes.is_initialized());
+    data.WriteBits(spellCastData.TargetPoints.size(), 16);
+    data.FlushBits();
+
+    for (WorldPackets::Spells::SpellMissStatus const& status : spellCastData.MissStatus)
+        data << status;
+
+    data << spellCastData.Target;
 
     for (ObjectGuid const& target : spellCastData.HitTargets)
         data << target;
@@ -381,22 +432,15 @@ ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Spells::SpellCastData con
     for (ObjectGuid const& target : spellCastData.MissTargets)
         data << target;
 
-    for (WorldPackets::Spells::SpellMissStatus const& status : spellCastData.MissStatus)
-        data << status;
-
     for (WorldPackets::Spells::SpellPowerData const& power : spellCastData.RemainingPower)
         data << power;
 
-    for (WorldPackets::Spells::TargetLocation const& targetLoc : spellCastData.TargetPoints)
-        data << targetLoc;
-
-    data.WriteBits(spellCastData.CastFlagsEx, 20);
-    data.WriteBit(spellCastData.RemainingRunes.is_initialized());
-    data.FlushBits();
-
     if (spellCastData.RemainingRunes)
         data << *spellCastData.RemainingRunes;
 
+    for (WorldPackets::Spells::TargetLocation const& targetLoc : spellCastData.TargetPoints)
+        data << targetLoc;
+
     return data;
 }
 
@@ -423,9 +467,13 @@ WorldPacket const* WorldPackets::Spells::SpellGo::Write()
 WorldPacket const* WorldPackets::Spells::LearnedSpells::Write()
 {
     _worldPacket << uint32(SpellID.size());
+    _worldPacket << uint32(FavoriteSpellID.size());
     for (int32 spell : SpellID)
         _worldPacket << spell;
 
+    for (int32 spell : FavoriteSpellID)
+        _worldPacket << spell;
+
     _worldPacket.WriteBit(SuppressMessaging);
     _worldPacket.FlushBits();
 
@@ -448,6 +496,7 @@ WorldPacket const* WorldPackets::Spells::SpellFailedOther::Write()
     _worldPacket << CasterUnit;
     _worldPacket << CastID;
     _worldPacket << uint32(SpellID);
+    _worldPacket << uint32(SpelXSpellVisualID);
     _worldPacket << uint8(Reason);
 
     return &_worldPacket;
@@ -465,6 +514,17 @@ WorldPacket const* WorldPackets::Spells::CastFailed::Write()
     return &_worldPacket;
 }
 
+WorldPacket const* WorldPackets::Spells::PetCastFailed::Write()
+{
+    _worldPacket << CastID;
+    _worldPacket << int32(SpellID);
+    _worldPacket << int32(Reason);
+    _worldPacket << int32(FailedArg1);
+    _worldPacket << int32(FailedArg2);
+
+    return &_worldPacket;
+}
+
 ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Spells::SpellModifierData const& spellModifierData)
 {
     data << float(spellModifierData.ModifierValue);
@@ -670,8 +730,8 @@ WorldPacket const* WorldPackets::Spells::PlaySpellVisualKit::Write()
 
 void WorldPackets::Spells::CancelCast::Read()
 {
-    _worldPacket >> SpellID;
     _worldPacket >> CastID;
+    _worldPacket >> SpellID;
 }
 
 void WorldPackets::Spells::OpenItem::Read()
@@ -722,15 +782,12 @@ WorldPacket const* WorldPackets::Spells::SpellChannelUpdate::Write()
 WorldPacket const* WorldPackets::Spells::ResurrectRequest::Write()
 {
     _worldPacket << ResurrectOffererGUID;
-    _worldPacket << ResurrectOffererVirtualRealmAddress;
-
-    _worldPacket << PetNumber;
-    _worldPacket << SpellID;
-
+    _worldPacket << uint32(ResurrectOffererVirtualRealmAddress);
+    _worldPacket << uint32(PetNumber);
+    _worldPacket << int32(SpellID);
     _worldPacket.WriteBits(Name.length(), 6);
     _worldPacket.WriteBit(UseTimer);
     _worldPacket.WriteBit(Sickness);
-
     _worldPacket.FlushBits();
 
     _worldPacket.WriteString(Name);
@@ -752,21 +809,21 @@ void WorldPackets::Spells::GetMirrorImageData::Read()
 WorldPacket const* WorldPackets::Spells::MirrorImageComponentedData::Write()
 {
     _worldPacket << UnitGUID;
-    _worldPacket << DisplayID;
-    _worldPacket << RaceID;
-    _worldPacket << Gender;
-    _worldPacket << ClassID;
-    _worldPacket << SkinColor;
-    _worldPacket << FaceVariation;
-    _worldPacket << HairVariation;
-    _worldPacket << HairColor;
-    _worldPacket << BeardVariation;
+    _worldPacket << int32(DisplayID);
+    _worldPacket << uint8(RaceID);
+    _worldPacket << uint8(Gender);
+    _worldPacket << uint8(ClassID);
+    _worldPacket << uint8(SkinColor);
+    _worldPacket << uint8(FaceVariation);
+    _worldPacket << uint8(HairVariation);
+    _worldPacket << uint8(HairColor);
+    _worldPacket << uint8(BeardVariation);
+    _worldPacket.append(CustomDisplay.data(), CustomDisplay.size());
     _worldPacket << GuildGUID;
-
     _worldPacket << uint32(ItemDisplayID.size());
 
-    for (auto const& itemDisplayId : ItemDisplayID)
-        _worldPacket << itemDisplayId;
+    for (int32 itemDisplayId : ItemDisplayID)
+        _worldPacket << int32(itemDisplayId);
 
     return &_worldPacket;
 }
@@ -774,7 +831,7 @@ WorldPacket const* WorldPackets::Spells::MirrorImageComponentedData::Write()
 WorldPacket const* WorldPackets::Spells::MirrorImageCreatureData::Write()
 {
     _worldPacket << UnitGUID;
-    _worldPacket << DisplayID;
+    _worldPacket << int32(DisplayID);
 
     return &_worldPacket;
 }
@@ -787,9 +844,7 @@ void WorldPackets::Spells::SpellClick::Read()
 
 WorldPacket const* WorldPackets::Spells::ResyncRunes::Write()
 {
-    _worldPacket << uint32(Runes.size());
-    if (!Runes.empty())
-        _worldPacket.append(Runes.data(), Runes.size());
+    _worldPacket << Runes;
 
     return &_worldPacket;
 }
@@ -825,9 +880,8 @@ void WorldPackets::Spells::UpdateMissileTrajectory::Read()
     _worldPacket.ResetBitPos();
     if (hasStatus)
     {
-        MovementInfo info;
-        _worldPacket >> info;
-        Status = info;
+        Status = boost::in_place();
+        _worldPacket >> *Status;
     }
 }
 
diff --git a/src/server/game/Server/Packets/SpellPackets.h b/src/server/game/Server/Packets/SpellPackets.h
index 8e9835f4009..901ebdd6b87 100644
--- a/src/server/game/Server/Packets/SpellPackets.h
+++ b/src/server/game/Server/Packets/SpellPackets.h
@@ -174,7 +174,7 @@ namespace WorldPackets
 
         struct SpellCastLogData
         {
-            int32 Health        = 0;
+            int64 Health        = 0;
             int32 AttackPower   = 0;
             int32 SpellPower    = 0;
             std::vector<SpellLogPowerData> PowerData;
@@ -182,10 +182,23 @@ namespace WorldPackets
             void Initialize(Unit const* unit);
         };
 
+        struct SandboxScalingData
+        {
+            uint32 Type = 0;
+            int16 PlayerLevelDelta = 0;
+            uint8 TargetLevel = 0;
+            uint8 Expansion = 0;
+            uint8 Class = 1;
+            uint8 TargetMinScalingLevel = 1;
+            uint8 TargetMaxScalingLevel = 1;
+            int8 TargetScalingLevelDelta = 1;
+        };
+
         struct AuraDataInfo
         {
+            ObjectGuid CastID;
             int32 SpellID = 0;
-            uint32 SpellXSpellVisualID = 0;
+            int32 SpellXSpellVisualID = 0;
             uint8 Flags = 0;
             uint32 ActiveFlags = 0;
             uint16 CastLevel = 1;
@@ -193,8 +206,10 @@ namespace WorldPackets
             Optional<ObjectGuid> CastUnit;
             Optional<int32> Duration;
             Optional<int32> Remaining;
+            Optional<float> TimeMod;
             std::vector<float> Points;
             std::vector<float> EstimatedPoints;
+            Optional<SandboxScalingData> SandboxScaling;
         };
 
         struct AuraInfo
@@ -229,6 +244,7 @@ namespace WorldPackets
             Optional<TargetLocation> SrcLocation;
             Optional<TargetLocation> DstLocation;
             Optional<float> Orientation;
+            Optional<int32> MapID;
             std::string Name;
         };
 
@@ -293,6 +309,17 @@ namespace WorldPackets
             SpellCastRequest Cast;
         };
 
+        class SpellPrepare final : public ServerPacket
+        {
+        public:
+            SpellPrepare() : ServerPacket(SMSG_SPELL_PREPARE, 16 + 16) { }
+
+            WorldPacket const* Write() override;
+
+            ObjectGuid ClientCastID;
+            ObjectGuid ServerCastID;
+        };
+
         struct SpellMissStatus
         {
             uint8 Reason = 0;
@@ -342,6 +369,7 @@ namespace WorldPackets
             ObjectGuid CasterGUID;
             ObjectGuid CasterUnit;
             ObjectGuid CastID;
+            ObjectGuid OriginalCastID;
             int32 SpellID       = 0;
             uint32 SpellXSpellVisualID = 0;
             uint32 CastFlags    = 0;
@@ -390,6 +418,7 @@ namespace WorldPackets
             WorldPacket const* Write() override;
 
             std::vector<int32> SpellID;
+            std::vector<int32> FavoriteSpellID;
             bool SuppressMessaging = false;
         };
 
@@ -416,6 +445,7 @@ namespace WorldPackets
 
             ObjectGuid CasterUnit;
             uint32 SpellID  = 0;
+            uint32 SpelXSpellVisualID = 0;
             uint8 Reason    = 0;
             ObjectGuid CastID;
         };
@@ -423,16 +453,30 @@ namespace WorldPackets
         class TC_GAME_API CastFailed final : public ServerPacket
         {
         public:
-            CastFailed(OpcodeServer opcode) : ServerPacket(opcode, 4+4+4+4+1) { }
+            CastFailed() : ServerPacket(SMSG_CAST_FAILED, 4 + 4 + 4 + 4 + 1) { }
 
             WorldPacket const* Write() override;
 
             ObjectGuid CastID;
-            int32 Reason              = 0;
+            int32 SpellID             = 0;
             int32 SpellXSpellVisualID = 0;
+            int32 Reason              = 0;
             int32 FailedArg1          = -1;
             int32 FailedArg2          = -1;
-            int32 SpellID             = 0;
+        };
+
+        class TC_GAME_API PetCastFailed final : public ServerPacket
+        {
+        public:
+            PetCastFailed() : ServerPacket(SMSG_PET_CAST_FAILED, 4 + 4 + 4 + 1) { }
+
+            WorldPacket const* Write() override;
+
+            ObjectGuid CastID;
+            int32 SpellID = 0;
+            int32 Reason = 0;
+            int32 FailedArg1 = -1;
+            int32 FailedArg2 = -1;
         };
 
         struct SpellModifierData
@@ -765,7 +809,7 @@ namespace WorldPackets
             WorldPacket const* Write() override;
 
             ObjectGuid UnitGUID;
-            uint32 DisplayID = 0;
+            int32 DisplayID = 0;
             uint8 RaceID = 0;
             uint8 Gender = 0;
             uint8 ClassID = 0;
@@ -774,9 +818,10 @@ namespace WorldPackets
             uint8 HairVariation = 0;
             uint8 HairColor = 0;
             uint8 BeardVariation = 0;
+            std::array<uint8, PLAYER_CUSTOM_DISPLAY_SIZE> CustomDisplay;
             ObjectGuid GuildGUID;
 
-            std::vector<uint32> ItemDisplayID;
+            std::vector<int32> ItemDisplayID;
         };
 
         class MirrorImageCreatureData final : public ServerPacket
@@ -787,7 +832,7 @@ namespace WorldPackets
             WorldPacket const* Write() override;
 
             ObjectGuid UnitGUID;
-            uint32 DisplayID = 0;
+            int32 DisplayID = 0;
         };
 
         class SpellClick final : public ClientPacket
@@ -804,11 +849,11 @@ namespace WorldPackets
         class ResyncRunes final : public ServerPacket
         {
         public:
-            ResyncRunes(size_t size) : ServerPacket(SMSG_RESYNC_RUNES, 4 + 2 * size) { }
+            ResyncRunes(size_t size) : ServerPacket(SMSG_RESYNC_RUNES, 1 + 1 + 4 + size) { }
 
             WorldPacket const* Write() override;
 
-            std::vector<uint8> Runes;
+            RuneData Runes;
         };
 
         class MissileTrajectoryCollision final : public ClientPacket
diff --git a/src/server/game/Server/Protocol/Opcodes.cpp b/src/server/game/Server/Protocol/Opcodes.cpp
index 0cf2a510660..d04bda1a0d9 100644
--- a/src/server/game/Server/Protocol/Opcodes.cpp
+++ b/src/server/game/Server/Protocol/Opcodes.cpp
@@ -211,7 +211,7 @@ void OpcodeTable::Initialize()
     DEFINE_HANDLER(CMSG_CALENDAR_UPDATE_EVENT,                              STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Calendar::CalendarUpdateEvent, &WorldSession::HandleCalendarUpdateEvent);
     DEFINE_HANDLER(CMSG_CANCEL_AURA,                                        STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Spells::CancelAura, &WorldSession::HandleCancelAuraOpcode);
     DEFINE_HANDLER(CMSG_CANCEL_AUTO_REPEAT_SPELL,                           STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Spells::CancelAutoRepeatSpell, &WorldSession::HandleCancelAutoRepeatSpellOpcode);
-    DEFINE_HANDLER(CMSG_CANCEL_CAST,                                        STATUS_UNHANDLED, PROCESS_THREADSAFE,   WorldPackets::Spells::CancelCast, &WorldSession::HandleCancelCastOpcode);
+    DEFINE_HANDLER(CMSG_CANCEL_CAST,                                        STATUS_LOGGEDIN,  PROCESS_THREADSAFE,   WorldPackets::Spells::CancelCast, &WorldSession::HandleCancelCastOpcode);
     DEFINE_HANDLER(CMSG_CANCEL_CHANNELLING,                                 STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Spells::CancelChannelling, &WorldSession::HandleCancelChanneling);
     DEFINE_HANDLER(CMSG_CANCEL_GROWTH_AURA,                                 STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Spells::CancelGrowthAura, &WorldSession::HandleCancelGrowthAuraOpcode);
     DEFINE_HANDLER(CMSG_CANCEL_MASTER_LOOT_ROLL,                            STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
@@ -221,7 +221,7 @@ void OpcodeTable::Initialize()
     DEFINE_HANDLER(CMSG_CANCEL_TEMP_ENCHANTMENT,                            STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Item::CancelTempEnchantment, &WorldSession::HandleCancelTempEnchantmentOpcode);
     DEFINE_HANDLER(CMSG_CANCEL_TRADE,                                       STATUS_LOGGEDIN_OR_RECENTLY_LOGGOUT, PROCESS_THREADUNSAFE, WorldPackets::Trade::CancelTrade, &WorldSession::HandleCancelTradeOpcode);
     DEFINE_HANDLER(CMSG_CAN_DUEL,                                           STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Duel::CanDuel, &WorldSession::HandleCanDuel);
-    DEFINE_HANDLER(CMSG_CAST_SPELL,                                         STATUS_UNHANDLED, PROCESS_THREADSAFE,   WorldPackets::Spells::CastSpell, &WorldSession::HandleCastSpellOpcode);
+    DEFINE_HANDLER(CMSG_CAST_SPELL,                                         STATUS_LOGGEDIN,  PROCESS_THREADSAFE,   WorldPackets::Spells::CastSpell, &WorldSession::HandleCastSpellOpcode);
     DEFINE_HANDLER(CMSG_CHALLENGE_MODE_REQUEST_LEADERS,                     STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_CHALLENGE_MODE_REQUEST_MAP_STATS,                   STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_CHANGE_BAG_SLOT_FLAG,                               STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
@@ -473,7 +473,7 @@ void OpcodeTable::Initialize()
     DEFINE_HANDLER(CMSG_MAIL_TAKE_MONEY,                                    STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Mail::MailTakeMoney, &WorldSession::HandleMailTakeMoney);
     DEFINE_OPCODE_HANDLER_OLD(CMSG_MASTER_LOOT_ITEM,                        STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleLootMasterGiveOpcode      );
     DEFINE_HANDLER(CMSG_MINIMAP_PING,                                       STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Party::MinimapPingClient, &WorldSession::HandleMinimapPingOpcode);
-    DEFINE_HANDLER(CMSG_MISSILE_TRAJECTORY_COLLISION,                       STATUS_UNHANDLED, PROCESS_THREADUNSAFE, WorldPackets::Spells::MissileTrajectoryCollision, &WorldSession::HandleMissileTrajectoryCollision);
+    DEFINE_HANDLER(CMSG_MISSILE_TRAJECTORY_COLLISION,                       STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Spells::MissileTrajectoryCollision, &WorldSession::HandleMissileTrajectoryCollision);
     DEFINE_HANDLER(CMSG_MOUNT_SET_FAVORITE,                                 STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_MOUNT_SPECIAL_ANIM,                                 STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Misc::MountSpecial, &WorldSession::HandleMountSpecialAnimOpcode);
     DEFINE_HANDLER(CMSG_MOVE_APPLY_MOVEMENT_FORCE_ACK,                      STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
@@ -568,7 +568,7 @@ void OpcodeTable::Initialize()
     DEFINE_HANDLER(CMSG_PET_BATTLE_REQUEST_WILD,                            STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_PET_BATTLE_SCRIPT_ERROR_NOTIFY,                     STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_PET_CANCEL_AURA,                                    STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Spells::PetCancelAura, &WorldSession::HandlePetCancelAuraOpcode);
-    DEFINE_HANDLER(CMSG_PET_CAST_SPELL,                                     STATUS_UNHANDLED, PROCESS_THREADUNSAFE, WorldPackets::Spells::PetCastSpell, &WorldSession::HandlePetCastSpellOpcode);
+    DEFINE_HANDLER(CMSG_PET_CAST_SPELL,                                     STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Spells::PetCastSpell, &WorldSession::HandlePetCastSpellOpcode);
     DEFINE_HANDLER(CMSG_PET_RENAME,                                         STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Pet::PetRename, &WorldSession::HandlePetRename);
     DEFINE_HANDLER(CMSG_PET_SET_ACTION,                                     STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Pet::PetSetAction, &WorldSession::HandlePetSetAction              );
     DEFINE_HANDLER(CMSG_PET_SPELL_AUTOCAST,                                 STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Pet::PetSpellAutocast, &WorldSession::HandlePetSpellAutocastOpcode);
@@ -763,7 +763,7 @@ void OpcodeTable::Initialize()
     DEFINE_HANDLER(CMSG_UNLOCK_VOID_STORAGE,                                STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::VoidStorage::UnlockVoidStorage, &WorldSession::HandleVoidStorageUnlock);
     DEFINE_HANDLER(CMSG_UPDATE_ACCOUNT_DATA,                                STATUS_AUTHED,    PROCESS_THREADUNSAFE, WorldPackets::ClientConfig::UserClientUpdateAccountData, &WorldSession::HandleUpdateAccountData);
     DEFINE_HANDLER(CMSG_UPDATE_CLIENT_SETTINGS,                             STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
-    DEFINE_HANDLER(CMSG_UPDATE_MISSILE_TRAJECTORY,                          STATUS_UNHANDLED, PROCESS_THREADUNSAFE, WorldPackets::Spells::UpdateMissileTrajectory, &WorldSession::HandleUpdateMissileTrajectory);
+    DEFINE_HANDLER(CMSG_UPDATE_MISSILE_TRAJECTORY,                          STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Spells::UpdateMissileTrajectory, &WorldSession::HandleUpdateMissileTrajectory);
     DEFINE_HANDLER(CMSG_UPDATE_RAID_TARGET,                                 STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Party::UpdateRaidTarget, &WorldSession::HandleUpdateRaidTargetOpcode);
     DEFINE_HANDLER(CMSG_UPDATE_VAS_PURCHASE_STATES,                         STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_UPDATE_WOW_TOKEN_AUCTIONABLE_LIST,                  STATUS_UNHANDLED, PROCESS_THREADUNSAFE, WorldPackets::Token::UpdateListedAuctionableTokens, &WorldSession::HandleUpdateListedAuctionableTokens);
@@ -773,8 +773,8 @@ void OpcodeTable::Initialize()
     DEFINE_HANDLER(CMSG_USED_FOLLOW,                                        STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_USE_CRITTER_ITEM,                                   STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Item::UseCritterItem, &WorldSession::HandleUseCritterItem);
     DEFINE_HANDLER(CMSG_USE_EQUIPMENT_SET,                                  STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::EquipmentSet::UseEquipmentSet, &WorldSession::HandleUseEquipmentSet);
-    DEFINE_HANDLER(CMSG_USE_ITEM,                                           STATUS_UNHANDLED, PROCESS_THREADUNSAFE, WorldPackets::Spells::UseItem, &WorldSession::HandleUseItemOpcode);
-    DEFINE_HANDLER(CMSG_USE_TOY,                                            STATUS_UNHANDLED, PROCESS_THREADUNSAFE, WorldPackets::Toy::UseToy, &WorldSession::HandleUseToy);
+    DEFINE_HANDLER(CMSG_USE_ITEM,                                           STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Spells::UseItem, &WorldSession::HandleUseItemOpcode);
+    DEFINE_HANDLER(CMSG_USE_TOY,                                            STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Toy::UseToy, &WorldSession::HandleUseToy);
     DEFINE_HANDLER(CMSG_VIOLENCE_LEVEL,                                     STATUS_AUTHED,    PROCESS_INPLACE,      WorldPackets::Misc::ViolenceLevel, &WorldSession::HandleViolenceLevel);
     DEFINE_HANDLER(CMSG_VOICE_ADD_IGNORE,                                   STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_VOICE_DEL_IGNORE,                                   STATUS_UNHANDLED, PROCESS_INPLACE,      WorldPackets::Null, &WorldSession::Handle_NULL);
@@ -844,7 +844,7 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_AUCTION_REPLICATE_RESPONSE,              STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_AUCTION_WON_NOTIFICATION,                STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_AURA_POINTS_DEPLETED,                    STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_AURA_UPDATE,                             STATUS_UNHANDLED,    CONNECTION_TYPE_INSTANCE);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_AURA_UPDATE,                             STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_AUTH_CHALLENGE,                          STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_AUTH_RESPONSE,                           STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_AVAILABLE_VOICE_CHANNEL,                 STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
@@ -941,12 +941,12 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_CAMERA_SHAKE,                            STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_CANCEL_AUTO_REPEAT,                      STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_CANCEL_COMBAT,                           STATUS_NEVER,        CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_CANCEL_ORPHAN_SPELL_VISUAL,              STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_CANCEL_ORPHAN_SPELL_VISUAL,              STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_CANCEL_SCENE,                            STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_CANCEL_SPELL_VISUAL,                     STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_CANCEL_SPELL_VISUAL,                     STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_CANCEL_SPELL_VISUAL_KIT,                 STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_CAN_DUEL_RESULT,                         STATUS_NEVER,        CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_CAST_FAILED,                             STATUS_UNHANDLED,    CONNECTION_TYPE_INSTANCE);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_CAST_FAILED,                             STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_CATEGORY_COOLDOWN,                       STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_CHALLEGE_MODE_REWARDS,                   STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_CHALLENGE_MODE_ALL_MAP_STATS,            STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
@@ -1233,7 +1233,7 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_ITEM_PUSH_RESULT,                        STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_ITEM_TIME_UPDATE,                        STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_KICK_REASON,                             STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_LEARNED_SPELLS,                          STATUS_UNHANDLED,    CONNECTION_TYPE_INSTANCE);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_LEARNED_SPELLS,                          STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_LEARN_PVP_TALENT_FAILED,                 STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_LEARN_TALENT_FAILED,                     STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_LEVEL_UPDATE,                            STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
@@ -1299,7 +1299,7 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_MASTER_LOOT_CANDIDATE_LIST,              STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_MESSAGE_BOX,                             STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_MINIMAP_PING,                            STATUS_NEVER,        CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_MIRROR_IMAGE_COMPONENTED_DATA,           STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_MIRROR_IMAGE_COMPONENTED_DATA,           STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_MIRROR_IMAGE_CREATURE_DATA,              STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_MISSILE_CANCEL,                          STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_MODIFY_COOLDOWN,                         STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
@@ -1390,7 +1390,7 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_NEW_TAXI_PATH,                           STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_NEW_WORLD,                               STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_NOTIFY_DEST_LOC_SPELL_CAST,              STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_NOTIFY_MISSILE_TRAJECTORY_COLLISION,     STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_NOTIFY_MISSILE_TRAJECTORY_COLLISION,     STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_NOTIFY_MONEY,                            STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_NOTIFY_RECEIVED_MAIL,                    STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_OFFER_PETITION_ERROR,                    STATUS_NEVER,        CONNECTION_TYPE_REALM);
@@ -1432,7 +1432,7 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_PET_BATTLE_REQUEST_FAILED,               STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_PET_BATTLE_ROUND_RESULT,                 STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_PET_BATTLE_SLOT_UPDATES,                 STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_PET_CAST_FAILED,                         STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_PET_CAST_FAILED,                         STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_PET_CLEAR_SPELLS,                        STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_PET_DISMISS_SOUND,                       STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_PET_GOD_MODE,                            STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
@@ -1548,7 +1548,7 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_RESUME_COMMS,                            STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_RESUME_TOKEN,                            STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_RESURRECT_REQUEST,                       STATUS_NEVER,        CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_RESYNC_RUNES,                            STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_RESYNC_RUNES,                            STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_ROLE_CHANGED_INFORM,                     STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_ROLE_CHOSEN,                             STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_ROLE_POLL_INFORM,                        STATUS_NEVER,        CONNECTION_TYPE_REALM);
@@ -1626,10 +1626,10 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPELL_DELAYED,                           STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPELL_DISPELL_LOG,                       STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPELL_ENERGIZE_LOG,                      STATUS_UNHANDLED,    CONNECTION_TYPE_INSTANCE);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPELL_EXECUTE_LOG,                       STATUS_UNHANDLED,    CONNECTION_TYPE_INSTANCE);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPELL_FAILED_OTHER,                      STATUS_UNHANDLED,    CONNECTION_TYPE_INSTANCE);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPELL_FAILURE,                           STATUS_UNHANDLED,    CONNECTION_TYPE_INSTANCE);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPELL_GO,                                STATUS_UNHANDLED,    CONNECTION_TYPE_INSTANCE);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPELL_EXECUTE_LOG,                       STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPELL_FAILED_OTHER,                      STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPELL_FAILURE,                           STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPELL_GO,                                STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPELL_HEAL_LOG,                          STATUS_UNHANDLED,    CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPELL_INSTAKILL_LOG,                     STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPELL_INTERRUPT_LOG,                     STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
@@ -1637,7 +1637,8 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPELL_NON_MELEE_DAMAGE_LOG,              STATUS_UNHANDLED,    CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPELL_OR_DAMAGE_IMMUNE,                  STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPELL_PERIODIC_AURA_LOG,                 STATUS_UNHANDLED,    CONNECTION_TYPE_INSTANCE);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPELL_START,                             STATUS_UNHANDLED,    CONNECTION_TYPE_INSTANCE);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPELL_PREPARE,                           STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPELL_START,                             STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPELL_UPDATE_CHAIN_TARGETS,              STATUS_UNHANDLED,    CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPIRIT_HEALER_CONFIRM,                   STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_STAND_STATE_UPDATE,                      STATUS_NEVER,        CONNECTION_TYPE_REALM);
diff --git a/src/server/game/Server/Protocol/Opcodes.h b/src/server/game/Server/Protocol/Opcodes.h
index 9a15ca951e2..571a1473aa1 100644
--- a/src/server/game/Server/Protocol/Opcodes.h
+++ b/src/server/game/Server/Protocol/Opcodes.h
@@ -1575,6 +1575,7 @@ enum OpcodeServer : uint32
     SMSG_SPELL_NON_MELEE_DAMAGE_LOG                   = 0x2C31,
     SMSG_SPELL_OR_DAMAGE_IMMUNE                       = 0x2C2E,
     SMSG_SPELL_PERIODIC_AURA_LOG                      = 0x2C1B,
+    SMSG_SPELL_PREPARE                                = 0x2C38,
     SMSG_SPELL_START                                  = 0x2C3A,
     SMSG_SPELL_UPDATE_CHAIN_TARGETS                   = 0x2C33,
     SMSG_SPIRIT_HEALER_CONFIRM                        = 0x2750,