Core/PacketIO: Updated combat log packets

14 files changed, 108 insertions, 79 deletions

diff --git a/src/server/game/Entities/Player/Player.cpp b/src/server/game/Entities/Player/Player.cpp
index 6fefd4cb383..c4bd0c0fc3e 100644
--- a/src/server/game/Entities/Player/Player.cpp
+++ b/src/server/game/Entities/Player/Player.cpp
@@ -6311,6 +6311,7 @@ bool Player::RewardHonor(Unit* victim, uint32 groupsize, int32 honor, bool pvpto
     // victim_rank [0, 20+] HK: <>
     WorldPackets::Combat::PvPCredit data;
     data.Honor = honor;
+    data.OriginalHonor = honor;
     data.Target = victim_guid;
     data.Rank = victim_rank;
 
diff --git a/src/server/game/Entities/Unit/Unit.cpp b/src/server/game/Entities/Unit/Unit.cpp
index ab16b8275c9..551efbca752 100644
--- a/src/server/game/Entities/Unit/Unit.cpp
+++ b/src/server/game/Entities/Unit/Unit.cpp
@@ -165,8 +165,8 @@ ProcEventInfo::ProcEventInfo(Unit* actor, Unit* actionTarget, Unit* procTarget,
     _damageInfo(damageInfo), _healInfo(healInfo)
 { }
 
-SpellNonMeleeDamage::SpellNonMeleeDamage(Unit* _attacker, Unit* _target, uint32 _SpellID, uint32 _schoolMask)
-    : target(_target), attacker(_attacker), SpellID(_SpellID), damage(0), schoolMask(_schoolMask),
+SpellNonMeleeDamage::SpellNonMeleeDamage(Unit* _attacker, Unit* _target, uint32 _SpellID, uint32 _schoolMask, ObjectGuid _castId)
+    : target(_target), attacker(_attacker), castId(_castId), SpellID(_SpellID), damage(0), schoolMask(_schoolMask),
     absorb(0), resist(0), periodicLog(false), blocked(0), HitInfo(0), cleanDamage(0), preHitHealth(_target->GetHealth())
 {
 }
@@ -1774,7 +1774,7 @@ void Unit::CalcAbsorbResist(Unit* victim, SpellSchoolMask schoolMask, DamageEffe
             uint32 split_absorb = 0;
             DealDamageMods(caster, splitDamage, &split_absorb);
 
-            SpellNonMeleeDamage log(this, caster, (*itr)->GetSpellInfo()->Id, schoolMask);
+            SpellNonMeleeDamage log(this, caster, (*itr)->GetSpellInfo()->Id, schoolMask, (*itr)->GetBase()->GetCastGUID());
             CleanDamage cleanDamage = CleanDamage(splitDamage, 0, BASE_ATTACK, MELEE_HIT_NORMAL);
             DealDamage(caster, splitDamage, &cleanDamage, DIRECT_DAMAGE, schoolMask, (*itr)->GetSpellInfo(), false);
             log.damage = splitDamage;
@@ -4829,6 +4829,7 @@ void Unit::SendSpellNonMeleeDamageLog(SpellNonMeleeDamage const* log)
     WorldPackets::CombatLog::SpellNonMeleeDamageLog packet;
     packet.Me = log->target->GetGUID();
     packet.CasterGUID = log->attacker->GetGUID();
+    packet.CastID = log->castId;
     packet.SpellID = log->SpellID;
     packet.Damage = log->damage;
     if (log->damage > log->preHitHealth)
@@ -4874,7 +4875,6 @@ void Unit::SendPeriodicAuraLog(SpellPeriodicAuraLogInfo* info)
     spellLogEffect.AbsorbedOrAmplitude = info->absorb;
     spellLogEffect.Resisted = info->resist;
     spellLogEffect.Crit = info->critical;
-    spellLogEffect.Multistrike = false; // NYI
     /// @todo: implement debug info
 
     data.Effects.push_back(spellLogEffect);
diff --git a/src/server/game/Entities/Unit/Unit.h b/src/server/game/Entities/Unit/Unit.h
index 15792d4f543..209958f430b 100644
--- a/src/server/game/Entities/Unit/Unit.h
+++ b/src/server/game/Entities/Unit/Unit.h
@@ -1051,10 +1051,11 @@ struct CalcDamageInfo
 // Spell damage info structure based on structure sending in SMSG_SPELLNONMELEEDAMAGELOG opcode
 struct TC_GAME_API SpellNonMeleeDamage
 {
-    SpellNonMeleeDamage(Unit* _attacker, Unit* _target, uint32 _SpellID, uint32 _schoolMask);
+    SpellNonMeleeDamage(Unit* _attacker, Unit* _target, uint32 _SpellID, uint32 _schoolMask, ObjectGuid _castId = ObjectGuid::Empty);
 
     Unit   *target;
     Unit   *attacker;
+    ObjectGuid castId;
     uint32 SpellID;
     uint32 damage;
     uint32 schoolMask;
diff --git a/src/server/game/Server/Packets/CombatLogPackets.cpp b/src/server/game/Server/Packets/CombatLogPackets.cpp
index f431b9b77a5..f1e6ac04d65 100644
--- a/src/server/game/Server/Packets/CombatLogPackets.cpp
+++ b/src/server/game/Server/Packets/CombatLogPackets.cpp
@@ -22,6 +22,7 @@ WorldPacket const* WorldPackets::CombatLog::SpellNonMeleeDamageLog::Write()
 {
     *this << Me;
     *this << CasterGUID;
+    *this << CastID;
     *this << int32(SpellID);
     *this << int32(Damage);
     *this << int32(Overkill);
@@ -30,11 +31,14 @@ WorldPacket const* WorldPackets::CombatLog::SpellNonMeleeDamageLog::Write()
     *this << int32(Resisted);
     *this << int32(Absorbed);
     WriteBit(Periodic);
-    WriteBits(Flags, 8);
+    WriteBits(Flags, 7);
     WriteBit(false); // Debug info
     WriteLogDataBit();
+    WriteBit(SandboxScaling.is_initialized());
     FlushBits();
     WriteLogData();
+    if (SandboxScaling)
+        *this << *SandboxScaling;
 
     return &_worldPacket;
 }
@@ -117,10 +121,10 @@ WorldPacket const* WorldPackets::CombatLog::SpellHealLog::Write()
     *this << int32(OverHeal);
     *this << int32(Absorbed);
     WriteBit(Crit);
-    WriteBit(Multistrike);
     WriteBit(CritRollMade.is_initialized());
     WriteBit(CritRollNeeded.is_initialized());
     WriteLogDataBit();
+    WriteBit(SandboxScaling.is_initialized());
     FlushBits();
 
     if (CritRollMade)
@@ -131,6 +135,9 @@ WorldPacket const* WorldPackets::CombatLog::SpellHealLog::Write()
 
     WriteLogData();
 
+    if (SandboxScaling)
+        *this << *SandboxScaling;
+
     return &_worldPacket;
 }
 
@@ -138,27 +145,31 @@ WorldPacket const* WorldPackets::CombatLog::SpellPeriodicAuraLog::Write()
 {
     *this << TargetGUID;
     *this << CasterGUID;
-    *this << SpellID;
+    *this << int32(SpellID);
     *this << uint32(Effects.size());
 
     for (SpellLogEffect const& effect : Effects)
     {
-        *this << effect.Effect;
+        *this << int32(effect.Effect);
         *this << int32(effect.Amount);
         *this << int32(effect.OverHealOrKill);
         *this << int32(effect.SchoolMaskOrPower);
         *this << int32(effect.AbsorbedOrAmplitude);
         *this << int32(effect.Resisted);
         WriteBit(effect.Crit);
-        WriteBit(effect.Multistrike);
+        WriteBit(effect.DebugInfo.is_initialized());
+        WriteBit(effect.SandboxScaling.is_initialized());
+        FlushBits();
 
-        if (WriteBit(effect.DebugInfo.is_initialized()))
+        if (effect.SandboxScaling)
+            *this << *effect.SandboxScaling;
+
+        if (effect.DebugInfo)
         {
             *this << float(effect.DebugInfo->CritRollMade);
             *this << float(effect.DebugInfo->CritRollNeeded);
         }
 
-        FlushBits();
     }
 
     WriteLogDataBit();
@@ -280,49 +291,59 @@ WorldPacket const* WorldPackets::CombatLog::SpellDamageShield::Write()
 WorldPacket const* WorldPackets::CombatLog::AttackerStateUpdate::Write()
 {
     ByteBuffer attackRoundInfo;
-    attackRoundInfo << HitInfo;
+    attackRoundInfo << uint32(HitInfo);
     attackRoundInfo << AttackerGUID;
     attackRoundInfo << VictimGUID;
-    attackRoundInfo << Damage;
-    attackRoundInfo << OverDamage;
-
-    if (attackRoundInfo.WriteBit(SubDmg.is_initialized()))
+    attackRoundInfo << int32(Damage);
+    attackRoundInfo << int32(OverDamage);
+    attackRoundInfo << uint8(SubDmg.is_initialized());
+    if (SubDmg)
     {
-       attackRoundInfo << SubDmg->SchoolMask;
-       attackRoundInfo << SubDmg->FDamage;
-       attackRoundInfo << SubDmg->Damage;
+       attackRoundInfo << int32(SubDmg->SchoolMask);
+       attackRoundInfo << float(SubDmg->FDamage);
+       attackRoundInfo << int32(SubDmg->Damage);
         if (HitInfo & (HITINFO_FULL_ABSORB | HITINFO_PARTIAL_ABSORB))
-            attackRoundInfo << SubDmg->Absorbed;
+            attackRoundInfo << int32(SubDmg->Absorbed);
         if (HitInfo & (HITINFO_FULL_RESIST | HITINFO_PARTIAL_RESIST))
-            attackRoundInfo << SubDmg->Resisted;
+            attackRoundInfo << int32(SubDmg->Resisted);
     }
 
-    attackRoundInfo << VictimState;
-    attackRoundInfo << AttackerState;
-    attackRoundInfo << MeleeSpellID;
+    attackRoundInfo << uint8(VictimState);
+    attackRoundInfo << uint32(AttackerState);
+    attackRoundInfo << uint32(MeleeSpellID);
     if (HitInfo & HITINFO_BLOCK)
-        attackRoundInfo << BlockAmount;
+        attackRoundInfo << int32(BlockAmount);
 
     if (HitInfo & HITINFO_RAGE_GAIN)
-        attackRoundInfo << RageGained;
+        attackRoundInfo << int32(RageGained);
 
     if (HitInfo & HITINFO_UNK1)
     {
-        attackRoundInfo << UnkState.State1;
-        attackRoundInfo << UnkState.State2;
-        attackRoundInfo << UnkState.State3;
-        attackRoundInfo << UnkState.State4;
-        attackRoundInfo << UnkState.State5;
-        attackRoundInfo << UnkState.State6;
-        attackRoundInfo << UnkState.State7;
-        attackRoundInfo << UnkState.State8;
-        attackRoundInfo << UnkState.State9;
-        attackRoundInfo << UnkState.State10;
-        attackRoundInfo << UnkState.State11;
-        attackRoundInfo << UnkState.State12;
+        attackRoundInfo << uint32(UnkState.State1);
+        attackRoundInfo << float(UnkState.State2);
+        attackRoundInfo << float(UnkState.State3);
+        attackRoundInfo << float(UnkState.State4);
+        attackRoundInfo << float(UnkState.State5);
+        attackRoundInfo << float(UnkState.State6);
+        attackRoundInfo << float(UnkState.State7);
+        attackRoundInfo << float(UnkState.State8);
+        attackRoundInfo << float(UnkState.State9);
+        attackRoundInfo << float(UnkState.State10);
+        attackRoundInfo << float(UnkState.State11);
+        attackRoundInfo << uint32(UnkState.State12);
     }
+
     if (HitInfo & (HITINFO_BLOCK | HITINFO_UNK12))
-        attackRoundInfo << Unk;
+        attackRoundInfo << float(Unk);
+
+    attackRoundInfo << uint8(SandboxScaling.Type);
+    attackRoundInfo << uint8(SandboxScaling.TargetLevel);
+    attackRoundInfo << uint8(SandboxScaling.Expansion);
+    attackRoundInfo << uint8(SandboxScaling.Class);
+    attackRoundInfo << uint8(SandboxScaling.TargetMinScalingLevel);
+    attackRoundInfo << uint8(SandboxScaling.TargetMaxScalingLevel);
+    attackRoundInfo << int16(SandboxScaling.PlayerLevelDelta);
+    attackRoundInfo << int8(SandboxScaling.TargetScalingLevelDelta);
 
     WriteLogDataBit();
     FlushBits();
diff --git a/src/server/game/Server/Packets/CombatLogPackets.h b/src/server/game/Server/Packets/CombatLogPackets.h
index 050c436a770..f4eed7caea5 100644
--- a/src/server/game/Server/Packets/CombatLogPackets.h
+++ b/src/server/game/Server/Packets/CombatLogPackets.h
@@ -82,18 +82,20 @@ namespace WorldPackets
 
             WorldPacket const* Write() override;
 
-            int32 Absorbed = 0;
-            int32 ShieldBlock = 0;
             ObjectGuid Me;
-            int32 SpellID = 0;
-            int32 Resisted = 0;
-            bool Periodic = 0.0f;
-            uint8 SchoolMask = 0;
             ObjectGuid CasterGUID;
+            ObjectGuid CastID;
+            int32 SpellID = 0;
             int32 Damage = 0;
-            // Optional<SpellNonMeleeDamageLogDebugInfo> Debug Info;
-            int32 Flags = 0;
             int32 Overkill = 0;
+            uint8 SchoolMask = 0;
+            int32 ShieldBlock = 0;
+            int32 Resisted = 0;
+            bool Periodic = false;
+            int32 Absorbed = 0;
+            int32 Flags = 0;
+            // Optional<SpellNonMeleeDamageLogDebugInfo> Debug Info;
+            Optional<Spells::SandboxScalingData> SandboxScaling;
         };
 
         class EnvironmentalDamageLog final : public CombatLogServerPacket
@@ -148,9 +150,9 @@ namespace WorldPackets
             int32 OverHeal      = 0;
             int32 Absorbed      = 0;
             bool Crit           = false;
-            bool Multistrike    = false;
             Optional<float> CritRollMade;
             Optional<float> CritRollNeeded;
+            Optional<Spells::SandboxScalingData> SandboxScaling;
         };
 
         class SpellPeriodicAuraLog final : public CombatLogServerPacket
@@ -171,8 +173,8 @@ namespace WorldPackets
                 int32 AbsorbedOrAmplitude = 0;
                 int32 Resisted            = 0;
                 bool Crit                 = false;
-                bool Multistrike          = false;
                 Optional<PeriodicalAuraLogEffectDebugInfo> DebugInfo;
+                Optional<Spells::SandboxScalingData> SandboxScaling;
             };
 
             SpellPeriodicAuraLog() : CombatLogServerPacket(SMSG_SPELL_PERIODIC_AURA_LOG, 16 + 16 + 4 + 4 + 1) { }
@@ -328,7 +330,7 @@ namespace WorldPackets
 
         struct UnkAttackerState
         {
-            int32 State1 = 0;
+            uint32 State1 = 0;
             float State2 = 0.0f;
             float State3 = 0.0f;
             float State4 = 0.0f;
@@ -339,7 +341,7 @@ namespace WorldPackets
             float State9 = 0.0f;
             float State10 = 0.0f;
             float State11 = 0.0f;
-            int32 State12 = 0;
+            uint32 State12 = 0;
         };
 
         class AttackerStateUpdate final : public CombatLogServerPacket
@@ -356,12 +358,13 @@ namespace WorldPackets
             int32 OverDamage = -1; // (damage - health) or -1 if unit is still alive
             Optional<SubDamage> SubDmg;
             uint8 VictimState = 0;
-            int32 AttackerState = -1;
-            int32 MeleeSpellID = 0;
+            uint32 AttackerState = 0;
+            uint32 MeleeSpellID = 0;
             int32 BlockAmount = 0;
             int32 RageGained = 0;
             UnkAttackerState UnkState;
             float Unk = 0.0f;
+            Spells::SandboxScalingData SandboxScaling;
         };
     }
 }
