Scripts/Ulduar:

* Removed achievement hacks from Ignis the Furnace Master's script and scripted them properly
* Code style cleanups

1 files changed, 313 insertions, 297 deletions

diff --git a/src/server/scripts/Northrend/Ulduar/ulduar/boss_ignis.cpp b/src/server/scripts/Northrend/Ulduar/ulduar/boss_ignis.cpp
index 662f1225b74..9e2b552b6ff 100644
--- a/src/server/scripts/Northrend/Ulduar/ulduar/boss_ignis.cpp
+++ b/src/server/scripts/Northrend/Ulduar/ulduar/boss_ignis.cpp
@@ -23,71 +23,70 @@
 
 enum Yells
 {
-    SAY_AGGRO                                   = -1603220,
-    SAY_SLAY_1                                  = -1603221,
-    SAY_SLAY_2                                  = -1603222,
-    SAY_DEATH                                   = -1603223,
-    SAY_SUMMON                                  = -1603224,
-    SAY_SLAG_POT                                = -1603225,
-    SAY_SCORCH_1                                = -1603226,
-    SAY_SCORCH_2                                = -1603227,
-    SAY_BERSERK                                 = -1603228,
-    EMOTE_JETS                                  = -1603229,
+    SAY_AGGRO       = -1603220,
+    SAY_SLAY_1      = -1603221,
+    SAY_SLAY_2      = -1603222,
+    SAY_DEATH       = -1603223,
+    SAY_SUMMON      = -1603224,
+    SAY_SLAG_POT    = -1603225,
+    SAY_SCORCH_1    = -1603226,
+    SAY_SCORCH_2    = -1603227,
+    SAY_BERSERK     = -1603228,
+    EMOTE_JETS      = -1603229,
 };
 
 enum Spells
 {
-    SPELL_FLAME_JETS                         = 62680,
-    SPELL_SCORCH                             = 62546,
-    SPELL_SLAG_POT                           = 62717,
-    SPELL_SLAG_POT_DAMAGE                    = 65722,
-    SPELL_SLAG_IMBUED                        = 62836,
-    SPELL_ACTIVATE_CONSTRUCT                 = 62488,
-    SPELL_STRENGHT                           = 64473,
-    SPELL_GRAB                               = 62707,
-    SPELL_BERSERK                            = 47008
+    SPELL_FLAME_JETS            = 62680,
+    SPELL_SCORCH                = 62546,
+    SPELL_SLAG_POT              = 62717,
+    SPELL_SLAG_POT_DAMAGE       = 65722,
+    SPELL_SLAG_IMBUED           = 62836,
+    SPELL_ACTIVATE_CONSTRUCT    = 62488,
+    SPELL_STRENGHT              = 64473,
+    SPELL_GRAB                  = 62707,
+    SPELL_BERSERK               = 47008,
+
+    // Iron Construct
+    SPELL_HEAT                  = 65667,
+    SPELL_MOLTEN                = 62373,
+    SPELL_BRITTLE               = 62382,
+    SPELL_SHATTER               = 62383,
+    SPELL_GROUND                = 62548,
 };
 
 enum Events
 {
-    EVENT_NONE,
-    EVENT_JET,
-    EVENT_SCORCH,
-    EVENT_SLAG_POT,
-    EVENT_GRAB_POT,
-    EVENT_CHANGE_POT,
-    EVENT_END_POT,
-    EVENT_CONSTRUCT,
-    EVENT_BERSERK,
-    ACTION_REMOVE_BUFF = 20
+    EVENT_JET           = 1,
+    EVENT_SCORCH        = 2,
+    EVENT_SLAG_POT      = 3,
+    EVENT_GRAB_POT      = 4,
+    EVENT_CHANGE_POT    = 5,
+    EVENT_END_POT       = 6,
+    EVENT_CONSTRUCT     = 7,
+    EVENT_BERSERK       = 8,
 };
 
-enum eCreatures
+enum Actions
 {
-    NPC_IRON_CONSTRUCT                          = 33121,
-    NPC_GROUND_SCORCH                           = 33221
+    ACTION_REMOVE_BUFF = 20,
 };
 
-enum ConstructSpells
+enum Creatures
 {
-    SPELL_HEAT                                  = 65667,
-    SPELL_MOLTEN                                = 62373,
-    SPELL_BRITTLE                               = 62382,
-    SPELL_SHATTER                               = 62383,
-    SPELL_GROUND                                = 62548,
+    NPC_IRON_CONSTRUCT  = 33121,
+    NPC_GROUND_SCORCH   = 33221,
 };
 
