Merge AzerothCore 3.3.5 to ElunaAzerothcore [skip ci]

Author: github-actions[bot]

data/sql/updates/db_world/2026_01_22_00.sql

@@ -0,0 +1,5 @@
+-- DB update 2026_01_21_02 -> 2026_01_22_00
+--
+DELETE FROM `spell_script_names` WHERE `spell_id` = 28375;
+INSERT INTO `spell_script_names` (`spell_id`, `ScriptName`) VALUES
+(28375, 'spell_gluth_decimate_damage');

data/sql/updates/db_world/2026_01_22_01.sql

@@ -0,0 +1,27 @@
+-- DB update 2026_01_22_00 -> 2026_01_22_01
+-- PrevQuestID from 12822 to 18221, A Flawless Plan requires Opening the Backdoor, not Know No Fear
+UPDATE `quest_template_addon` SET `PrevQuestID` = 12821 WHERE `ID` = 12823;
+
+-- Remove phase shifts in Garm and Garm's Rise for Know No Fear
+DELETE FROM `spell_area`
+WHERE `Quest_start` = 12822
+  AND `quest_start_status` = 74;
+
+-- Add phase shift in Garm and Garm's Rise after turning in Opening the Backdoor
+DELETE FROM `spell_area` WHERE `Quest_start` = 12821 AND `Spell` = 54635;
+INSERT INTO `spell_area`
+(
+  `Spell`,
+  `Area`,
+  `Quest_start`,
+  `Quest_end`,
+  `Aura_spell`,
+  `Racemask`,
+  `Gender`,
+  `Autocast`,
+  `Quest_start_status`,
+  `Quest_end_status`
+)
+VALUES
+(54635, 4421, 12821, 0, 0, 0, 2, 1, 64, 0),
+(54635, 4461, 12821, 0, 0, 0, 2, 1, 64, 0);

data/sql/updates/db_world/2026_01_22_02.sql

@@ -0,0 +1,7 @@
+-- DB update 2026_01_22_01 -> 2026_01_22_02
+--
+DELETE FROM `smart_scripts` WHERE `entryorguid` = 28581 AND `source_type` = 0 AND `id` IN (0, 1, 2);
+INSERT INTO `smart_scripts` (`entryorguid`, `source_type`, `id`, `link`, `event_type`, `event_phase_mask`, `event_chance`, `event_flags`, `event_param1`, `event_param2`, `event_param3`, `event_param4`, `event_param5`, `event_param6`, `action_type`, `action_param1`, `action_param2`, `action_param3`, `action_param4`, `action_param5`, `action_param6`, `target_type`, `target_param1`, `target_param2`, `target_param3`, `target_param4`, `target_x`, `target_y`, `target_z`, `target_o`, `comment`) VALUES
+(28581, 0, 0, 0, 0, 0, 100, 2, 0, 9000, 11000, 14000, 0, 0, 11, 52778, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 'Stormforged Tactician - In Combat - Cast \'Welding Beam\' (Normal Dungeon)'),
+(28581, 0, 1, 0, 0, 0, 100, 4, 0, 9000, 11000, 14000, 0, 0, 11, 59166, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 'Stormforged Tactician - In Combat - Cast \'Welding Beam\' (Heroic Dungeon)'),
+(28581, 0, 2, 0, 2, 0, 100, 6, 0, 70, 15000, 27000, 0, 0, 11, 59085, 32, 0, 0, 0, 0, 5, 40, 0, 0, 0, 0, 0, 0, 0, 'Stormforged Tactician - Between 0-70% Health - Cast \'Arc Weld\' (Dungeon)');

data/sql/updates/db_world/2026_01_22_03.sql

