Core/Packets: Added SMSG_SPELL_FAILURE, SMSG_SPELL_FAILED_OTHER, SMSG_SET_FLAT_SPELL_MODIFIER, SMSG_SET_PCT_SPELL_MODIFIER packets

5 files changed, 135 insertions, 32 deletions

diff --git a/src/server/game/Entities/Player/Player.cpp b/src/server/game/Entities/Player/Player.cpp
index c9a782cc78b..867c3b18133 100644
--- a/src/server/game/Entities/Player/Player.cpp
+++ b/src/server/game/Entities/Player/Player.cpp
@@ -20797,14 +20797,18 @@ void Player::AddSpellMod(SpellModifier* mod, bool apply)
     TC_LOG_DEBUG("spells", "Player::AddSpellMod %d", mod->spellId);
     OpcodeServer opcode = (mod->type == SPELLMOD_FLAT) ? SMSG_SET_FLAT_SPELL_MODIFIER : SMSG_SET_PCT_SPELL_MODIFIER;
 
+    WorldPackets::Spells::SetSpellModifier packet(opcode);
+
     int i = 0;
     flag96 _mask;
     uint32 modTypeCount = 0; // count of mods per one mod->op
-    WorldPacket data(opcode);
-    data << uint32(1);  // count of different mod->op's in packet
-    size_t writePos = data.wpos();
-    data << uint32(modTypeCount);
-    data << uint8(mod->op);
+
+    /// @todo Implement sending of bulk modifiers instead of single
+    packet.Modifiers.resize(1);
+    WorldPackets::Spells::SpellModifier& spellMod = packet.Modifiers[0];
+
+    spellMod.ModIndex = mod->op;
+
     for (int eff = 0; eff < 96; ++eff)
     {
         if (eff != 0 && (eff % 32) == 0)
@@ -20813,19 +20817,21 @@ void Player::AddSpellMod(SpellModifier* mod, bool apply)
         _mask[i] = uint32(1) << (eff - (32 * i));
         if (mod->mask & _mask)
         {
-            int32 val = 0;
+            WorldPackets::Spells::SpellModifierData modData;
+
             for (SpellModList::iterator itr = m_spellMods[mod->op].begin(); itr != m_spellMods[mod->op].end(); ++itr)
                 if ((*itr)->type == mod->type && (*itr)->mask & _mask)
-                    val += (*itr)->value;
-            val += apply ? mod->value : -(mod->value);
+                    modData.ModifierValue += (*itr)->value;
 
-            data << uint8(eff);
-            data << float(val);
-            ++modTypeCount;
+            modData.ModifierValue += apply ? mod->value : -(mod->value);
+            modData.ClassIndex = eff;
+
+            spellMod.ModifierData.push_back(modData);
         }
     }
-    data.put<uint32>(writePos, modTypeCount);
-    SendDirectMessage(&data);
+
+    SendDirectMessage(packet.Write());
+
     if (apply)
         m_spellMods[mod->op].push_back(mod);
     else
diff --git a/src/server/game/Server/Packets/SpellPackets.cpp b/src/server/game/Server/Packets/SpellPackets.cpp
index ee2e0e8dfdf..bdf7575d8f0 100644
--- a/src/server/game/Server/Packets/SpellPackets.cpp
+++ b/src/server/game/Server/Packets/SpellPackets.cpp
@@ -66,7 +66,7 @@ WorldPacket const* WorldPackets::Spells::SendUnlearnSpells::Write()
     return &_worldPacket;
 }
 
-ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Spells::SpellCastLogData& spellCastLogData)
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Spells::SpellCastLogData const& spellCastLogData)
 {
     data << spellCastLogData.Health;
     data << spellCastLogData.AttackPower;
@@ -416,3 +416,50 @@ WorldPacket const* WorldPackets::Spells::LearnedSpells::Write()
 
     return &_worldPacket;
 }
+
+WorldPacket const* WorldPackets::Spells::SpellFailure::Write()
+{
+    _worldPacket << CasterUnit;
+    _worldPacket << CastID;
+    _worldPacket << SpellID;
+    _worldPacket << Reason;
+
+    return &_worldPacket;
+}
+
+WorldPacket const* WorldPackets::Spells::SpellFailedOther::Write()
+{
+    _worldPacket << CasterUnit;
+    _worldPacket << CastID;
+    _worldPacket << SpellID;
+    _worldPacket << Reason;
+
+    return &_worldPacket;
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Spells::SpellModifierData const& spellModifierData)
+{
+    data << spellModifierData.ModifierValue;
+    data << spellModifierData.ClassIndex;
+
+    return data;
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Spells::SpellModifier const& spellModifier)
+{
+    data << spellModifier.ModIndex;
+    data << uint32(spellModifier.ModifierData.size());
+    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;
+}
diff --git a/src/server/game/Server/Packets/SpellPackets.h b/src/server/game/Server/Packets/SpellPackets.h
index 2c971107268..2d94e2c72a9 100644
--- a/src/server/game/Server/Packets/SpellPackets.h
+++ b/src/server/game/Server/Packets/SpellPackets.h
@@ -164,9 +164,59 @@ namespace WorldPackets
             std::vector<int32> SpellID;
             bool SuppressMessaging = false;
         };