-enum eAchievementData
+enum AchievementData
 {
-    ACHIEVEMENT_STOKIN_THE_FURNACE_10           = 2930,
-    ACHIEVEMENT_STOKIN_THE_FURNACE_25           = 2929,
-    ACHIEVEMENT_SHATTERED_10                    = 2925,
-    ACHIEVEMENT_SHATTERED_25                    = 2926,
+    DATA_SHATTERED                  = 29252926,
+    ACHIEVEMENT_IGNIS_START_EVENT   = 20951,
 };
 
-#define MAX_ENCOUNTER_TIME                    4 * 60 * 1000
+#define CONSTRUCT_SPAWN_POINTS 20
 
-const Position Pos[20] =
+Position const ConstructSpawnPosition[CONSTRUCT_SPAWN_POINTS] =
 {
     {630.366f, 216.772f, 360.891f, 3.001970f},
     {630.594f, 231.846f, 360.891f, 3.124140f},
@@ -108,320 +107,318 @@ const Position Pos[20] =
     {543.316f, 337.468f, 360.886f, 6.195920f},
     {543.280f, 239.674f, 360.890f, 6.265730f},
     {543.265f, 217.147f, 360.891f, 0.174533f},
-    {543.256f, 224.831f, 360.891f, 0.122173f}
+    {543.256f, 224.831f, 360.891f, 0.122173f},
 };
 
 class boss_ignis : public CreatureScript
 {
-public:
-    boss_ignis() : CreatureScript("boss_ignis") { }
-
-    CreatureAI* GetAI(Creature* pCreature) const
-    {
-        return GetUlduarAI<boss_ignis_AI>(pCreature);
-    }
+    public:
+        boss_ignis() : CreatureScript("boss_ignis") { }
 
-    struct boss_ignis_AI : public BossAI
-    {
-        boss_ignis_AI(Creature *pCreature) : BossAI(pCreature, BOSS_IGNIS), vehicle(me->GetVehicleKit())
+        struct boss_ignis_AI : public BossAI
         {
-            ASSERT(vehicle);
-        }
+            boss_ignis_AI(Creature* creature) : BossAI(creature, BOSS_IGNIS), _vehicle(me->GetVehicleKit())
+            {
+                ASSERT(_vehicle);
+            }
 
-        Vehicle *vehicle;
+            void Reset()
+            {
+                _Reset();
+                if (_vehicle)
+                    _vehicle->RemoveAllPassengers();
 
-        std::vector<Creature*> triggers;
+                instance->DoStopTimedAchievement(ACHIEVEMENT_TIMED_TYPE_EVENT, ACHIEVEMENT_IGNIS_START_EVENT);
+            }
 
-        bool Shattered;
-        uint64 SlagPotGUID;
-        uint32 EncounterTime;
-        uint32 ConstructTimer;
+            void EnterCombat(Unit* /*who*/)
+            {
+                _EnterCombat();
+                DoScriptText(SAY_AGGRO, me);
+                events.ScheduleEvent(EVENT_JET, 30000);
+                events.ScheduleEvent(EVENT_SCORCH, 25000);
+                events.ScheduleEvent(EVENT_SLAG_POT, 35000);
+                events.ScheduleEvent(EVENT_CONSTRUCT, 15000);
+                events.ScheduleEvent(EVENT_END_POT, 40000);
+                events.ScheduleEvent(EVENT_BERSERK, 480000);
+                _slagPotGUID = 0;
+                _shattered = false;
+                _firstConstructKill = 0;
+                instance->DoStartTimedAchievement(ACHIEVEMENT_TIMED_TYPE_EVENT, ACHIEVEMENT_IGNIS_START_EVENT);
+            }
 
-        void Reset()
-        {
-            _Reset();
-            if (vehicle)
-                vehicle->RemoveAllPassengers();
-        }
+            void JustDied(Unit* /*victim*/)
+            {
+                _JustDied();
+                DoScriptText(SAY_DEATH, me);
+            }
 
-        void EnterCombat(Unit* /*who*/)
-        {
-            _EnterCombat();
-            DoScriptText(SAY_AGGRO, me);
-            events.ScheduleEvent(EVENT_JET, 30000);
-            events.ScheduleEvent(EVENT_SCORCH, 25000);
-            events.ScheduleEvent(EVENT_SLAG_POT, 35000);
-            events.ScheduleEvent(EVENT_CONSTRUCT, 15000);
-            events.ScheduleEvent(EVENT_END_POT, 40000);
-            events.ScheduleEvent(EVENT_BERSERK, 480000);
-            SlagPotGUID = 0;
-            EncounterTime = 0;
-            ConstructTimer = 0;
-            Shattered = false;
-        }
+            uint32 GetData(uint32 type)
+            {
+                if (type == DATA_SHATTERED)
+                    return _shattered ? 1 : 0;
 
-        void JustDied(Unit* /*victim*/)
-        {
-            _JustDied();
-            DoScriptText(SAY_DEATH, me);
+                return 0;
+            }
 
-            // Achievements
-            if (instance)
+            void KilledUnit(Unit* /*victim*/)
             {
-                // Shattered
-                if (Shattered)
-                    instance->DoCompleteAchievement(RAID_MODE(ACHIEVEMENT_SHATTERED_10, ACHIEVEMENT_SHATTERED_25));
-                // Stokin' the Furnace
-                if (EncounterTime <= MAX_ENCOUNTER_TIME)
-                    instance->DoCompleteAchievement(RAID_MODE(ACHIEVEMENT_STOKIN_THE_FURNACE_10, ACHIEVEMENT_STOKIN_THE_FURNACE_25));
+                if (!urand(0, 4))
+                    DoScriptText(RAND(SAY_SLAY_1, SAY_SLAY_2), me);
             }
-        }
 
-        void UpdateAI(const uint32 diff)
-        {
-            if (!UpdateVictim())
-                return;
+            void JustSummoned(Creature* summon)
+            {
+                if (summon->GetEntry() == NPC_IRON_CONSTRUCT)
+                {
+                    summon->setFaction(16);
+                    summon->SetReactState(REACT_AGGRESSIVE);
+                    summon->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE | UNIT_FLAG_PACIFIED | UNIT_FLAG_STUNNED | UNIT_FLAG_DISABLE_MOVE);
+                }
 
-            events.Update(diff);
+                summon->AI()->AttackStart(me->getVictim());
+                summon->AI()->DoZoneInCombat();
+                summons.Summon(summon);
+            }
 
-            if (me->HasUnitState(UNIT_STAT_CASTING))
-                return;
+            void DoAction(const int32 action)
+            {
+                if (action != ACTION_REMOVE_BUFF)
+                    return;
 
-            EncounterTime += diff;
-            ConstructTimer += diff;
+                me->RemoveAuraFromStack(SPELL_STRENGHT);
+                // Shattered Achievement
+                time_t secondKill = sWorld->GetGameTime();
+                if ((secondKill - _firstConstructKill) < 5)
+                    _shattered = true;
+                _firstConstructKill = secondKill;
+            }
 
-            while(uint32 eventId = events.ExecuteEvent())
+            void UpdateAI(const uint32 diff)
             {
-                switch(eventId)
+                if (!UpdateVictim())
+                    return;
+
+                events.Update(diff);
+
+                if (me->HasUnitState(UNIT_STAT_CASTING))
+                    return;
+
+                while (uint32 eventId = events.ExecuteEvent())
                 {
-                    case EVENT_JET:
-                        me->MonsterTextEmote(EMOTE_JETS, 0, true);
-                        DoCastAOE(SPELL_FLAME_JETS);
-                        events.RescheduleEvent(EVENT_JET, urand(35000, 40000));
-                        break;
-                    case EVENT_SLAG_POT:
-                        if (Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
-                        {
-                            DoScriptText(SAY_SLAG_POT, me);
-                            SlagPotGUID = pTarget->GetGUID();
-                            DoCast(pTarget, SPELL_GRAB);
-                            events.DelayEvents(3000);
-                            events.ScheduleEvent(EVENT_GRAB_POT, 500);
-                        }
-                        events.RescheduleEvent(EVENT_SLAG_POT, RAID_MODE(30000, 15000));
-                        break;
-                    case EVENT_GRAB_POT:
-                        if (Unit* SlagPotTarget = Unit::GetUnit(*me, SlagPotGUID))
-                        {
-                            SlagPotTarget->EnterVehicle(me, 0);
-                            events.CancelEvent(EVENT_GRAB_POT);
-                            events.ScheduleEvent(EVENT_CHANGE_POT, 1000);
-                        }
-                        break;
-                    case EVENT_CHANGE_POT:
-                        if (Unit* SlagPotTarget = Unit::GetUnit(*me, SlagPotGUID))
-                        {
-                            SlagPotTarget->AddAura(SPELL_SLAG_POT, SlagPotTarget);
-                            SlagPotTarget->EnterVehicle(me, 1);
-                            events.CancelEvent(EVENT_CHANGE_POT);
-                            events.ScheduleEvent(EVENT_END_POT, 10000);
-                        }
-                        break;
-                    case EVENT_END_POT:
-                        if (Unit* SlagPotTarget = Unit::GetUnit(*me, SlagPotGUID))
-                        {
-                            SlagPotTarget->ExitVehicle();
-                            SlagPotTarget = NULL;
-                            SlagPotGUID = 0;
-                            events.CancelEvent(EVENT_END_POT);
-                        }
-                        break;
-                    case EVENT_SCORCH:
-                        DoScriptText(RAND(SAY_SCORCH_1, SAY_SCORCH_2), me);
-                        if (Unit *pTarget = me->getVictim())
-                            me->SummonCreature(NPC_GROUND_SCORCH, pTarget->GetPositionX(), pTarget->GetPositionY(), pTarget->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN, 45000);
-                        DoCast(SPELL_SCORCH);
-                        events.RescheduleEvent(EVENT_SCORCH, 25000);
-                        break;
-                    case EVENT_CONSTRUCT:
-                        DoScriptText(SAY_SUMMON, me);
-                        DoSummon(NPC_IRON_CONSTRUCT, Pos[rand()%20], 30000, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT);
-                        DoCast(SPELL_STRENGHT);
-                        DoCast(me, SPELL_ACTIVATE_CONSTRUCT);
-                        events.RescheduleEvent(EVENT_CONSTRUCT, RAID_MODE(40000, 30000));
-                        break;
-                    case EVENT_BERSERK:
-                        DoCast(me, SPELL_BERSERK, true);
-                        DoScriptText(SAY_BERSERK, me);
-                        break;
+                    switch (eventId)
+                    {
+                        case EVENT_JET:
+                            me->MonsterTextEmote(EMOTE_JETS, 0, true);
+                            DoCast(me, SPELL_FLAME_JETS);
+                            events.ScheduleEvent(EVENT_JET, urand(35000, 40000));
+                            break;
+                        case EVENT_SLAG_POT:
+                            if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
+                            {
+                                DoScriptText(SAY_SLAG_POT, me);
+                                _slagPotGUID = target->GetGUID();
+                                DoCast(target, SPELL_GRAB);
+                                events.DelayEvents(3000);
+                                events.ScheduleEvent(EVENT_GRAB_POT, 500);
+                            }
+                            events.ScheduleEvent(EVENT_SLAG_POT, RAID_MODE(30000, 15000));
+                            break;
+                        case EVENT_GRAB_POT:
+                            if (Unit* slagPotTarget = ObjectAccessor::GetUnit(*me, _slagPotGUID))
+                            {
+                                slagPotTarget->EnterVehicle(me, 0);
+                                events.CancelEvent(EVENT_GRAB_POT);
+                                events.ScheduleEvent(EVENT_CHANGE_POT, 1000);
+                            }
+                            break;
+                        case EVENT_CHANGE_POT:
+                            if (Unit* slagPotTarget = ObjectAccessor::GetUnit(*me, _slagPotGUID))
+                            {
+                                slagPotTarget->AddAura(SPELL_SLAG_POT, slagPotTarget);
+                                slagPotTarget->EnterVehicle(me, 1);
+                                events.CancelEvent(EVENT_CHANGE_POT);
+                                events.ScheduleEvent(EVENT_END_POT, 10000);
+                            }
+                            break;
+                        case EVENT_END_POT:
+                            if (Unit* slagPotTarget = ObjectAccessor::GetUnit(*me, _slagPotGUID))
+                            {
+                                slagPotTarget->ExitVehicle();
+                                slagPotTarget = NULL;
+                                _slagPotGUID = 0;
+                                events.CancelEvent(EVENT_END_POT);
+                            }
+                            break;
+                        case EVENT_SCORCH:
+                            DoScriptText(RAND(SAY_SCORCH_1, SAY_SCORCH_2), me);
+                            if (Unit* target = me->getVictim())
+                                me->SummonCreature(NPC_GROUND_SCORCH, target->GetPositionX(), target->GetPositionY(), target->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN, 45000);
+                            DoCast(SPELL_SCORCH);
+                            events.ScheduleEvent(EVENT_SCORCH, 25000);
+                            break;
+                        case EVENT_CONSTRUCT:
+                            DoScriptText(SAY_SUMMON, me);
+                            DoSummon(NPC_IRON_CONSTRUCT, ConstructSpawnPosition[urand(0, CONSTRUCT_SPAWN_POINTS - 1)], 30000, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT);
+                            DoCast(SPELL_STRENGHT);
+                            DoCast(me, SPELL_ACTIVATE_CONSTRUCT);
+                            events.ScheduleEvent(EVENT_CONSTRUCT, RAID_MODE(40000, 30000));
+                            break;
+                        case EVENT_BERSERK:
+                            DoCast(me, SPELL_BERSERK, true);
+                            DoScriptText(SAY_BERSERK, me);
+                            break;
+                    }
                 }
+
+                DoMeleeAttackIfReady();
             }
-            DoMeleeAttackIfReady();
-        }
 
-        void KilledUnit(Unit* /*victim*/)
-        {
-            if (!(rand()%5))
-                DoScriptText(RAND(SAY_SLAY_1, SAY_SLAY_2), me);
-        }
+        private:
+            uint64 _slagPotGUID;
+            Vehicle* _vehicle;
+            time_t _firstConstructKill;
+            bool _shattered;
 
-        void JustSummoned(Creature *summon)
-        {
-            if (summon->GetEntry() == NPC_IRON_CONSTRUCT)
-            {
-                summon->setFaction(16);
-                summon->SetReactState(REACT_AGGRESSIVE);
-                summon->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE | UNIT_FLAG_PACIFIED | UNIT_FLAG_STUNNED | UNIT_FLAG_DISABLE_MOVE);
-            }
-            summon->AI()->AttackStart(me->getVictim());
-            summon->AI()->DoZoneInCombat();
-            summons.Summon(summon);
-        }
+        };
 
