Core/Misc: Fixed armor mitigation after 567590248592494adabd0ffa8cbb3c9daed983f4

* Also fixes gcc build with -Werror enabled

4 files changed, 94 insertions, 88 deletions

diff --git a/src/server/game/Battlegrounds/ArenaScore.h b/src/server/game/Battlegrounds/ArenaScore.h
index 93eb1c64969..c5746f405f3 100644
--- a/src/server/game/Battlegrounds/ArenaScore.h
+++ b/src/server/game/Battlegrounds/ArenaScore.h
@@ -27,7 +27,7 @@ struct TC_GAME_API ArenaScore : public BattlegroundScore
     protected:
         ArenaScore(ObjectGuid playerGuid, uint32 team);
 
-        void BuildPvPLogPlayerDataPacket(WorldPackets::Battleground::PVPLogData::PlayerData& playerData) const;
+        void BuildPvPLogPlayerDataPacket(WorldPackets::Battleground::PVPLogData::PlayerData& playerData) const override;
 
         // For Logging purpose
         std::string ToString() const override;
diff --git a/src/server/game/Entities/Unit/Unit.cpp b/src/server/game/Entities/Unit/Unit.cpp
index 17a51e9d5b2..923e4514299 100644
--- a/src/server/game/Entities/Unit/Unit.cpp
+++ b/src/server/game/Entities/Unit/Unit.cpp
@@ -1603,7 +1603,7 @@ uint32 Unit::CalcArmorReducedDamage(Unit* attacker, Unit* victim, const uint32 d
     if (G3D::fuzzyLe(armor, 0.0f))
         return damage;
 
-    uint8 attackerLevel = attacker->getLevel();
+    uint8 attackerLevel = attacker->GetLevelForTarget(victim);
     if (attackerLevel > sArmorMitigationByLvlGameTable.GetTableRowCount())
         attackerLevel = sArmorMitigationByLvlGameTable.GetTableRowCount();
 
diff --git a/src/server/game/Server/Packets/CombatLogPacketsCommon.cpp b/src/server/game/Server/Packets/CombatLogPacketsCommon.cpp
index c4a36149dc6..7265af29d17 100644
--- a/src/server/game/Server/Packets/CombatLogPacketsCommon.cpp
+++ b/src/server/game/Server/Packets/CombatLogPacketsCommon.cpp
@@ -16,6 +16,8 @@
  */
 
 #include "CombatLogPacketsCommon.h"
+#include "Creature.h"
+#include "Player.h"
 #include "Spell.h"
 #include "SpellInfo.h"
 #include "Unit.h"
@@ -46,6 +48,96 @@ void WorldPackets::Spells::SpellCastLogData::Initialize(Spell const* spell)
         PowerData.insert(PowerData.begin(), SpellLogPowerData(int32(primaryPowerType), spell->GetCaster()->GetPower(primaryPowerType), 0));
 }
 