diff --git a/src/server/game/Server/Packets/CombatPackets.cpp b/src/server/game/Server/Packets/CombatPackets.cpp
index 8f2ea3ac39a..3b3bcc5d19c 100644
--- a/src/server/game/Server/Packets/CombatPackets.cpp
+++ b/src/server/game/Server/Packets/CombatPackets.cpp
@@ -143,6 +143,7 @@ WorldPacket const* WorldPackets::Combat::ThreatClear::Write()
 
 WorldPacket const* WorldPackets::Combat::PvPCredit::Write()
 {
+    _worldPacket << int32(OriginalHonor);
     _worldPacket << int32(Honor);
     _worldPacket << Target;
     _worldPacket << int32(Rank);
diff --git a/src/server/game/Server/Packets/CombatPackets.h b/src/server/game/Server/Packets/CombatPackets.h
index 4a8eddc2562..550fee5fe35 100644
--- a/src/server/game/Server/Packets/CombatPackets.h
+++ b/src/server/game/Server/Packets/CombatPackets.h
@@ -206,8 +206,9 @@ namespace WorldPackets
 
             WorldPacket const* Write() override;
 
-            ObjectGuid Target;
+            int32 OriginalHonor = 0;
             int32 Honor = 0;
+            ObjectGuid Target;
             int32 Rank = 0;
         };
 