-        void DoAction(const int32 action)
+        CreatureAI* GetAI(Creature* creature) const
         {
-            switch(action)
-            {
-                case ACTION_REMOVE_BUFF:
-                    me->RemoveAuraFromStack(SPELL_STRENGHT);
-                    // Shattered Achievement
-                    if (ConstructTimer >= 5000)
-                        ConstructTimer = 0;
-                    else
-                        Shattered = true;
-                    break;
-            }
+            return GetUlduarAI<boss_ignis_AI>(creature);
         }
-    };
 };
 
 class npc_iron_construct : public CreatureScript
 {
-public:
-    npc_iron_construct() : CreatureScript("npc_iron_construct") { }
-
-    CreatureAI *GetAI(Creature *creature) const
-    {
-        return new npc_iron_constructAI(creature);
-    }
-
-    struct npc_iron_constructAI : public ScriptedAI
-    {
-        npc_iron_constructAI(Creature* pCreature) : ScriptedAI(pCreature)
-        {
-            instance = pCreature->GetInstanceScript();
-            pCreature->SetReactState(REACT_PASSIVE);
-        }
-
-        InstanceScript* instance;
-        bool Brittled;
-
-        void Reset()
-        {
-            Brittled = false;
-        }
+    public:
+        npc_iron_construct() : CreatureScript("npc_iron_construct") { }
 
-        void DamageTaken(Unit* /*attacker*/, uint32& damage)
+        struct npc_iron_constructAI : public ScriptedAI
         {
-            if (me->HasAura(SPELL_BRITTLE) && damage >= 5000)
+            npc_iron_constructAI(Creature* creature) : ScriptedAI(creature), _instance(creature->GetInstanceScript())
             {
-                DoCast(SPELL_SHATTER);
-                if (Creature *pIgnis = me->GetCreature(*me, instance->GetData64(BOSS_IGNIS)))
-                    if (pIgnis->AI())
-                        pIgnis->AI()->DoAction(ACTION_REMOVE_BUFF);
-
-                me->DespawnOrUnsummon(1000);
+                creature->SetReactState(REACT_PASSIVE);
             }
-        }
 
-        void UpdateAI(const uint32 /*uiDiff*/)
-        {
-            if (!UpdateVictim())
-                return;
+            void Reset()
+            {
+                _brittled = false;
+            }
 
-            if (Aura * aur = me->GetAura(SPELL_HEAT))
+            void DamageTaken(Unit* /*attacker*/, uint32& damage)
             {
-                if (aur->GetStackAmount() >= 10)
+                if (me->HasAura(SPELL_BRITTLE) && damage >= 5000)
                 {
-                    me->RemoveAura(SPELL_HEAT);
-                    DoCast(SPELL_MOLTEN);
-                    Brittled = false;
+                    DoCast(SPELL_SHATTER);
+                    if (Creature* ignis = ObjectAccessor::GetCreature(*me, _instance->GetData64(BOSS_IGNIS)))
+                        if (ignis->AI())
+                            ignis->AI()->DoAction(ACTION_REMOVE_BUFF);
+
+                    me->DespawnOrUnsummon(1000);
                 }
             }
-            // Water pools
-            if (me->IsInWater() && !Brittled && me->HasAura(SPELL_MOLTEN))
+
+            void UpdateAI(const uint32 /*uiDiff*/)
             {
-                DoCast(SPELL_BRITTLE);
-                me->RemoveAura(SPELL_MOLTEN);
-                Brittled = true;
+                if (!UpdateVictim())
+                    return;
+
+                if (Aura* aur = me->GetAura(SPELL_HEAT))
+                {
+                    if (aur->GetStackAmount() >= 10)
+                    {
+                        me->RemoveAura(SPELL_HEAT);
+                        DoCast(SPELL_MOLTEN);
+                        _brittled = false;
+                    }
+                }
+
+                // Water pools
+                if (me->IsInWater() && !_brittled && me->HasAura(SPELL_MOLTEN))
+                {
+                    DoCast(SPELL_BRITTLE);
+                    me->RemoveAura(SPELL_MOLTEN);
+                    _brittled = true;
+                }
+
+                DoMeleeAttackIfReady();
             }
-            DoMeleeAttackIfReady();
-        }
-    };
-};
-class npc_scorch_ground : public CreatureScript
-{
-public:
-    npc_scorch_ground() : CreatureScript("npc_scorch_ground") { }
 
-    CreatureAI *GetAI(Creature *creature) const
-    {
-        return new npc_scorch_groundAI(creature);
-    }
+        private:
+            InstanceScript* _instance;
+            bool _brittled;
+        };
 