+
+        class SpellFailure final : public ServerPacket
+        {
+        public:
+            SpellFailure() : ServerPacket(SMSG_SPELL_FAILURE, 16+4+1+1) { }
+
+            WorldPacket const* Write() override;
+
+            ObjectGuid CasterUnit;
+            uint32 SpellID  = 0;
+            uint8 Reason    = 0;
+            uint8 CastID    = 0;
+        };
+
+        class SpellFailedOther final : public ServerPacket
+        {
+        public:
+            SpellFailedOther() : ServerPacket(SMSG_SPELL_FAILED_OTHER, 16+4+1+1) { }
+
+            WorldPacket const* Write() override;
+
+            ObjectGuid CasterUnit;
+            uint32 SpellID  = 0;
+            uint8 Reason    = 0;
+            uint8 CastID    = 0;
+        };
+
+        struct SpellModifierData
+        {
+            float ModifierValue = 0.0f;
+            uint8 ClassIndex = 0;
+        };
+
+        struct SpellModifier
+        {
+            uint8 ModIndex = 0;
+            std::vector<SpellModifierData> ModifierData;
+        };
+
+        class SetSpellModifier final : public ServerPacket
+        {
+        public:
+            SetSpellModifier(OpcodeServer opcode) : ServerPacket(opcode, 20) { }
+
+            WorldPacket const* Write() override;
+
+            std::vector<SpellModifier> Modifiers;
+        };
     }
 }
 
-ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Spells::SpellCastLogData& spellCastLogData);
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Spells::SpellCastLogData const& spellCastLogData);
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Spells::SpellModifierData const& spellModifierData);
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Spells::SpellModifier const& spellModifier);
 
 #endif // SpellPackets_h__
diff --git a/src/server/game/Server/Protocol/Opcodes.cpp b/src/server/game/Server/Protocol/Opcodes.cpp
index 3b92433fb2d..29c816c2416 100644
--- a/src/server/game/Server/Protocol/Opcodes.cpp
+++ b/src/server/game/Server/Protocol/Opcodes.cpp
@@ -1282,12 +1282,12 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SET_FACTION_NOT_VISIBLE,                 STATUS_UNHANDLED);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SET_FACTION_STANDING,                    STATUS_UNHANDLED);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SET_FACTION_VISIBLE,                     STATUS_UNHANDLED);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_SET_FLAT_SPELL_MODIFIER,                 STATUS_UNHANDLED);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_SET_FLAT_SPELL_MODIFIER,                 STATUS_NEVER);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SET_FORCED_REACTIONS,                    STATUS_UNHANDLED);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SET_MAX_WEEKLY_QUANTITY,                 STATUS_UNHANDLED);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SET_MELEE_ANIM_KIT,                      STATUS_UNHANDLED);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SET_MOVEMENT_ANIM_KIT,                   STATUS_UNHANDLED);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_SET_PCT_SPELL_MODIFIER,                  STATUS_UNHANDLED);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_SET_PCT_SPELL_MODIFIER,                  STATUS_NEVER);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SET_PHASE_SHIFT,                         STATUS_UNHANDLED);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SET_PLAYER_DECLINED_NAMES_RESULT,        STATUS_UNHANDLED);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SET_PLAY_HOVER_ANIM,                     STATUS_UNHANDLED);
@@ -1315,8 +1315,8 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPELL_CATEGORY_COOLDOWN,                 STATUS_NEVER);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPELL_COOLDOWN,                          STATUS_UNHANDLED);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPELL_DELAYED,                           STATUS_UNHANDLED);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPELL_FAILED_OTHER,                      STATUS_UNHANDLED);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPELL_FAILURE,                           STATUS_UNHANDLED);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPELL_FAILED_OTHER,                      STATUS_NEVER);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPELL_FAILURE,                           STATUS_NEVER);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPELL_GO,                                STATUS_UNHANDLED);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPELL_START,                             STATUS_NEVER);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPELL_UPDATE_CHAIN_TARGETS,              STATUS_UNHANDLED);
diff --git a/src/server/game/Spells/Spell.cpp b/src/server/game/Spells/Spell.cpp
index 0a55735eae5..c6b92f66fb9 100644
--- a/src/server/game/Spells/Spell.cpp
+++ b/src/server/game/Spells/Spell.cpp
@@ -4248,19 +4248,19 @@ void Spell::ExecuteLogEffectResurrect(uint8 effIndex, Unit* target)
 
 void Spell::SendInterrupted(uint8 result)
 {
-    WorldPacket data(SMSG_SPELL_FAILURE, (8+4+1));
-    data << m_caster->GetPackGUID();
-    data << uint8(m_cast_count);
-    data << uint32(m_spellInfo->Id);
-    data << uint8(result);
-    m_caster->SendMessageToSet(&data, true);
-
-    data.Initialize(SMSG_SPELL_FAILED_OTHER, (8+4));
-    data << m_caster->GetPackGUID();
-    data << uint8(m_cast_count);
-    data << uint32(m_spellInfo->Id);
-    data << uint8(result);
-    m_caster->SendMessageToSet(&data, true);
+    WorldPackets::Spells::SpellFailure failurePacket;
+    failurePacket.CasterUnit = m_caster->GetGUID();
+    failurePacket.CastID = m_cast_count;
+    failurePacket.SpellID = m_spellInfo->Id;
+    failurePacket.Reason = result;
+    m_caster->SendMessageToSet(failurePacket.Write(), true);
+
+    WorldPackets::Spells::SpellFailedOther failedPacket;
+    failedPacket.CasterUnit = m_caster->GetGUID();
+    failedPacket.CastID = m_cast_count;
+    failedPacket.SpellID = m_spellInfo->Id;
+    failedPacket.Reason = result;
+    m_caster->SendMessageToSet(failedPacket.Write(), true);
 }
 
 void Spell::SendChannelUpdate(uint32 time)