diff --git a/src/server/game/Server/Packets/SpellPackets.cpp b/src/server/game/Server/Packets/SpellPackets.cpp
index 36ce28478f0..599d07e0d87 100644
--- a/src/server/game/Server/Packets/SpellPackets.cpp
+++ b/src/server/game/Server/Packets/SpellPackets.cpp
@@ -117,16 +117,16 @@ ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Spells::SpellCastLogData
     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);
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Spells::SandboxScalingData const& sandboxScalingData)
+{
+    data.WriteBits(sandboxScalingData.Type, 3);
+    data << int16(sandboxScalingData.PlayerLevelDelta);
+    data << uint8(sandboxScalingData.TargetLevel);
+    data << uint8(sandboxScalingData.Expansion);
+    data << uint8(sandboxScalingData.Class);
+    data << uint8(sandboxScalingData.TargetMinScalingLevel);
+    data << uint8(sandboxScalingData.TargetMaxScalingLevel);
+    data << int8(sandboxScalingData.TargetScalingLevelDelta);
     return data;
 }
 
diff --git a/src/server/game/Server/Packets/SpellPackets.h b/src/server/game/Server/Packets/SpellPackets.h
index 901ebdd6b87..a3a68c8e194 100644
--- a/src/server/game/Server/Packets/SpellPackets.h
+++ b/src/server/game/Server/Packets/SpellPackets.h
@@ -926,5 +926,6 @@ namespace WorldPackets
 
 ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Spells::SpellCastLogData const& spellCastLogData);
 ByteBuffer& operator>>(ByteBuffer& buffer, WorldPackets::Spells::SpellCastRequest& request);
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Spells::SandboxScalingData const& sandboxScalingData);
 
 #endif // SpellPackets_h__
