Core/PacketIO: Updated and enabled a few combat log opcodes

* Fixed structure of SMSG_SPELL_NON_MELEE_DAMAGE_LOG

3 files changed, 167 insertions, 22 deletions

diff --git a/src/server/game/Server/Packets/CombatLogPackets.cpp b/src/server/game/Server/Packets/CombatLogPackets.cpp
index 295f27375da..baf1576f852 100644
--- a/src/server/game/Server/Packets/CombatLogPackets.cpp
+++ b/src/server/game/Server/Packets/CombatLogPackets.cpp
@@ -22,16 +22,16 @@ WorldPacket const* WorldPackets::CombatLog::SpellNonMeleeDamageLog::Write()
 {
     _worldPacket << Me;
     _worldPacket << CasterGUID;
-    _worldPacket << SpellID;
-    _worldPacket << Damage;
-    _worldPacket << Overkill;
-    _worldPacket << SchoolMask;
-    _worldPacket << ShieldBlock;
-    _worldPacket << Resisted;
-    _worldPacket << Absorbed;
+    _worldPacket << int32(SpellID);
+    _worldPacket << int32(Damage);
+    _worldPacket << int32(Overkill);
+    _worldPacket << uint8(SchoolMask);
+    _worldPacket << int32(ShieldBlock);
+    _worldPacket << int32(Resisted);
+    _worldPacket << int32(Absorbed);
 
     _worldPacket.WriteBit(Periodic);
-    _worldPacket.WriteBits(Flags, 9);
+    _worldPacket.WriteBits(Flags, 8);
     _worldPacket.WriteBit(false); // Debug info
     _worldPacket.WriteBit(LogData.is_initialized());
     _worldPacket.FlushBits();
@@ -220,3 +220,77 @@ WorldPacket const* WorldPackets::CombatLog::SpellInstakillLog::Write()
 
     return &_worldPacket;
 }
+
+ByteBuffer& operator<<(ByteBuffer& buffer, WorldPackets::CombatLog::SpellLogMissDebug const& missDebug)
+{
+    buffer << float(missDebug.HitRoll);
+    buffer << float(missDebug.HitRollNeeded);
+    return buffer;
+}
+
+ByteBuffer& operator<<(ByteBuffer& buffer, WorldPackets::CombatLog::SpellLogMissEntry const& missEntry)
+{
+    buffer << missEntry.Victim;
+    buffer << uint8(missEntry.MissReason);
+    if (buffer.WriteBit(missEntry.Debug.is_initialized()))
+        buffer << *missEntry.Debug;
+
+    buffer.FlushBits();
+    return buffer;
+}
+
+WorldPacket const* WorldPackets::CombatLog::SpellMissLog::Write()
+{
+    _worldPacket << int32(SpellID);
+    _worldPacket << Caster;
+    _worldPacket << uint32(Entries.size());
+    for (SpellLogMissEntry const& missEntry : Entries)
+        _worldPacket << missEntry;
+
+    return &_worldPacket;
+}
+
+WorldPacket const* WorldPackets::CombatLog::ProcResist::Write()
+{
+    _worldPacket << Caster;
+    _worldPacket << Target;
+    _worldPacket << int32(SpellID);
+    _worldPacket.WriteBit(Rolled.is_initialized());
+    _worldPacket.WriteBit(Needed.is_initialized());
+    _worldPacket.FlushBits();
+
+    if (Rolled)
+        _worldPacket << *Rolled;
+
+    if (Needed)
+        _worldPacket << *Needed;
+
+    return &_worldPacket;
+}
+
+WorldPacket const* WorldPackets::CombatLog::SpellOrDamageImmune::Write()
+{
+    _worldPacket << CasterGUID;
+    _worldPacket << VictimGUID;
+    _worldPacket << uint32(SpellID);
+    _worldPacket.WriteBit(IsPeriodic);
+    _worldPacket.FlushBits();
+
+    return &_worldPacket;
+}
+
+WorldPacket const* WorldPackets::CombatLog::SpellDamageShield::Write()
+{
+    _worldPacket << Attacker;
+    _worldPacket << Defender;
+    _worldPacket << int32(SpellID);
+    _worldPacket << int32(TotalDamage);
+    _worldPacket << int32(OverKill);
+    _worldPacket << int32(SchoolMask);
+    _worldPacket << int32(LogAbsorbed);
+    if (_worldPacket.WriteBit(LogData.is_initialized()))
+        _worldPacket << *LogData;
+
+    _worldPacket.FlushBits();
+    return &_worldPacket;
+}
diff --git a/src/server/game/Server/Packets/CombatLogPackets.h b/src/server/game/Server/Packets/CombatLogPackets.h
index 5566ea62180..a181ead6d6a 100644
--- a/src/server/game/Server/Packets/CombatLogPackets.h
+++ b/src/server/game/Server/Packets/CombatLogPackets.h
@@ -180,6 +180,77 @@ namespace WorldPackets
             ObjectGuid Caster;
             int32 SpellID = 0;
         };