@@ -0,0 +1,8 @@
+-- DB update 2026_01_22_02 -> 2026_01_22_03
+--
+UPDATE `creature_template` SET `AIName` = 'SmartAI' WHERE `entry` = 29134;
+
+DELETE FROM `smart_scripts` WHERE (`entryorguid` = 29134) AND (`source_type` = 0) AND (`id` IN (0, 1));
+INSERT INTO `smart_scripts` (`entryorguid`, `source_type`, `id`, `link`, `event_type`, `event_phase_mask`, `event_chance`, `event_flags`, `event_param1`, `event_param2`, `event_param3`, `event_param4`, `event_param5`, `event_param6`, `action_type`, `action_param1`, `action_param2`, `action_param3`, `action_param4`, `action_param5`, `action_param6`, `target_type`, `target_param1`, `target_param2`, `target_param3`, `target_param4`, `target_x`, `target_y`, `target_z`, `target_o`, `comment`) VALUES
+(29134, 0, 0, 0, 54, 0, 100, 0, 0, 0, 0, 0, 0, 0, 41, 180000, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 'Brown Rabbit - On Just Summoned - Despawn In 180000 ms'),
+(29134, 0, 1, 0, 6, 0, 100, 0, 0, 0, 0, 0, 0, 0, 11, 53273, 2, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 'Brown Rabbit - On Death - Cast \'Decoy Explosive\'');

data/sql/updates/db_world/2026_01_22_04.sql

@@ -0,0 +1,3 @@
+-- DB update 2026_01_22_03 -> 2026_01_22_04
+-- Sniffed from 50664 Build
+UPDATE `creature_template` SET `unit_flags` = `unit_flags`&~(2|131072), `unit_flags` = `unit_flags`|256 WHERE (`entry` IN (31079, 31492));

src/server/game/Combat/ThreatMgr.cpp

@@ -328,7 +328,7 @@ HostileReference* ThreatContainer::SelectNextVictim(Creature* attacker, HostileR
         Unit* cvUnit = currentVictim->getTarget();
         if (!attacker->CanCreatureAttack(cvUnit)) // pussywizard: if currentVictim is not valid => don't compare the threat with it, just take the highest threat valid target
             currentVictim = nullptr;
-        else if (cvUnit->IsImmunedToDamageOrSchool(attacker->GetMeleeDamageSchoolMask()) || cvUnit->HasNegativeAuraWithInterruptFlag(AURA_INTERRUPT_FLAG_TAKE_DAMAGE) || cvUnit->HasUnitState(UNIT_STATE_CONFUSED)) // pussywizard: no 10%/30% if currentVictim is immune to damage or has auras breakable by damage
+        else if (!IsPreferredTarget(attacker, cvUnit)) // pussywizard: no 10%/30% if currentVictim is immune to damage or has auras breakable by damage
             currentVictim = nullptr;
     }
 