diff --git a/src/server/game/Server/Protocol/Opcodes.cpp b/src/server/game/Server/Protocol/Opcodes.cpp
index dd0ec3577c0..7bfbb88e9bd 100644
--- a/src/server/game/Server/Protocol/Opcodes.cpp
+++ b/src/server/game/Server/Protocol/Opcodes.cpp
@@ -852,7 +852,7 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_ARTIFACT_FORGE_OPENED,                   STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_ARTIFACT_POWERS_UPDATED,                 STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_ARTIFACT_XP_GAIN,                        STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_ATTACKER_STATE_UPDATE,                   STATUS_UNHANDLED,    CONNECTION_TYPE_INSTANCE);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_ATTACKER_STATE_UPDATE,                   STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_ATTACK_START,                            STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_ATTACK_STOP,                             STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_ATTACK_SWING_ERROR,                      STATUS_NEVER,        CONNECTION_TYPE_REALM);
@@ -1076,7 +1076,7 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_ENCOUNTER_END,                           STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_ENCOUNTER_START,                         STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_ENUM_CHARACTERS_RESULT,                  STATUS_NEVER,        CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_ENVIRONMENTAL_DAMAGE_LOG,                STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_ENVIRONMENTAL_DAMAGE_LOG,                STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_EQUIPMENT_SET_ID,                        STATUS_UNHANDLED,    CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_EXPECTED_SPAM_RECORDS,                   STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_EXPLORATION_EXPERIENCE,                  STATUS_NEVER,        CONNECTION_TYPE_REALM);
@@ -1498,7 +1498,7 @@ void OpcodeTable::Initialize()
     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_PUSH_SPELL_TO_ACTION_BAR,                STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_PVP_CREDIT,                              STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_PVP_CREDIT,                              STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_PVP_LOG_DATA,                            STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_PVP_OPTIONS_ENABLED,                     STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_PVP_SEASON,                              STATUS_NEVER,        CONNECTION_TYPE_REALM);
