Core/PacketIO: Updated combat log packets

7 files changed, 95 insertions, 68 deletions

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);