+namespace WorldPackets
+{
+    namespace Spells
+    {
+        template<class T, class U>
+        bool SandboxScalingData::GenerateDataForUnits(T* /*attacker*/, U* /*target*/)
+        {
+            return false;
+        }
+
+        template<>
+        bool SandboxScalingData::GenerateDataForUnits<Creature, Player>(Creature* attacker, Player* target)
+        {
+            CreatureTemplate const* creatureTemplate = attacker->GetCreatureTemplate();
+
+            Type = TYPE_CREATURE_TO_PLAYER_DAMAGE;
+            PlayerLevelDelta = target->GetInt32Value(PLAYER_FIELD_SCALING_PLAYER_LEVEL_DELTA);
+            PlayerItemLevel = target->GetAverageItemLevel();
+            TargetLevel = target->getLevel();
+            Expansion = creatureTemplate->RequiredExpansion;
+            Class = creatureTemplate->unit_class;
+            TargetMinScalingLevel = uint8(creatureTemplate->levelScaling->MinLevel);
+            TargetMaxScalingLevel = uint8(creatureTemplate->levelScaling->MaxLevel);
+            TargetScalingLevelDelta = int8(creatureTemplate->levelScaling->DeltaLevel);
+            return true;
+        }
+
+        template<>
+        bool SandboxScalingData::GenerateDataForUnits<Player, Creature>(Player* attacker, Creature* target)
+        {
+            CreatureTemplate const* creatureTemplate = target->GetCreatureTemplate();
+
+            Type = TYPE_PLAYER_TO_CREATURE_DAMAGE;
+            PlayerLevelDelta = attacker->GetInt32Value(PLAYER_FIELD_SCALING_PLAYER_LEVEL_DELTA);
+            PlayerItemLevel = attacker->GetAverageItemLevel();
+            TargetLevel = target->getLevel();
+            Expansion = creatureTemplate->RequiredExpansion;
+            Class = creatureTemplate->unit_class;
+            TargetMinScalingLevel = uint8(creatureTemplate->levelScaling->MinLevel);
+            TargetMaxScalingLevel = uint8(creatureTemplate->levelScaling->MaxLevel);
+            TargetScalingLevelDelta = int8(creatureTemplate->levelScaling->DeltaLevel);
+            return true;
+        }
+
+        template<>
+        bool SandboxScalingData::GenerateDataForUnits<Creature, Creature>(Creature* attacker, Creature* target)
+        {
+            CreatureTemplate const* creatureTemplate = target->HasScalableLevels() ? target->GetCreatureTemplate() : attacker->GetCreatureTemplate();
+
+            Type = TYPE_CREATURE_TO_CREATURE_DAMAGE;
+            PlayerLevelDelta = 0;
+            PlayerItemLevel = 0;
+            TargetLevel = target->getLevel();
+            Expansion = creatureTemplate->RequiredExpansion;
+            Class = creatureTemplate->unit_class;
+            TargetMinScalingLevel = uint8(creatureTemplate->levelScaling->MinLevel);
+            TargetMaxScalingLevel = uint8(creatureTemplate->levelScaling->MaxLevel);
+            TargetScalingLevelDelta = int8(creatureTemplate->levelScaling->DeltaLevel);
+            return true;
+        }
+
+        template<>
+        bool SandboxScalingData::GenerateDataForUnits<Unit, Unit>(Unit* attacker, Unit* target)
+        {
+            if (Player* playerAttacker = attacker->ToPlayer())
+            {
+                if (Player* playerTarget = target->ToPlayer())
+                    return GenerateDataForUnits(playerAttacker, playerTarget);
+                else if (Creature* creatureTarget = target->ToCreature())
+                {
+                    if (creatureTarget->HasScalableLevels())
+                        return GenerateDataForUnits(playerAttacker, creatureTarget);
+                }
+            }
+            else if (Creature* creatureAttacker = attacker->ToCreature())
+            {
+                if (Player* playerTarget = target->ToPlayer())
+                    return GenerateDataForUnits(creatureAttacker, playerTarget);
+                else if (Creature* creatureTarget = target->ToCreature())
+                {
+                    if (creatureAttacker->HasScalableLevels() || creatureTarget->HasScalableLevels())
+                        return GenerateDataForUnits(creatureAttacker, creatureTarget);
+                }
+            }
+
+            return false;
+        }
+    }
+}
+
 ByteBuffer& WorldPackets::CombatLog::CombatLogServerPacket::WriteLogData()
 {
     return _fullLogPacket << LogData;
diff --git a/src/server/game/Server/Packets/SpellPackets.cpp b/src/server/game/Server/Packets/SpellPackets.cpp
index 20f41f13e95..30a2f7e2b73 100644
--- a/src/server/game/Server/Packets/SpellPackets.cpp
+++ b/src/server/game/Server/Packets/SpellPackets.cpp
@@ -15,9 +15,7 @@
  * with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "Creature.h"
 #include "MovementPackets.h"
-#include "Player.h"
 #include "SpellPackets.h"
 
 void WorldPackets::Spells::CancelAura::Read()
@@ -92,90 +90,6 @@ WorldPacket const* WorldPackets::Spells::SendUnlearnSpells::Write()
     return &_worldPacket;
 }
 