-    struct npc_scorch_groundAI : public ScriptedAI
-    {
-        npc_scorch_groundAI(Creature* pCreature) : ScriptedAI(pCreature)
+        CreatureAI* GetAI(Creature* creature) const
         {
-            me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_DISABLE_MOVE |UNIT_FLAG_NOT_SELECTABLE | UNIT_FLAG_PACIFIED);
-            pCreature->SetDisplayId(16925); //model 2 in db cannot overwrite wdb fields
+            return GetUlduarAI<npc_iron_constructAI>(creature);
         }
+};
 
-        uint64 ConstructGUID;
-        uint32 HeatTimer;
-        bool Heat;
+class npc_scorch_ground : public CreatureScript
+{
+    public:
+        npc_scorch_ground() : CreatureScript("npc_scorch_ground") { }
 
-        void MoveInLineOfSight(Unit* pWho)
+        struct npc_scorch_groundAI : public ScriptedAI
         {
-            if (!Heat)
+            npc_scorch_groundAI(Creature* creature) : ScriptedAI(creature)
+            {
+                me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_DISABLE_MOVE |UNIT_FLAG_NOT_SELECTABLE | UNIT_FLAG_PACIFIED);
+                creature->SetDisplayId(16925); //model 2 in db cannot overwrite wdb fields
+            }
+
+            void MoveInLineOfSight(Unit* unit)
             {
-                if (pWho->GetEntry() == NPC_IRON_CONSTRUCT)
+                if (!_heat)
                 {
-                    if (!pWho->HasAura(SPELL_HEAT) || !pWho->HasAura(SPELL_MOLTEN))
+                    if (unit->GetEntry() == NPC_IRON_CONSTRUCT)
                     {
-                        ConstructGUID = pWho->GetGUID();
-                        Heat=true;
+                        if (!unit->HasAura(SPELL_HEAT) || !unit->HasAura(SPELL_MOLTEN))
+                        {
+                            _constructGUID = unit->GetGUID();
+                            _heat = true;
+                        }
                     }
                 }
             }
-        }
 