@@ -1653,21 +1653,21 @@ 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_INSTANCE);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPELL_DAMAGE_SHIELD,                     STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     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_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_UNHANDLED,    CONNECTION_TYPE_INSTANCE);
+    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_NEVER,        CONNECTION_TYPE_INSTANCE);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPELL_NON_MELEE_DAMAGE_LOG,              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_NEVER,        CONNECTION_TYPE_INSTANCE);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPELL_PERIODIC_AURA_LOG,                 STATUS_UNHANDLED,    CONNECTION_TYPE_INSTANCE);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_SPELL_PERIODIC_AURA_LOG,                 STATUS_NEVER,        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);
diff --git a/src/server/game/Spells/Auras/SpellAuraEffects.cpp b/src/server/game/Spells/Auras/SpellAuraEffects.cpp
index 58375e3f0df..a6ab82e2211 100644
--- a/src/server/game/Spells/Auras/SpellAuraEffects.cpp
+++ b/src/server/game/Spells/Auras/SpellAuraEffects.cpp
@@ -6055,7 +6055,7 @@ void AuraEffect::HandlePeriodicHealthLeechAuraTick(Unit* target, Unit* caster) c
     TC_LOG_DEBUG("spells.periodic", "PeriodicTick: %s health leech of %s for %u dmg inflicted by %u abs is %u",
         GetCasterGUID().ToString().c_str(), target->GetGUID().ToString().c_str(), damage, GetId(), absorb);
 
