Scripts/Maraudon: Modernize scripts (#31092)

* New register model
* Codestyle changes
* TaskScheduler instead of timer variables
* Implement one spell script for Noxxion encounter

Author: offl

sql/updates/world/3.3.5/2025_07_13_00_world.sql

@@ -0,0 +1,6 @@
+--
+UPDATE `creature_template` SET `ScriptName` = 'boss_celebras_the_cursed' WHERE `entry` = 12225;
+
+DELETE FROM `spell_script_names` WHERE `ScriptName` = 'spell_noxxion_summon_spawns';
+INSERT INTO `spell_script_names` (`spell_id`, `ScriptName`) VALUES
+(21708, 'spell_noxxion_summon_spawns');

src/server/scripts/Kalimdor/Maraudon/boss_celebras_the_cursed.cpp

@@ -15,101 +15,77 @@
  * with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-/* ScriptData
-SDName: Boss_Celebras_the_Cursed
-SD%Complete: 100
-SDComment:
-SDCategory: Maraudon
-EndScriptData */
-
 #include "ScriptMgr.h"
 #include "maraudon.h"
 #include "ScriptedCreature.h"
 
-enum Spells
+enum CelebrasSpells
 {
     SPELL_WRATH                 = 21807,
-    SPELL_ENTANGLINGROOTS       = 12747,
+    SPELL_ENTANGLING_ROOTS      = 12747,
     SPELL_CORRUPT_FORCES        = 21968
 };
 
-class celebras_the_cursed : public CreatureScript
+enum CelebrasMisc
+{
+    NPC_CELEBRAS_THE_REDEEMED   = 13716
+};
+
+// 12225 - Celebras the Cursed
+struct boss_celebras_the_cursed : public ScriptedAI
 {
-public:
-    celebras_the_cursed() : CreatureScript("celebras_the_cursed") { }
+    boss_celebras_the_cursed(Creature* creature) : ScriptedAI(creature) { }
 
-    CreatureAI* GetAI(Creature* creature) const override
+    void Reset() override
     {
-        return GetMaraudonAI<celebras_the_cursedAI>(creature);
+        _scheduler.CancelAll();
     }
 
-    struct celebras_the_cursedAI : public ScriptedAI
+    void JustEngagedWith(Unit* /*who*/) override
     {
-        celebras_the_cursedAI(Creature* creature) : ScriptedAI(creature)
-        {
-            Initialize();
-        }
-
-        void Initialize()
-        {
-            WrathTimer = 8000;
-            EntanglingRootsTimer = 2000;
-            CorruptForcesTimer = 30000;
-        }
-
-        uint32 WrathTimer;
-        uint32 EntanglingRootsTimer;
-        uint32 CorruptForcesTimer;
-
-        void Reset() override
-        {
-            Initialize();
-        }
-
-        void JustEngagedWith(Unit* /*who*/) override { }
-
-        void JustDied(Unit* /*killer*/) override
-        {
-            me->SummonCreature(13716, me->GetPositionX(), me->GetPositionY(), me->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN, 10min);
-        }
-
-        void UpdateAI(uint32 diff) override
-        {
-            if (!UpdateVictim())
-                return;
-
-            //Wrath
-            if (WrathTimer <= diff)
+        _scheduler
+            .SetValidator([this]
             {
-                if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0))
-                    DoCast(target, SPELL_WRATH);
-                WrathTimer = 8000;
-            }
-            else WrathTimer -= diff;
-
-            //EntanglingRoots
-            if (EntanglingRootsTimer <= diff)
+                return !me->HasUnitState(UNIT_STATE_CASTING);
+            })
+            .Schedule(0s, 6s, [this](TaskContext task)
             {
-                DoCastVictim(SPELL_ENTANGLINGROOTS);
-                EntanglingRootsTimer = 20000;
-            }
-            else EntanglingRootsTimer -= diff;
-
-            //CorruptForces
-            if (CorruptForcesTimer <= diff)
+                DoCastVictim(SPELL_WRATH);
+                task.Repeat(4s, 8s);
+            })
+            .Schedule(0s, 5s, [this](TaskContext task)
             {
-                me->InterruptNonMeleeSpells(false);
-                DoCast(me, SPELL_CORRUPT_FORCES);
-                CorruptForcesTimer = 20000;
-            }
-            else CorruptForcesTimer -= diff;
+                DoCastVictim(SPELL_ENTANGLING_ROOTS);
+                task.Repeat(20s);
+            })
+            .Schedule(30s, [this](TaskContext task)
+            {
+                DoCastSelf(SPELL_CORRUPT_FORCES);
+                task.Repeat(20s);
+            });
+    }
+
+    void JustDied(Unit* /*killer*/) override
+    {
+        me->SummonCreature(NPC_CELEBRAS_THE_REDEEMED, me->GetPositionX(), me->GetPositionY(), me->GetPositionZ(), 0, TEMPSUMMON_MANUAL_DESPAWN);
+    }
+
+    void UpdateAI(uint32 diff) override
+    {
+        if (!UpdateVictim())
+            return;
 
+        _scheduler.Update(diff, [this]
+        {
             DoMeleeAttackIfReady();
-        }
-    };
+        });
+    }
+
+private:
+    TaskScheduler _scheduler;
 };
 
 void AddSC_boss_celebras_the_cursed()
 {
-    new celebras_the_cursed();
+    RegisterMaraudonCreatureAI(boss_celebras_the_cursed);
 }