-template<class T, class U>
-bool WorldPackets::Spells::SandboxScalingData::GenerateDataForUnits(T* /*attacker*/, U* /*target*/)
-{
-    return false;
-}
-
-template<>
-bool WorldPackets::Spells::SandboxScalingData::GenerateDataForUnits<Creature, Player>(Creature* attacker, Player* target)
-{
-    CreatureTemplate const* creatureTemplate = attacker->GetCreatureTemplate();
-
-    Type                    = TYPE_CREATURE_TO_PLAYER_DAMAGE;
-    PlayerLevelDelta        = target->GetInt32Value(PLAYER_FIELD_SCALING_PLAYER_LEVEL_DELTA);
-    PlayerItemLevel         = target->GetAverageItemLevel();
-    TargetLevel             = target->getLevel();
-    Expansion               = creatureTemplate->RequiredExpansion;
-    Class                   = creatureTemplate->unit_class;
-    TargetMinScalingLevel   = uint8(creatureTemplate->levelScaling->MinLevel);
-    TargetMaxScalingLevel   = uint8(creatureTemplate->levelScaling->MaxLevel);
-    TargetScalingLevelDelta = int8(creatureTemplate->levelScaling->DeltaLevel);
-    return true;
-}
-
-template<>
-bool WorldPackets::Spells::SandboxScalingData::GenerateDataForUnits<Player, Creature>(Player* attacker, Creature* target)
-{
-    CreatureTemplate const* creatureTemplate = target->GetCreatureTemplate();
-
-    Type                    = TYPE_PLAYER_TO_CREATURE_DAMAGE;
-    PlayerLevelDelta        = attacker->GetInt32Value(PLAYER_FIELD_SCALING_PLAYER_LEVEL_DELTA);
-    PlayerItemLevel         = attacker->GetAverageItemLevel();
-    TargetLevel             = target->getLevel();
-    Expansion               = creatureTemplate->RequiredExpansion;
-    Class                   = creatureTemplate->unit_class;
-    TargetMinScalingLevel   = uint8(creatureTemplate->levelScaling->MinLevel);
-    TargetMaxScalingLevel   = uint8(creatureTemplate->levelScaling->MaxLevel);
-    TargetScalingLevelDelta = int8(creatureTemplate->levelScaling->DeltaLevel);
-    return true;
-}
-
-template<>
-bool WorldPackets::Spells::SandboxScalingData::GenerateDataForUnits<Creature, Creature>(Creature* attacker, Creature* target)
-{
-    CreatureTemplate const* creatureTemplate = target->HasScalableLevels() ? target->GetCreatureTemplate() : attacker->GetCreatureTemplate();
-
-    Type                    = TYPE_CREATURE_TO_CREATURE_DAMAGE;
-    PlayerLevelDelta        = 0;
-    PlayerItemLevel         = 0;
-    TargetLevel             = target->getLevel();
-    Expansion               = creatureTemplate->RequiredExpansion;
-    Class                   = creatureTemplate->unit_class;
-    TargetMinScalingLevel   = uint8(creatureTemplate->levelScaling->MinLevel);
-    TargetMaxScalingLevel   = uint8(creatureTemplate->levelScaling->MaxLevel);
-    TargetScalingLevelDelta = int8(creatureTemplate->levelScaling->DeltaLevel);
-    return true;
-}
-
-template<>
-bool WorldPackets::Spells::SandboxScalingData::GenerateDataForUnits<Unit, Unit>(Unit* attacker, Unit* target)
-{
-    if (Player* playerAttacker = attacker->ToPlayer())
-    {
-        if (Player* playerTarget = target->ToPlayer())
-            return GenerateDataForUnits(playerAttacker, playerTarget);
-        else if (Creature* creatureTarget = target->ToCreature())
-        {
-            if (creatureTarget->HasScalableLevels())
-                return GenerateDataForUnits(playerAttacker, creatureTarget);
-        }
-    }
-    else if (Creature* creatureAttacker = attacker->ToCreature())
-    {
-        if (Player* playerTarget = target->ToPlayer())
-            return GenerateDataForUnits(creatureAttacker, playerTarget);
-        else if (Creature* creatureTarget = target->ToCreature())
-        {
-            if (creatureAttacker->HasScalableLevels() || creatureTarget->HasScalableLevels())
-                return GenerateDataForUnits(creatureAttacker, creatureTarget);
-        }
-    }
-
-    return false;
-}
-
 ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Spells::AuraDataInfo const& auraData)
 {
     data << auraData.CastID;