-    SpellNonMeleeDamage log(caster, target, GetId(), GetSpellInfo()->GetSchoolMask());
+    SpellNonMeleeDamage log(caster, target, GetId(), GetSpellInfo()->GetSchoolMask(), GetBase()->GetCastGUID());
     log.damage = damage - absorb - resist;
     log.absorb = absorb;
     log.resist = resist;
@@ -6359,7 +6359,7 @@ void AuraEffect::HandlePeriodicPowerBurnAuraTick(Unit* target, Unit* caster) con
 
     SpellInfo const* spellProto = GetSpellInfo();
     // maybe has to be sent different to client, but not by SMSG_PERIODICAURALOG
-    SpellNonMeleeDamage damageInfo(caster, target, spellProto->Id, spellProto->SchoolMask);
+    SpellNonMeleeDamage damageInfo(caster, target, spellProto->Id, spellProto->SchoolMask, GetBase()->GetCastGUID());
     // no SpellDamageBonus for burn mana
     caster->CalculateSpellDamageTaken(&damageInfo, int32(gain * dmgMultiplier), spellProto);
 
@@ -6413,7 +6413,7 @@ void AuraEffect::HandleProcTriggerDamageAuraProc(AuraApplication* aurApp, ProcEv
 {
     Unit* target = aurApp->GetTarget();
     Unit* triggerTarget = eventInfo.GetProcTarget();
-    SpellNonMeleeDamage damageInfo(target, triggerTarget, GetId(), GetSpellInfo()->SchoolMask);
+    SpellNonMeleeDamage damageInfo(target, triggerTarget, GetId(), GetSpellInfo()->SchoolMask, GetBase()->GetCastGUID());
     uint32 damage = target->SpellDamageBonusDone(triggerTarget, GetSpellInfo(), GetAmount(), SPELL_DIRECT_DAMAGE, GetSpellEffectInfo());
     damage = triggerTarget->SpellDamageBonusTaken(target, GetSpellInfo(), damage, SPELL_DIRECT_DAMAGE, GetSpellEffectInfo());
     target->CalculateSpellDamageTaken(&damageInfo, damage, GetSpellInfo());
diff --git a/src/server/game/Spells/Spell.cpp b/src/server/game/Spells/Spell.cpp
index d109667cd85..a3553f6b762 100644
--- a/src/server/game/Spells/Spell.cpp
+++ b/src/server/game/Spells/Spell.cpp
@@ -2428,7 +2428,7 @@ void Spell::DoAllEffectOnTarget(TargetInfo* target)
     else if (m_damage > 0)
     {
         // Fill base damage struct (unitTarget - is real spell target)
-        SpellNonMeleeDamage damageInfo(caster, unitTarget, m_spellInfo->Id, m_spellSchoolMask);
+        SpellNonMeleeDamage damageInfo(caster, unitTarget, m_spellInfo->Id, m_spellSchoolMask, m_castId);
 
         // Add bonuses and fill damageInfo struct
         caster->CalculateSpellDamageTaken(&damageInfo, m_damage, m_spellInfo, m_attackType, target->crit);
diff --git a/src/server/game/Spells/SpellEffects.cpp b/src/server/game/Spells/SpellEffects.cpp
index 11a92fd67b8..0cca7a27d2c 100644
--- a/src/server/game/Spells/SpellEffects.cpp
+++ b/src/server/game/Spells/SpellEffects.cpp
@@ -396,7 +396,7 @@ void Spell::EffectEnvironmentalDMG(SpellEffIndex /*effIndex*/)
     uint32 resist = 0;
 
     m_caster->CalcAbsorbResist(unitTarget, m_spellInfo->GetSchoolMask(), SPELL_DIRECT_DAMAGE, damage, &absorb, &resist, m_spellInfo);
-    SpellNonMeleeDamage log(m_caster, unitTarget, m_spellInfo->Id, m_spellInfo->GetSchoolMask());
+    SpellNonMeleeDamage log(m_caster, unitTarget, m_spellInfo->Id, m_spellInfo->GetSchoolMask(), m_castId);
     log.damage = damage - absorb - resist;
     log.absorb = absorb;
     log.resist = resist;
diff --git a/src/server/scripts/Spells/spell_warlock.cpp b/src/server/scripts/Spells/spell_warlock.cpp
index 5cc25d87f99..6c6eec993ab 100644
--- a/src/server/scripts/Spells/spell_warlock.cpp
+++ b/src/server/scripts/Spells/spell_warlock.cpp
@@ -793,7 +793,7 @@ class spell_warl_health_funnel : public SpellScriptLoader
                 if (Player* modOwner = caster->GetSpellModOwner())
                     modOwner->ApplySpellMod(GetId(), SPELLMOD_COST, damage);
 
-                SpellNonMeleeDamage damageInfo(caster, caster, GetSpellInfo()->Id, GetSpellInfo()->SchoolMask);
+                SpellNonMeleeDamage damageInfo(caster, caster, GetSpellInfo()->Id, GetSpellInfo()->SchoolMask, GetAura()->GetCastGUID());
                 damageInfo.periodicLog = true;
                 damageInfo.damage = damage;
                 caster->DealSpellDamage(&damageInfo, false);