+
+        struct SpellLogMissDebug
+        {
+            float HitRoll = 0.0f;
+            float HitRollNeeded = 0.0f;
+        };
+
+        struct SpellLogMissEntry
+        {
+            SpellLogMissEntry(ObjectGuid const& victim, uint8 missReason) : Victim(victim), MissReason(missReason) { }
+
+            ObjectGuid Victim;
+            uint8 MissReason = 0;
+            Optional<SpellLogMissDebug> Debug;
+        };
+
+        class SpellMissLog final : public ServerPacket
+        {
+        public:
+            SpellMissLog() : ServerPacket(SMSG_SPELL_MISS_LOG) { }
+
+            WorldPacket const* Write() override;
+
+            int32 SpellID = 0;
+            ObjectGuid Caster;
+            std::vector<SpellLogMissEntry> Entries;
+        };
+
+        class ProcResist final : public ServerPacket
+        {
+        public:
+            ProcResist() : ServerPacket(SMSG_PROC_RESIST, 16 + 4 + 4 + 4 + 16) { }
+
+            WorldPacket const* Write() override;
+
+            ObjectGuid Caster;
+            ObjectGuid Target;
+            int32 SpellID = 0;
+            Optional<float> Rolled;
+            Optional<float> Needed;
+        };
+
+        class SpellOrDamageImmune final : public ServerPacket
+        {
+        public:
+            SpellOrDamageImmune() : ServerPacket(SMSG_SPELL_OR_DAMAGE_IMMUNE, 16 + 1 + 4 + 16) { }
+
+            WorldPacket const* Write() override;
+
+            ObjectGuid CasterGUID;
+            ObjectGuid VictimGUID;
+            uint32 SpellID = 0;
+            bool IsPeriodic = false;
+        };
+
+        class SpellDamageShield final : public ServerPacket
+        {
+        public:
+            SpellDamageShield() : ServerPacket(SMSG_SPELL_DAMAGE_SHIELD, 4 + 16 + 4 + 4 + 16 + 4 + 4 + 1) { }
+
+            WorldPacket const* Write() override;
+
+            ObjectGuid Attacker;
+            ObjectGuid Defender;
+            int32 SpellID = 0;
+            int32 TotalDamage = 0;
+            int32 OverKill = 0;
+            int32 SchoolMask = 0;
+            int32 LogAbsorbed = 0;
+            Optional<Spells::SpellCastLogData> LogData;
+        };
     }
 }
 
diff --git a/src/server/game/Server/Protocol/Opcodes.cpp b/src/server/game/Server/Protocol/Opcodes.cpp
index 84743eea95a..883a1693cec 100644
--- a/src/server/game/Server/Protocol/Opcodes.cpp
+++ b/src/server/game/Server/Protocol/Opcodes.cpp
@@ -1492,7 +1492,7 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_POWER_UPDATE,                            STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_PRE_RESSURECT,                           STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_PRINT_NOTIFICATION,                      STATUS_NEVER,        CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_PROC_RESIST,                             STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_PROC_RESIST,                             STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_PROPOSE_LEVEL_GRANT,                     STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_PVP_CREDIT,                              STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_PVP_LOG_DATA,                            STATUS_UNHANDLED,    CONNECTION_TYPE_INSTANCE);
@@ -1638,24 +1638,24 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPELL_CHANNEL_START,                     STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPELL_CHANNEL_UPDATE,                    STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPELL_COOLDOWN,                          STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPELL_DAMAGE_SHIELD,                     STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPELL_DELAYED,                           STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPELL_DISPELL_LOG,                       STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPELL_ENERGIZE_LOG,                      STATUS_NEVER,        CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPELL_EXECUTE_LOG,                       STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPELL_DAMAGE_SHIELD,                     STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPELL_DELAYED,                           STATUS_UNHANDLED,    CONNECTION_TYPE_INSTANCE);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPELL_DISPELL_LOG,                       STATUS_UNHANDLED,    CONNECTION_TYPE_INSTANCE);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPELL_ENERGIZE_LOG,                      STATUS_NEVER,        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_NEVER,        CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPELL_INSTAKILL_LOG,                     STATUS_NEVER,        CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPELL_INTERRUPT_LOG,                     STATUS_NEVER,        CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPELL_MISS_LOG,                          STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPELL_MULTISTRIKE_EFFECT,                STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPELL_HEAL_LOG,                          STATUS_NEVER,        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);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPELL_MISS_LOG,                          STATUS_UNHANDLED,    CONNECTION_TYPE_INSTANCE);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPELL_MULTISTRIKE_EFFECT,                STATUS_UNHANDLED,    CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPELL_NON_MELEE_DAMAGE_LOG,              STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPELL_OR_DAMAGE_IMMUNE,                  STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPELL_PERIODIC_AURA_LOG,                 STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPELL_OR_DAMAGE_IMMUNE,                  STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPELL_PERIODIC_AURA_LOG,                 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_REALM);
+    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);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_START_ELAPSED_TIMER,                     STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);