src/server/scripts/Kalimdor/Maraudon/boss_landslide.cpp

@@ -15,100 +15,78 @@
  * with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-/* ScriptData
-SDName: Boss_Landslide
-SD%Complete: 100
-SDComment:
-SDCategory: Maraudon
-EndScriptData */
-
 #include "ScriptMgr.h"
 #include "maraudon.h"
 #include "ScriptedCreature.h"
 
-enum Spells
+enum LandslideSpells
 {
-    SPELL_KNOCKAWAY         = 18670,
+    SPELL_KNOCK_AWAY        = 18670,
     SPELL_TRAMPLE           = 5568,
     SPELL_LANDSLIDE         = 21808
 };
 
-class boss_landslide : public CreatureScript
+// 12203 - Landslide
+struct boss_landslide : public ScriptedAI
 {
-public:
-    boss_landslide() : CreatureScript("boss_landslide") { }
+    boss_landslide(Creature* creature) : ScriptedAI(creature), _landslide(false) { }
 
-    CreatureAI* GetAI(Creature* creature) const override
+    void Reset() override
     {
-        return GetMaraudonAI<boss_landslideAI>(creature);
+        _scheduler.CancelAll();
+        _landslide = false;
     }
 
-    struct boss_landslideAI : public ScriptedAI
+    void JustEngagedWith(Unit* /*who*/) override
     {
-        boss_landslideAI(Creature* creature) : ScriptedAI(creature)
-        {
-            Initialize();
-        }
+        _scheduler
+            .SetValidator([this]
+            {
+                return !me->HasUnitState(UNIT_STATE_CASTING);
+            })
+            .Schedule(5s, 10s, [this](TaskContext task)
+            {
+                DoCastVictim(SPELL_KNOCK_AWAY);
+                task.Repeat(15s, 25s);
+            })
+            .Schedule(10s, 15s, [this](TaskContext task)
+            {
+                DoCastSelf(SPELL_TRAMPLE);
+                task.Repeat(10s, 20s);
+            });
+    }
 
-        void Initialize()
+    void DamageTaken(Unit* /*attacker*/, uint32& damage, DamageEffectType /*damageType*/, SpellInfo const* /*spellInfo = nullptr*/) override
+    {
+        if (!_landslide && me->HealthBelowPctDamaged(50, damage))
         {
-            KnockAwayTimer = 8000;
-            TrampleTimer = 2000;
-            LandslideTimer = 0;
-        }
-
-        uint32 KnockAwayTimer;
-        uint32 TrampleTimer;
-        uint32 LandslideTimer;
+            _landslide = true;
 
-        void Reset() override
-        {
-            Initialize();
+            _scheduler.Schedule(0s, [this](TaskContext task)
+            {
+                DoCastSelf(SPELL_LANDSLIDE);
+                task.Repeat(30s, 40s);
+            });
         }
+    }
 
-        void JustEngagedWith(Unit* /*who*/) override
-        {
-        }
+    void UpdateAI(uint32 diff) override
+    {
+        if (!UpdateVictim())
+            return;
 
-        void UpdateAI(uint32 diff) override
+        _scheduler.Update(diff, [this]
         {
-            if (!UpdateVictim())
-                return;
-
-            //KnockAwayTimer
-            if (KnockAwayTimer <= diff)
-            {
-                DoCastVictim(SPELL_KNOCKAWAY);
-                KnockAwayTimer = 15000;
-            }
-            else KnockAwayTimer -= diff;
-
-            //TrampleTimer
-            if (TrampleTimer <= diff)
-            {
-                DoCast(me, SPELL_TRAMPLE);
-                TrampleTimer = 8000;
-            }
-            else TrampleTimer -= diff;
-
-            //Landslide
-            if (HealthBelowPct(50))
-            {
-                if (LandslideTimer <= diff)
-                {
-                    me->InterruptNonMeleeSpells(false);
-                    DoCast(me, SPELL_LANDSLIDE);
-                    LandslideTimer = 60000;
-                }
-                else LandslideTimer -= diff;
-            }
-
             DoMeleeAttackIfReady();
-        }
-    };
+        });
+    }
+
+private:
+    TaskScheduler _scheduler;
+    bool _landslide;
 };
 
 void AddSC_boss_landslide()
 {
-    new boss_landslide();
+    RegisterMaraudonCreatureAI(boss_landslide);
 }