@@ -345,7 +345,7 @@ HostileReference* ThreatContainer::SelectNextVictim(Creature* attacker, HostileR
 
         // pussywizard: don't go to threat comparison if this ref is immune to damage or has aura breakable on damage (second choice target)
         // pussywizard: if this is the last entry on the threat list, then all targets are second choice, set bool to true and loop threat list again, ignoring this section
-        if (!noPriorityTargetFound && (target->IsImmunedToDamageOrSchool(attacker->GetMeleeDamageSchoolMask()) || target->HasNegativeAuraWithInterruptFlag(AURA_INTERRUPT_FLAG_TAKE_DAMAGE) || target->HasUnitState(UNIT_STATE_CONFUSED) || target->HasAuraTypeWithCaster(SPELL_AURA_IGNORED, attacker->GetGUID())))
+        if (!noPriorityTargetFound && !IsPreferredTarget(attacker, target))
         {
             if (iter != lastRef)
             {
@@ -394,6 +394,8 @@ HostileReference* ThreatContainer::SelectNextVictim(Creature* attacker, HostileR
             }
             else // pussywizard: no currentVictim, first passing all checks is chosen (highest threat, list is sorted)
             {
+                // tie-breaker if multiple targets have the same threat: select closest target
+                currentRef = SelectNextVictimTieBreaker(attacker, iter, noPriorityTargetFound);
                 found = true;
                 break;
             }
@@ -406,6 +408,69 @@ HostileReference* ThreatContainer::SelectNextVictim(Creature* attacker, HostileR
     return currentRef;
 }
 
+// Helper for Tie-breakers
+HostileReference* ThreatContainer::SelectNextVictimTieBreaker(Creature* attacker, ThreatContainer::StorageType::const_iterator currentIter, bool noPriorityTargetFound) const
+{
+    HostileReference* bestRef = *currentIter;
+    float bestThreat = bestRef->GetThreat();
+    float shortestDistSq = attacker->GetExactDistSq(bestRef->getTarget());
+
+    auto tieIter = std::next(currentIter);
+
+    while (tieIter != iThreatList.end())
+    {
+        HostileReference* nextRef = *tieIter;
+
+        if (!nextRef)
+        {
+            ++tieIter;
+            continue;
+        }
+
+        // Threatlist is sorted, so we can stop as soon as we find a lower threat
+        if (bestThreat - nextRef->GetThreat() > 0.01f)
+            break;
+
+        Unit* target = nextRef->getTarget();
+
+        if (!target)
+        {
+            ++tieIter;
+            continue;
+        }
+
+        if (attacker->CanCreatureAttack(target) && (noPriorityTargetFound || IsPreferredTarget(attacker, target)))
+        {
+            float distSq = attacker->GetExactDistSq(target);
+            if (distSq < shortestDistSq)
+            {
+                bestRef = nextRef;
+                shortestDistSq = distSq;
+            }
+        }
+        ++tieIter;
+    }
+    return bestRef;
+}
+
+// Helper for checking if a target is preferred (not immune, not confused, etc)
+bool ThreatContainer::IsPreferredTarget(Creature* attacker, Unit* target) const
+{
+    if (target->IsImmunedToDamageOrSchool(attacker->GetMeleeDamageSchoolMask()))
+        return false;
+
+    if (target->HasNegativeAuraWithInterruptFlag(AURA_INTERRUPT_FLAG_TAKE_DAMAGE))
+        return false;
+
+    if (target->HasUnitState(UNIT_STATE_CONFUSED))
+        return false;
+
+    if (target->HasAuraTypeWithCaster(SPELL_AURA_IGNORED, attacker->GetGUID()))
+        return false;
+
+    return true;
+}
+
 //============================================================
 //=================== ThreatMgr ==========================
 //============================================================

src/server/game/Combat/ThreatMgr.h

@@ -156,6 +156,10 @@ class ThreatContainer
 
     HostileReference* SelectNextVictim(Creature* attacker, HostileReference* currentVictim) const;
 
+    HostileReference* SelectNextVictimTieBreaker(Creature* attacker, ThreatContainer::StorageType::const_iterator currentIter, bool noPriorityTargetFound) const;
+
+    bool IsPreferredTarget(Creature* attacker, Unit* target) const;
+
     void setDirty(bool isDirty) { iDirty = isDirty; }
 
     [[nodiscard]] bool isDirty() const { return iDirty; }

src/server/game/Entities/Unit/Unit.cpp

@@ -2148,36 +2148,36 @@ uint32 Unit::CalcArmorReducedDamage(Unit const* attacker, Unit const* victim, co
 
 float Unit::GetEffectiveResistChance(Unit const* owner, SpellSchoolMask schoolMask, Unit const* victim)
 {
-    float victimResistance = float(victim->GetResistance(schoolMask));
+    float victimResistance = static_cast<float>(victim->GetResistance(schoolMask));
     if (owner)
     {
         // Xinef: pets inherit 100% of masters penetration
         // Xinef: excluding traps
         Player const* player = owner->GetSpellModOwner();
         if (player && owner->GetEntry() != WORLD_TRIGGER)
         {
-            victimResistance += float(player->GetTotalAuraModifierByMiscMask(SPELL_AURA_MOD_TARGET_RESISTANCE, schoolMask));
-            victimResistance -= float(player->GetSpellPenetrationItemMod());
+            victimResistance += static_cast<float>(player->GetTotalAuraModifierByMiscMask(SPELL_AURA_MOD_TARGET_RESISTANCE, schoolMask));
+            victimResistance -= static_cast<float>(player->GetSpellPenetrationItemMod());
         }
         else
-            victimResistance += float(owner->GetTotalAuraModifierByMiscMask(SPELL_AURA_MOD_TARGET_RESISTANCE, schoolMask));
+            victimResistance += static_cast<float>(owner->GetTotalAuraModifierByMiscMask(SPELL_AURA_MOD_TARGET_RESISTANCE, schoolMask));
     }
 
     victimResistance = std::max(victimResistance, 0.0f);
     if (owner)
-        victimResistance += std::max((float(victim->GetLevel()) - float(owner->GetLevel())) * 5.0f, 0.0f);
+        victimResistance += std::max(static_cast<float>(victim->GetLevel() - owner->GetLevel()) * 5.0f, 0.0f);
 
-    static uint32 const BOSS_LEVEL = 83;
-    static float const BOSS_RESISTANCE_CONSTANT = 510.0f;
-    uint32 level = victim->GetLevel();
+    float level = static_cast<float>(victim->GetLevel());
     float resistanceConstant = 0.0f;
 
-    if (level == BOSS_LEVEL)
-        resistanceConstant = BOSS_RESISTANCE_CONSTANT;
+    if (level > 60.0f)
+        resistanceConstant = 150.0f + (level - 60.0f) * (level - 67.5f);
+    else if (level > 20.0f)
+        resistanceConstant = 50.0f + (level - 20.0f) * 2.5f;
     else
-        resistanceConstant = level * 5.0f;
+        resistanceConstant = 50.0f;
 
-    return victimResistance / (victimResistance + resistanceConstant);
+    return std::min(victimResistance / (victimResistance + resistanceConstant), 0.75f);
 }
 
 void Unit::CalcAbsorbResist(DamageInfo& dmgInfo, bool Splited)

src/server/scripts/Northrend/Naxxramas/boss_gluth.cpp

@@ -255,7 +255,8 @@ class spell_gluth_decimate : public SpellScript
                 Unit::DealDamage(GetCaster(), cTarget, damage);
                 return;
             }
-            GetCaster()->CastCustomSpell(SPELL_DECIMATE_DAMAGE, SPELLVALUE_BASE_POINT0, damage, unitTarget);
+
+            GetCaster()->CastSpell(unitTarget, SPELL_DECIMATE_DAMAGE);
         }
     }
 
@@ -265,8 +266,38 @@ class spell_gluth_decimate : public SpellScript
     }
 };
 
+// 28375 - Decimate
+class spell_gluth_decimate_damage : public SpellScript
+{
+    PrepareSpellScript(spell_gluth_decimate_damage)
+
+    void RecalculateDamage()
+    {
+        Unit* target = GetHitUnit();
+        if (!target)
+            return;
+
+        int32 targetHealth = int32(target->GetHealth());
+        int32 fivePctHealth = int32(target->CountPctFromMaxHealth(5));
+
+        // Damage needed to leave the target at exactly 5%
+        int32 damage = targetHealth - fivePctHealth;
+
+        if (damage <= 0)
+            damage = 0;
+
+        SetHitDamage(damage);
+    }
+
+    void Register() override
+    {
+        OnHit += SpellHitFn(spell_gluth_decimate_damage::RecalculateDamage);
+    }
+};
+
 void AddSC_boss_gluth()
 {
     new boss_gluth();
     RegisterSpellScript(spell_gluth_decimate);
+    RegisterSpellScript(spell_gluth_decimate_damage);
 }