-        void Reset()
-        {
-            Heat=false;
-            DoCast(me, SPELL_GROUND);
-            ConstructGUID=0;
-            HeatTimer=0;
-        }
+            void Reset()
+            {
+                _heat = false;
+                DoCast(me, SPELL_GROUND);
+                _constructGUID = 0;
+                _heatTimer = 0;
+            }
 
-        void UpdateAI(const uint32 uiDiff)
-        {
-            if (Heat)
+            void UpdateAI(const uint32 uiDiff)
             {
-                if(HeatTimer <= uiDiff)
+                if (_heat)
                 {
-                    Creature* Construct = me->GetCreature(*me , ConstructGUID);
-                    if (Construct && !Construct->HasAura(SPELL_MOLTEN))
+                    if(_heatTimer <= uiDiff)
                     {
-                        me->AddAura(SPELL_HEAT, Construct);
-                        HeatTimer=1000;
+                        Creature* construct = me->GetCreature(*me , _constructGUID);
+                        if (construct && !construct->HasAura(SPELL_MOLTEN))
+                        {
+                            me->AddAura(SPELL_HEAT, construct);
+                            _heatTimer = 1000;
+                        }
                     }
+                    else
+                        _heatTimer -= uiDiff;
                 }
-                else
-                    HeatTimer -= uiDiff;
             }
+
+        private:
+            uint64 _constructGUID;
+            uint32 _heatTimer;
+            bool _heat;
+        };
+
+        CreatureAI* GetAI(Creature* creature) const
+        {
+            return GetUlduarAI<npc_scorch_groundAI>(creature);
         }
-    };
 };
 
 class spell_ignis_slag_pot : public SpellScriptLoader
@@ -431,13 +428,12 @@ class spell_ignis_slag_pot : public SpellScriptLoader
 
         class spell_ignis_slag_pot_AuraScript : public AuraScript
         {
-            PrepareAuraScript(spell_ignis_slag_pot_AuraScript)
+            PrepareAuraScript(spell_ignis_slag_pot_AuraScript);
+
             bool Validate(SpellEntry const* /*spellEntry*/)
             {
                 if (!sSpellStore.LookupEntry(SPELL_SLAG_POT_DAMAGE))
                     return false;
-                if (!sSpellStore.LookupEntry(SPELL_SLAG_POT))
-                    return false;
                 if (!sSpellStore.LookupEntry(SPELL_SLAG_IMBUED))
                     return false;
                 return true;
@@ -451,13 +447,18 @@ class spell_ignis_slag_pot : public SpellScriptLoader
 
                 Unit* target = GetTarget();
                 aurEffCaster->CastSpell(target, SPELL_SLAG_POT_DAMAGE, true);
-                if (target->isAlive() && !GetDuration())
-                     target->CastSpell(target, SPELL_SLAG_IMBUED, true);
+            }
+
+            void OnRemove(AuraEffect const* aurEff, AuraEffectHandleModes /*mode*/)
+            {
+                if (GetTarget()->isAlive())
+                    GetTarget()->CastSpell(GetTarget(), SPELL_SLAG_IMBUED, true);
             }
 
             void Register()
             {
                 OnEffectPeriodic += AuraEffectPeriodicFn(spell_ignis_slag_pot_AuraScript::HandleEffectPeriodic, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY);
+                AfterEffectRemove += AuraEffectRemoveFn(spell_ignis_slag_pot_AuraScript::OnRemove, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY, AURA_EFFECT_HANDLE_REAL);
             }
         };
 
@@ -467,10 +468,25 @@ class spell_ignis_slag_pot : public SpellScriptLoader
         }
 };
 
+class achievement_ignis_shattered : public AchievementCriteriaScript
+{
+    public:
+        achievement_ignis_shattered() : AchievementCriteriaScript("achievement_ignis_shattered") { }
+
+        bool OnCheck(Player* /*source*/, Unit* target)
+        {
+            if (target && target->IsAIEnabled)
+                return target->GetAI()->GetData(DATA_SHATTERED);
+
+            return false;
+        }
+};
+
 void AddSC_boss_ignis()
 {
     new boss_ignis();
     new npc_iron_construct();
     new npc_scorch_ground();
     new spell_ignis_slag_pot();
+    new achievement_ignis_shattered();
 }