initial commit

Scripts/Northrend/AzjolNerub/Ahnkahet/BossAmanitar.cs

@@ -0,0 +1,209 @@
+/*
+ * Copyright (C) 2012-2017 CypherCore <http://github.com/CypherCore>
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+using Framework.Constants;
+using Game.AI;
+using Game.Entities;
+using Game.Scripting;
+using System;
+
+namespace Scripts.Northrend.AzjolNerub.Ahnkahet.Amanitar
+{
+    struct SpellIds
+    {
+        public const uint Bash = 57094; // Victim
+        public const uint EntanglingRoots = 57095; // Random Victim 100y
+        public const uint Mini = 57055; // Self
+        public const uint VenomBoltVolley = 57088; // Random Victim 100y
+        public const uint HealthyMushroomPotentFungus = 56648; // Killer 3y
+        public const uint PoisonousMushroomPoisonCloud = 57061; // Self - Duration 8 Sec
+        public const uint PoisonousMushroomVisualArea = 61566; // Self
+        public const uint PoisonousMushroomVisualAura = 56741; // Self
+        public const uint PutridMushroom = 31690; // To Make The Mushrooms Visible
+        public const uint PowerMushroomVisualAura = 56740;
+    }
+
+    struct CreatureIds
+    {
+        public const uint Trigger = 19656;
+        public const uint HealthyMushroom = 30391;
+        public const uint PoisonousMushroom = 30435;
+    }
+
+    [Script]
+    class boss_amanitar : CreatureScript
+    {
+        public boss_amanitar() : base("boss_amanitar") { }
+
+        class boss_amanitarAI : BossAI
+        {
+            public boss_amanitarAI(Creature creature) : base(creature, DataTypes.Amanitar) { }
+
+            public override void Reset()
+            {
+                _Reset();
+                me.SetMeleeDamageSchool(SpellSchools.Nature);
+                me.ApplySpellImmune(0, SpellImmunity.School, SpellSchoolMask.Nature, true);
+            }
+
+            public override void EnterCombat(Unit who)
+            {
+                _EnterCombat();
+
+                _scheduler.SetValidator(() => !me.HasUnitState(UnitState.Casting));
+
+                _scheduler.Schedule(TimeSpan.FromSeconds(5), task =>
+                {
+                    SpawnAdds();
+                    task.Repeat(TimeSpan.FromSeconds(20));
+                });
+                _scheduler.Schedule(TimeSpan.FromSeconds(5), TimeSpan.FromSeconds(9), task =>
+                {
+                    DoCast(SelectTarget(SelectAggroTarget.Random, 0, 100, true), SpellIds.EntanglingRoots, true);
+                    task.Repeat(TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(15));
+                });
+                _scheduler.Schedule(TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(14), task =>
+                {
+                    DoCastVictim(SpellIds.Bash);
+                    task.Repeat(TimeSpan.FromSeconds(7), TimeSpan.FromSeconds(12));
+                });
+                _scheduler.Schedule(TimeSpan.FromSeconds(12), TimeSpan.FromSeconds(18), task =>
+                {
+                    DoCast(SpellIds.Mini);
+                    task.Repeat(TimeSpan.FromSeconds(25), TimeSpan.FromSeconds(30));
+                });
+                _scheduler.Schedule(TimeSpan.FromSeconds(15), TimeSpan.FromSeconds(20), task =>
+                {
+                    DoCast(SelectTarget(SelectAggroTarget.Random, 0, 100, true), SpellIds.VenomBoltVolley, true);
+                    task.Repeat(TimeSpan.FromSeconds(18), TimeSpan.FromSeconds(22));
+                });
+            }
+
+            public override void JustDied(Unit killer)
+            {
+                _JustDied();
+                instance.DoRemoveAurasDueToSpellOnPlayers(SpellIds.Mini);
+            }
+
+            void SpawnAdds()
+            {
+                int u = 0;
+
+                for (byte i = 0; i < 30; ++i)
+                {
+                    Position pos = me.GetRandomNearPosition(30.0f);
+                    pos.posZ = me.GetMap().GetHeight(pos.GetPositionX(), pos.GetPositionY(), MapConst.MaxHeight) + 2.0f;
+
+                    Creature trigger = me.SummonCreature(CreatureIds.Trigger, pos);
+                    if (trigger)
+                    {
+                        Creature temp1 = trigger.FindNearestCreature(CreatureIds.HealthyMushroom, 4.0f, true);
+                        Creature temp2 = trigger.FindNearestCreature(CreatureIds.PoisonousMushroom, 4.0f, true);
+                        if (temp1 || temp2)
+                        {
+                            trigger.DisappearAndDie();
+                        }
+                        else
+                        {
+                            u = 1 - u;
+                            trigger.DisappearAndDie();
+                            me.SummonCreature(u > 0 ? CreatureIds.PoisonousMushroom : CreatureIds.HealthyMushroom, pos, TempSummonType.TimedOrCorpseDespawn, 60 * Time.InMilliseconds);
+                        }
+                    }
+                }
+            }
+
+            public override void UpdateAI(uint diff)
+            {
+                if (!UpdateVictim())
+                    return;
+
+                _scheduler.Update(diff);
+
+                if (me.HasUnitState(UnitState.Casting))
+                    return;
+
+                DoMeleeAttackIfReady();
+            }
+        }
+
+        public override CreatureAI GetAI(Creature creature)
+        {
+            return GetInstanceAI<boss_amanitarAI>(creature);
+        }
+    }
+
+    [Script]
+    class npc_amanitar_mushrooms : CreatureScript
+    {
+        public npc_amanitar_mushrooms() : base("npc_amanitar_mushrooms") { }
+
+        class npc_amanitar_mushroomsAI : ScriptedAI
+        {
+            public npc_amanitar_mushroomsAI(Creature creature) : base(creature) { }
+
+            public override void Reset()
+            {
+                _scheduler.CancelAll();
+                _scheduler.SetValidator(() => !me.HasUnitState(UnitState.Casting));
+
+                _scheduler.Schedule(TimeSpan.FromSeconds(1), task =>
+                {
+                    if (me.GetEntry() == CreatureIds.PoisonousMushroom)
+                    {
+                        DoCast(me, SpellIds.PoisonousMushroomVisualArea, true);
+                        DoCast(me, SpellIds.PoisonousMushroomPoisonCloud);
+                    }
+                    task.Repeat(TimeSpan.FromSeconds(7));
+                });
+
+                me.SetDisplayId(me.GetCreatureTemplate().ModelId2);
+                DoCast(SpellIds.PutridMushroom);
+
+                if (me.GetEntry() == CreatureIds.PoisonousMushroom)
+                    DoCast(SpellIds.PoisonousMushroomVisualAura);
+                else
+                    DoCast(SpellIds.PowerMushroomVisualAura);
+            }
+
+            public override void DamageTaken(Unit attacker, ref uint damage)
+            {
+                if (damage >= me.GetHealth() && me.GetEntry() == CreatureIds.HealthyMushroom)
+                    DoCast(me, SpellIds.HealthyMushroomPotentFungus, true);
+            }
+
+            public override void EnterCombat(Unit who) { }
+            public override void AttackStart(Unit victim) { }
+
+            public override void UpdateAI(uint diff)
+            {
+                if (!UpdateVictim())
+                    return;
+
+                _scheduler.Update(diff);
+
+                if (me.HasUnitState(UnitState.Casting))
+                    return;
+            }
+        }
+
+        public override CreatureAI GetAI(Creature creature)
+        {
+            return new npc_amanitar_mushroomsAI(creature);
+        }
+    }
+}

Scripts/Northrend/AzjolNerub/Ahnkahet/BossElderNadox.cs

@@ -0,0 +1,276 @@
+/*
+ * Copyright (C) 2012-2017 CypherCore <http://github.com/CypherCore>
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+using Framework.Constants;
+using Game.AI;
+using Game.Entities;
+using Game.Scripting;
+using Game.Spells;
+using System;
+using System.Collections.Generic;
+
+
+namespace Scripts.Northrend.AzjolNerub.Ahnkahet.ElderNadox
+{
+    struct SpellIds
+    {
+        public const uint BroodPlague = 56130;
+        public const uint HBroodRage = 59465;
+        public const uint Enrage = 26662; // Enraged If Too Far Away From Home
+        public const uint SummonSwarmers = 56119; // 2x 30178  -- 2x Every 10secs
+        public const uint SummonSwarmGuard = 56120; // 1x 30176
+
+        // Adds
+        public const uint SwarmBuff = 56281;
+        public const uint Sprint = 56354;
+    }
+
+    struct TextIds
+    {
+        public const uint SayAggro = 0;
+        public const uint SaySlay = 1;
+        public const uint SayDeath = 2;
+        public const uint SayEggSac = 3;
+        public const uint EmoteHatches = 4;
+    }
+
+    struct Misc
+    {
+        public const uint DataRespectYourElders = 6;
+    }
+
+    [Script]
+    class boss_elder_nadox : CreatureScript
+    {
+        public boss_elder_nadox() : base("boss_elder_nadox") { }
+
+        class boss_elder_nadoxAI : BossAI
+        {
+            public boss_elder_nadoxAI(Creature creature) : base(creature, DataTypes.ElderNadox)
+            {
+                Initialize();
+            }
+
+            void Initialize()
+            {
+                GuardianSummoned = false;
+                GuardianDied = false;
+            }
+
+            public override void Reset()
+            {
+                _Reset();
+                Initialize();
+            }
+
+            public override void EnterCombat(Unit who)
+            {
+                _EnterCombat();
+                Talk(TextIds.SayAggro);
+
+                _scheduler.Schedule(TimeSpan.FromSeconds(13), task =>
+                {
+                    DoCast(SelectTarget(SelectAggroTarget.Random, 0, 100, true), SpellIds.BroodPlague, true);
+                    task.Repeat(TimeSpan.FromSeconds(15));
+                });
+
+                _scheduler.Schedule(TimeSpan.FromSeconds(10), task =>
+                {
+                    /// @todo: summoned by egg
+                    DoCast(me, SpellIds.SummonSwarmers);
+                    if (RandomHelper.URand(1, 3) == 3) // 33% chance of dialog
+                        Talk(TextIds.SayEggSac);
+                    task.Repeat();
+                });
+
+                if (IsHeroic())
+                {
+                    _scheduler.Schedule(TimeSpan.FromSeconds(12), task =>
+                    {
+                        DoCast(SpellIds.HBroodRage);
+                        task.Repeat(TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(50));
+                    });
+
+                    _scheduler.Schedule(TimeSpan.FromSeconds(5), task =>
+                    {
+                        if (me.HasAura(SpellIds.Enrage))
+                            return;
+                        if (me.GetPositionZ() < 24.0f)
+                            DoCast(me, SpellIds.Enrage, true);
+                        task.Repeat();
+                    });
+                }
+            }
+
+            public override void SummonedCreatureDies(Creature summon, Unit killer)
+            {
+                if (summon.GetEntry() == AKCreatureIds.AhnkaharGuardian)
+                    GuardianDied = true;
+            }
+
+            public override uint GetData(uint type)
+            {
+                if (type == Misc.DataRespectYourElders)
+                    return !GuardianDied ? 1 : 0u;
+
+                return 0;
+            }
+
+            public override void KilledUnit(Unit who)
+            {
+                if (who.IsTypeId(TypeId.Player))
+                    Talk(TextIds.SaySlay);
+            }
+
+            public override void JustDied(Unit killer)
+            {
+                _JustDied();
+                Talk(TextIds.SayDeath);
+            }
+
+            public override void UpdateAI(uint diff)
+            {
+                if (!UpdateVictim())
+                    return;
+
+                _scheduler.Update(diff);
+
+                if (!GuardianSummoned && me.HealthBelowPct(50))
+                {
+                    /// @todo: summoned by egg
+                    Talk(TextIds.EmoteHatches, me);
+                    DoCast(me, SpellIds.SummonSwarmGuard);
+                    GuardianSummoned = true;
+                }
+
+                DoMeleeAttackIfReady();
+            }
+
+            bool GuardianSummoned;
+            bool GuardianDied;
+        }
+
+        public override CreatureAI GetAI(Creature creature)
+        {
+            return GetInstanceAI<boss_elder_nadoxAI>(creature, "instance_ahnkahet");
+        }
+    }
+
+    [Script]
+    class npc_ahnkahar_nerubian : CreatureScript
+    {
+        public npc_ahnkahar_nerubian() : base("npc_ahnkahar_nerubian") { }
+
+        class npc_ahnkahar_nerubianAI : ScriptedAI
+        {
+            public npc_ahnkahar_nerubianAI(Creature creature) : base(creature) { }
+
+            public override void Reset()
+            {
+                _scheduler.CancelAll();
+                _scheduler.Schedule(TimeSpan.FromSeconds(13), task =>
+                {
+                    DoCast(me, SpellIds.Sprint);
+                    task.Repeat(TimeSpan.FromSeconds(20));
+                });
+            }
+
+            public override void UpdateAI(uint diff)
+            {
+                if (!UpdateVictim())
+                    return;
+
+                if (me.HasUnitState(UnitState.Casting))
+                    return;
+
+                _scheduler.Update(diff);
+
+                DoMeleeAttackIfReady();
+            }
+        }
+
+        public override CreatureAI GetAI(Creature creature)
+        {
+            return new npc_ahnkahar_nerubianAI(creature);
+        }
+    }
+
+    // 56159 - Swarm
+    [Script]
+    class spell_ahn_kahet_swarm : SpellScriptLoader
+    {
+        public spell_ahn_kahet_swarm() : base("spell_ahn_kahet_swarm") { }
+
+        class spell_ahn_kahet_swarm_SpellScript : SpellScript
+        {
+            public spell_ahn_kahet_swarm_SpellScript()
+            {
+                _targetCount = 0;
+            }
+
+            public override bool Validate(SpellInfo spellInfo)
+            {
+                return ValidateSpellInfo(SpellIds.SwarmBuff);
+            }
+
+            void CountTargets(List<WorldObject> targets)
+            {
+                _targetCount = targets.Count;
+            }
+
+            void HandleDummy(uint effIndex)
+            {
+                if (_targetCount != 0)
+                { Aura aura = GetCaster().GetAura(SpellIds.SwarmBuff);
+                    if (aura != null)
+                    {
+                        aura.SetStackAmount((byte)_targetCount);
+                        aura.RefreshDuration();
+                    }
+                    else
+                        GetCaster().CastCustomSpell(SpellIds.SwarmBuff, SpellValueMod.AuraStack, _targetCount, GetCaster(), TriggerCastFlags.FullMask);
+                }
+                else
+                    GetCaster().RemoveAurasDueToSpell(SpellIds.SwarmBuff);
+            }
+
+            public override void Register()
+            {
+                OnObjectAreaTargetSelect.Add(new ObjectAreaTargetSelectHandler(CountTargets, 0, Targets.UnitSrcAreaAlly));
+                OnEffectHit.Add(new EffectHandler(HandleDummy, 0, SpellEffectName.Dummy));
+            }
+
+            int _targetCount;
+        }
+
+        public override SpellScript GetSpellScript()
+        {
+            return new spell_ahn_kahet_swarm_SpellScript();
+        }
+    }
+
+    [Script]
+    class achievement_respect_your_elders : AchievementCriteriaScript
+    {
+        public achievement_respect_your_elders() : base("achievement_respect_your_elders") { }
+
+        public override bool OnCheck(Player player, Unit target)
+        {
+            return target && target.GetAI().GetData(Misc.DataRespectYourElders) != 0;
+        }
+    }
+}

Scripts/Northrend/AzjolNerub/Ahnkahet/BossHeraldVolazj.cs

@@ -0,0 +1,295 @@
+/*
+ * Copyright (C) 2012-2017 CypherCore <http://github.com/CypherCore>
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+using Framework.Constants;
+using Game.AI;
+using Game.Entities;
+using Game.Maps;
+using Game.Scripting;
+using Game.Spells;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Scripts.Northrend.AzjolNerub.Ahnkahet.HeraldVolazj
+{
+    struct SpellIds
+    {
+        public const uint Insanity = 57496; //Dummy
+        public const uint InsanityVisual = 57561;
+        public const uint InsanityTarget = 57508;
+        public const uint MindFlay = 57941;
+        public const uint ShadowBoltVolley = 57942;
+        public const uint Shiver = 57949;
+        public const uint ClonePlayer = 57507; //Cast On Player During Insanity
+        public const uint InsanityPhasing1 = 57508;
+        public const uint InsanityPhasing2 = 57509;
+        public const uint InsanityPhasing3 = 57510;
+        public const uint InsanityPhasing4 = 57511;
+        public const uint InsanityPhasing5 = 57512;
+    }
+
+    struct TextIds
+    {
+        public const uint SayAggro = 0;
+        public const uint SaySlay = 1;
+        public const uint SayDeath = 2;
+        public const uint SayPhase = 3;
+    }
+
+    struct Misc
+    {
+        public const uint AchievQuickDemiseStartEvent = 20382;
+    }
+
+    [Script]
+    class boss_volazj : CreatureScript
+    {
+        public boss_volazj() : base("boss_volazj") { }
+
+        class boss_volazjAI : ScriptedAI
+        {
+            public boss_volazjAI(Creature creature) : base(creature)
+            {
+                Summons = new SummonList(me);
+
+                Initialize();
+                instance = creature.GetInstanceScript();
+            }
+
+            void Initialize()
+            {
+                uiMindFlayTimer = 8 * Time.InMilliseconds;
+                uiShadowBoltVolleyTimer = 5 * Time.InMilliseconds;
+                uiShiverTimer = 15 * Time.InMilliseconds;
+                // Used for Insanity handling
+                insanityHandled = 0;
+            }
+
+            // returns the percentage of health after taking the given damage.
+            uint GetHealthPct(uint damage)
+            {
+                if (damage > me.GetHealth())
+                    return 0;
+                return (uint)(100 * (me.GetHealth() - damage) / me.GetMaxHealth());
+            }
+
+            public override void DamageTaken(Unit pAttacker, ref uint damage)
+            {
+                if (me.HasFlag(UnitFields.Flags, UnitFlags.NotSelectable))
+                    damage = 0;
+
+                if ((GetHealthPct(0) >= 66 && GetHealthPct(damage) < 66) ||
+                    (GetHealthPct(0) >= 33 && GetHealthPct(damage) < 33))
+                {
+                    me.InterruptNonMeleeSpells(false);
+                    DoCast(me, SpellIds.Insanity, false);
+                }
+            }
+
+            public override void SpellHitTarget(Unit target, SpellInfo spell)
+            {
+                if (spell.Id == SpellIds.Insanity)
+                {
+                    // Not good target or too many players
+                    if (target.GetTypeId() != TypeId.Player || insanityHandled > 4)
+                        return;
+                    // First target - start channel visual and set self as unnattackable
+                    if (insanityHandled == 0)
+                    {
+                        // Channel visual
+                        DoCast(me, SpellIds.InsanityVisual, true);
+                        // Unattackable
+                        me.SetFlag(UnitFields.Flags, UnitFlags.NotSelectable);
+                        me.SetControlled(true, UnitState.Stunned);
+                    }
+
+                    // phase the player
+                    target.CastSpell(target, SpellIds.InsanityTarget + insanityHandled, true);
+
+                    SpellInfo spellInfo = Global.SpellMgr.GetSpellInfo(SpellIds.InsanityTarget + insanityHandled);
+                    if (spellInfo == null)
+                        return;
+
+                    // summon twisted party members for this target
+                    var players = me.GetMap().GetPlayers();
+                    foreach (var player in players)
+                    {
+                        if (!player || !player.IsAlive())
+                            continue;
+                        // Summon clone
+                        Unit summon = me.SummonCreature(AKCreatureIds.TwistedVisage, me.GetPositionX(), me.GetPositionY(), me.GetPositionZ(), me.GetOrientation(), TempSummonType.CorpseDespawn, 0);
+                        if (summon)
+                        {
+                            // clone
+                            player.CastSpell(summon, SpellIds.ClonePlayer, true);
+                            // phase the summon
+                            summon.SetInPhase((uint)spellInfo.GetEffect(0).MiscValueB, true, true);
+                        }
+                    }
+                    ++insanityHandled;
+                }
+            }
+
+            void ResetPlayersPhase()
+            {
+                var players = me.GetMap().GetPlayers();
+                foreach (var player in players)
+                {
+                    for (uint index = 0; index <= 4; ++index)
+                        player.RemoveAurasDueToSpell(SpellIds.InsanityTarget + index);
+                }
+            }
+
+            public override void Reset()
+            {
+                Initialize();
+
+                instance.SetBossState(DataTypes.HeraldVolazj, EncounterState.NotStarted);
+                instance.DoStopCriteriaTimer(CriteriaTimedTypes.Event, Misc.AchievQuickDemiseStartEvent);
+
+                // Visible for all players in insanity
+                me.SetInPhase(169, true, true);
+                for (uint i = 173; i <= 177; ++i)
+                    me.SetInPhase(i, true, true);
+
+                ResetPlayersPhase();
+
+                // Cleanup
+                Summons.DespawnAll();
+                me.RemoveFlag(UnitFields.Flags, UnitFlags.NotSelectable);
+                me.SetControlled(false, UnitState.Stunned);
+            }
+
+            public override void EnterCombat(Unit who)
+            {
+                Talk(TextIds.SayAggro);
+
+                instance.SetBossState(DataTypes.HeraldVolazj, EncounterState.InProgress);
+                instance.DoStartCriteriaTimer(CriteriaTimedTypes.Event, Misc.AchievQuickDemiseStartEvent);
+            }
+
+            public override void JustSummoned(Creature summon)
+            {
+                Summons.Summon(summon);
+            }
+
+            public override void SummonedCreatureDespawn(Creature summon)
+            {
+                uint nextPhase = 0;
+                Summons.Despawn(summon);
+
+                // Check if all summons in this phase killed
+                foreach (var guid in Summons)
+                {
+                    Creature visage = ObjectAccessor.GetCreature(me, guid);
+                    if (visage)
+                    {
+                        // Not all are dead
+                        if (visage.IsInPhase(summon))
+                            return;
+                        else
+                        {
+                            nextPhase = visage.GetPhases().First();
+                            break;
+                        }
+                    }
+                }
+
+                // Roll Insanity
+                var players = me.GetMap().GetPlayers();
+                foreach (var player in players)
+                {
+                    if (player)
+                    {
+                        for (uint index = 0; index <= 4; ++index)
+                            player.RemoveAurasDueToSpell(SpellIds.InsanityTarget + index);
+                        player.CastSpell(player, SpellIds.InsanityTarget + nextPhase - 173, true);
+                    }
+                }
+            }
+
+            public override void UpdateAI(uint diff)
+            {
+                //Return since we have no target
+                if (!UpdateVictim())
+                    return;
+
+                if (insanityHandled != 0)
+                {
+                    if (!Summons.Empty())
+                        return;
+
+                    insanityHandled = 0;
+                    me.RemoveFlag(UnitFields.Flags, UnitFlags.NotSelectable);
+                    me.SetControlled(false, UnitState.Stunned);
+                    me.RemoveAurasDueToSpell(SpellIds.InsanityVisual);
+                }
+
+                if (uiMindFlayTimer <= diff)
+                {
+                    DoCastVictim(SpellIds.MindFlay);
+                    uiMindFlayTimer = 20 * Time.InMilliseconds;
+                } else uiMindFlayTimer -= diff;
+
+                if (uiShadowBoltVolleyTimer <= diff)
+                {
+                    DoCastVictim(SpellIds.ShadowBoltVolley);
+                    uiShadowBoltVolleyTimer = 5 * Time.InMilliseconds;
+                } else uiShadowBoltVolleyTimer -= diff;
+
+                if (uiShiverTimer <= diff)
+                {
+                    Unit target = SelectTarget(SelectAggroTarget.Random, 0);
+                    if (target)
+                        DoCast(target, SpellIds.Shiver);
+                    uiShiverTimer = 15 * Time.InMilliseconds;
+                } else uiShiverTimer -= diff;
+
+                DoMeleeAttackIfReady();
+            }
+
+            public override void JustDied(Unit killer)
+            {
+                Talk(TextIds.SayDeath);
+
+                instance.SetBossState(DataTypes.HeraldVolazj, EncounterState.Done);
+
+                Summons.DespawnAll();
+                ResetPlayersPhase();
+            }
+
+            public override void KilledUnit(Unit who)
+            {
+                if (who.IsTypeId(TypeId.Player))
+                    Talk(TextIds.SaySlay);
+            }
+
+            InstanceScript instance;
+
+            uint uiMindFlayTimer;
+            uint uiShadowBoltVolleyTimer;
+            uint uiShiverTimer;
+            uint insanityHandled;
+            SummonList Summons;
+        }
+
+        public override CreatureAI GetAI(Creature creature)
+        {
+            return GetInstanceAI<boss_volazjAI>(creature);
+        }
+    }
+}

Scripts/Northrend/AzjolNerub/Ahnkahet/BossJedogaShadowseeker.cs

@@ -0,0 +1,602 @@
+/*
+ * Copyright (C) 2012-2017 CypherCore <http://github.com/CypherCore>
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+using Framework.Constants;
+using Game.AI;
+using Game.Entities;
+using Game.Maps;
+using Game.Scripting;
+
+namespace Scripts.Northrend.AzjolNerub.Ahnkahet.JedogaShadowseeker
+{
+    struct SpellIds
+    {
+        public const uint SphereVisual = 56075;
+        public const uint GiftOfTheHerald = 56219;
+        public const uint CycloneStrike = 56855; // Self
+        public const uint LightningBolt = 56891; // 40y
+        public const uint Thundershock = 56926;  // 30y
+
+        public const uint RandomLightningVisual = 56327;
+        public const uint SacrificeBeam = 56150;
+        public const uint SacrificeVisual = 56133;
+    }
+
+    struct TextIds
+    {
+        public const uint SayAggro = 0;
+        public const uint SaySacrifice1 = 1;
+        public const uint SaySacrifice2 = 2;
+        public const uint SaySlay = 3;
+        public const uint SayDeath = 4;
+        public const uint SayPreaching = 5;
+    }
+    struct Misc
+    {
+        public const int ActionInitiateKilled = 1;
+        public const uint DataVolunteerWork = 2;
+
+        public static Position[] JedogaPosition =
+        {
+            new Position(372.330994f, -705.278015f, -0.624178f,  5.427970f),
+            new Position(372.330994f, -705.278015f, -16.179716f, 5.427970f)
+        };
+    }
+
+    [Script]
+    class boss_jedoga_shadowseeker : CreatureScript
+    {
+        public boss_jedoga_shadowseeker() : base("boss_jedoga_shadowseeker") { }
+
+        public class boss_jedoga_shadowseekerAI : ScriptedAI
+        {
+            public boss_jedoga_shadowseekerAI(Creature creature) : base(creature)
+            {
+                instance = creature.GetInstanceScript();
+                bFirstTime = true;
+                bPreDone = false;
+            }
+
+            void Initialize()
+            {
+                uiOpFerTimer = RandomHelper.URand(15 * Time.InMilliseconds, 20 * Time.InMilliseconds);
+
+                uiCycloneTimer = 3 * Time.InMilliseconds;
+                uiBoltTimer = 7 * Time.InMilliseconds;
+                uiThunderTimer = 12 * Time.InMilliseconds;
+
+                bOpFerok = false;
+                bOpFerokFail = false;
+                bOnGround = false;
+                bCanDown = false;
+                volunteerWork = true;
+            }
+
+            public override void Reset()
+            {
+                Initialize();
+
+                DoCast(SpellIds.RandomLightningVisual);
+
+                if (!bFirstTime)
+                    instance.SetBossState(DataTypes.JedogaShadowseeker, EncounterState.Fail);
+
+                instance.SetGuidData(DataTypes.PlJedogaTarget, ObjectGuid.Empty);
+                instance.SetGuidData(DataTypes.AddJedogaVictim, ObjectGuid.Empty);
+                instance.SetData(DataTypes.JedogaResetInitiands, 0);
+                MoveUp();
+
+                bFirstTime = false;
+            }
+
+            public override void EnterCombat(Unit who)
+            {
+                if (instance == null || (who.GetTypeId() == TypeId.Unit && who.GetEntry() == AKCreatureIds.JedogaController))
+                    return;
+
+                Talk(TextIds.SayAggro);
+                me.SetInCombatWithZone();
+                instance.SetBossState(DataTypes.JedogaShadowseeker, EncounterState.InProgress);
+            }
+
+            public override void AttackStart(Unit who)
+            {
+                if (!who || (who.GetTypeId() == TypeId.Unit && who.GetEntry() == AKCreatureIds.JedogaController))
+                    return;
+
+                base.AttackStart(who);
+            }
+
+            public override void KilledUnit(Unit Victim)
+            {
+                if (!Victim || !Victim.IsTypeId(TypeId.Player))
+                    return;
+
+                Talk(TextIds.SaySlay);
+            }
+
+            public override void JustDied(Unit killer)
+            {
+                Talk(TextIds.SayDeath);
+                instance.SetBossState(DataTypes.JedogaShadowseeker, EncounterState.Done);
+            }
+
+            public override void DoAction(int action)
+            {
+                if (action == Misc.ActionInitiateKilled)
+                    volunteerWork = false;
+            }
+
+            public override uint GetData(uint type)
+            {
+                if (type == Misc.DataVolunteerWork)
+                    return volunteerWork ? 1 : 0u;
+
+                return 0;
+            }
+
+            public override void MoveInLineOfSight(Unit who)
+            {
+                if (instance == null || !who || (who.IsTypeId(TypeId.Unit) && who.GetEntry() == AKCreatureIds.JedogaController))
+                    return;
+
+                if (!bPreDone && who.IsTypeId(TypeId.Player) && me.GetDistance(who) < 100.0f)
+                {
+                    Talk(TextIds.SayPreaching);
+                    bPreDone = true;
+                }
+
+                if (instance.GetBossState(DataTypes.JedogaShadowseeker) != EncounterState.InProgress || !bOnGround)
+                    return;
+
+                if (!me.GetVictim() && me.CanCreatureAttack(who))
+                {
+                    float attackRadius = me.GetAttackDistance(who);
+                    if (me.IsWithinDistInMap(who, attackRadius) && me.IsWithinLOSInMap(who))
+                    {
+                        if (!me.GetVictim())
+                        {
+                            who.RemoveAurasByType(AuraType.ModStealth);
+                            AttackStart(who);
+                        }
+                        else
+                        {
+                            who.SetInCombatWith(me);
+                            me.AddThreat(who, 0.0f);
+                        }
+                    }
+                }
+            }
+
+            void MoveDown()
+            {
+                bOpFerokFail = false;
+
+                instance.SetData(DataTypes.JedogaTriggerSwitch, 0);
+                me.GetMotionMaster().MovePoint(1, Misc.JedogaPosition[1]);
+                me.ApplySpellImmune(0, SpellImmunity.Damage, SpellSchoolMask.Normal, false);
+                me.ApplySpellImmune(0, SpellImmunity.Damage, SpellSchoolMask.Magic, false);
+                me.RemoveFlag(UnitFields.Flags, UnitFlags.NotSelectable | UnitFlags.NonAttackable);
+
+                me.RemoveAurasDueToSpell(SpellIds.SphereVisual);
+
+                bOnGround = true;
+
+                if (UpdateVictim())
+                {
+                    AttackStart(me.GetVictim());
+                    me.GetMotionMaster().MoveChase(me.GetVictim());
+                }
+                else
+                {
+                    Unit target = Global.ObjAccessor.GetUnit(me, instance.GetGuidData(DataTypes.PlJedogaTarget));
+                    if (target)
+                    {
+                        AttackStart(target);
+                        instance.SetData(DataTypes.JedogaResetInitiands, 0);
+                        if (instance.GetBossState(DataTypes.JedogaShadowseeker) != EncounterState.InProgress)
+                            EnterCombat(target);
+                    }
+                    else if (!me.IsInCombat())
+                        EnterEvadeMode();
+                }
+            }
+
+            void MoveUp()
+            {
+                me.ApplySpellImmune(0, SpellImmunity.Damage, SpellSchoolMask.Normal, true);
+                me.ApplySpellImmune(0, SpellImmunity.Damage, SpellSchoolMask.Magic, true);
+                me.SetFlag(UnitFields.Flags, UnitFlags.NotSelectable | UnitFlags.NonAttackable);
+
+                me.AttackStop();
+                me.RemoveAllAuras();
+                me.LoadCreaturesAddon();
+                me.GetMotionMaster().MovePoint(0, Misc.JedogaPosition[0]);
+
+                instance.SetData(DataTypes.JedogaTriggerSwitch, 1);
+                if (instance.GetBossState(DataTypes.JedogaShadowseeker) == EncounterState.InProgress)
+                    GetVictimForSacrifice();
+
+                bOnGround = false;
+                uiOpFerTimer = RandomHelper.URand(15 * Time.InMilliseconds, 30 * Time.InMilliseconds);
+            }
+
+            void GetVictimForSacrifice()
+            {
+                ObjectGuid victim = instance.GetGuidData(DataTypes.AddJedogaInitiand);
+                if (!victim.IsEmpty())
+                {
+                    Talk(TextIds.SaySacrifice1);
+                    instance.SetGuidData(DataTypes.AddJedogaVictim, victim);
+                }
+                else
+                    bCanDown = true;
+            }
+
+            void Sacrifice()
+            {
+                Talk(TextIds.SaySacrifice2);
+
+                me.InterruptNonMeleeSpells(false);
+                DoCast(me, SpellIds.GiftOfTheHerald, false);
+
+                bOpFerok = false;
+                bCanDown = true;
+            }
+
+            public override void UpdateAI(uint diff)
+            {
+                if (instance.GetBossState(DataTypes.JedogaShadowseeker) != EncounterState.InProgress && instance.GetData(DataTypes.AllInitiandDead) != 0)
+                    MoveDown();
+
+                if (bOpFerok && !bOnGround && !bCanDown)
+                    Sacrifice();
+
+                if (bOpFerokFail && !bOnGround && !bCanDown)
+                    bCanDown = true;
+
+                if (bCanDown)
+                {
+                    MoveDown();
+                    bCanDown = false;
+                }
+
+                if (bOnGround)
+                {
+                    if (!UpdateVictim())
+                        return;
+
+                    if (uiCycloneTimer <= diff)
+                    {
+                        DoCast(me, SpellIds.CycloneStrike, false);
+                        uiCycloneTimer = RandomHelper.URand(15 * Time.InMilliseconds, 30 * Time.InMilliseconds);
+                    }
+                    else uiCycloneTimer -= diff;
+
+                    if (uiBoltTimer <= diff)
+                    {
+                        Unit target = SelectTarget(SelectAggroTarget.Random, 0, 100, true);
+                        if (target)
+                            me.CastSpell(target, SpellIds.LightningBolt, false);
+
+                        uiBoltTimer = RandomHelper.URand(15 * Time.InMilliseconds, 30 * Time.InMilliseconds);
+                    }
+                    else uiBoltTimer -= diff;
+
+                    if (uiThunderTimer <= diff)
+                    {
+                        Unit target = SelectTarget(SelectAggroTarget.Random, 0, 100, true);
+                        if (target)
+                            me.CastSpell(target, SpellIds.Thundershock, false);
+
+                        uiThunderTimer = RandomHelper.URand(15 * Time.InMilliseconds, 30 * Time.InMilliseconds);
+                    }
+                    else uiThunderTimer -= diff;
+
+                    if (uiOpFerTimer <= diff)
+                        MoveUp();
+                    else
+                        uiOpFerTimer -= diff;
+
+                    DoMeleeAttackIfReady();
+                }
+            }
+
+            InstanceScript instance;
+
+            uint uiOpFerTimer;
+            uint uiCycloneTimer;
+            uint uiBoltTimer;
+            uint uiThunderTimer;
+
+            bool bPreDone;
+            public bool bOpFerok;
+            bool bOnGround;
+            public bool bOpFerokFail;
+            bool bCanDown;
+            bool volunteerWork;
+            bool bFirstTime;
+        }
+
+        public override CreatureAI GetAI(Creature creature)
+        {
+            return GetInstanceAI<boss_jedoga_shadowseekerAI>(creature);
+        }
+    }
+
+    [Script]
+    class npc_jedoga_twilight_volunteer : CreatureScript
+    {
+        public npc_jedoga_twilight_volunteer() : base("npc_jedoga_initiand") { }
+
+        class npc_jedoga_twilight_volunteerAI : ScriptedAI
+        {
+            public npc_jedoga_twilight_volunteerAI(Creature creature) : base(creature)
+            {
+                Initialize();
+                instance = creature.GetInstanceScript();
+            }
+
+            void Initialize()
+            {
+                bWalking = false;
+                bCheckTimer = 2 * Time.InMilliseconds;
+            }
+
+            public override void Reset()
+            {
+                Initialize();
+
+                if (instance.GetBossState(DataTypes.JedogaShadowseeker) != EncounterState.InProgress)
+                {
+                    me.RemoveAurasDueToSpell(SpellIds.SphereVisual);
+                    me.ApplySpellImmune(0, SpellImmunity.Damage, SpellSchoolMask.Normal, false);
+                    me.ApplySpellImmune(0, SpellImmunity.Damage, SpellSchoolMask.Magic, false);
+                    me.RemoveFlag(UnitFields.Flags, UnitFlags.NotSelectable | UnitFlags.NonAttackable);
+                }
+                else
+                {
+                    DoCast(me, SpellIds.SphereVisual, false);
+                    me.ApplySpellImmune(0, SpellImmunity.Damage, SpellSchoolMask.Normal, true);
+                    me.ApplySpellImmune(0, SpellImmunity.Damage, SpellSchoolMask.Magic, true);
+                    me.SetFlag(UnitFields.Flags, UnitFlags.NotSelectable | UnitFlags.NonAttackable);
+                }
+            }
+
+            public override void JustDied(Unit killer)
+            {
+                if (!killer || instance == null)
+                    return;
+
+                if (bWalking)
+                {
+                    Creature boss = ObjectAccessor.GetCreature(me, instance.GetGuidData(DataTypes.JedogaShadowseeker));
+                    if (boss)
+                    {
+                        if (!boss.GetAI<boss_jedoga_shadowseeker.boss_jedoga_shadowseekerAI>().bOpFerok)
+                            boss.GetAI<boss_jedoga_shadowseeker.boss_jedoga_shadowseekerAI>().bOpFerokFail = true;
+
+                        if (killer.IsTypeId(TypeId.Player))
+                            boss.GetAI().DoAction(Misc.ActionInitiateKilled);
+                    }
+
+                    instance.SetGuidData(DataTypes.AddJedogaVictim, ObjectGuid.Empty);
+
+                    bWalking = false;
+                }
+                if (killer.IsTypeId(TypeId.Player))
+                    instance.SetGuidData(DataTypes.PlJedogaTarget, killer.GetGUID());
+            }
+
+            public override void EnterCombat(Unit who) { }
+
+            public override void AttackStart(Unit victim)
+            {
+                if ((instance.GetBossState(DataTypes.JedogaShadowseeker) == EncounterState.InProgress) || !victim)
+                    return;
+
+                base.AttackStart(victim);
+            }
+
+            public override void MoveInLineOfSight(Unit who)
+            {
+                if ((instance.GetBossState(DataTypes.JedogaShadowseeker) == EncounterState.InProgress) || !who)
+                    return;
+
+                base.MoveInLineOfSight(who);
+            }
+
+            public override void MovementInform(MovementGeneratorType uiType, uint uiPointId)
+            {
+                if (uiType != MovementGeneratorType.Point || instance == null)
+                    return;
+
+                switch (uiPointId)
+                {
+                    case 1:
+                        {
+                            Creature boss = me.GetMap().GetCreature(instance.GetGuidData(DataTypes.JedogaShadowseeker));
+                            if (boss)
+                            {
+                                boss.GetAI<boss_jedoga_shadowseeker.boss_jedoga_shadowseekerAI>().bOpFerok = true;
+                                boss.GetAI<boss_jedoga_shadowseeker.boss_jedoga_shadowseekerAI>().bOpFerokFail = false;
+                                me.KillSelf();
+                            }
+                        }
+                        break;
+                }
+            }
+
+            public override void UpdateAI(uint diff)
+            {
+                if (bCheckTimer <= diff)
+                {
+                    if (me.GetGUID() == instance.GetGuidData(DataTypes.AddJedogaVictim) && !bWalking)
+                    {
+                        me.RemoveAurasDueToSpell(SpellIds.SphereVisual);
+                        me.ApplySpellImmune(0, SpellImmunity.Damage, SpellSchoolMask.Normal, false);
+                        me.ApplySpellImmune(0, SpellImmunity.Damage, SpellSchoolMask.Magic, false);
+                        me.RemoveFlag(UnitFields.Flags, UnitFlags.NotSelectable | UnitFlags.NonAttackable);
+
+                        float distance = me.GetDistance(Misc.JedogaPosition[1]);
+
+                        if (distance < 9.0f)
+                            me.SetSpeedRate(UnitMoveType.Walk, 0.5f);
+                        else if (distance < 15.0f)
+                            me.SetSpeedRate(UnitMoveType.Walk, 0.75f);
+                        else if (distance < 20.0f)
+                            me.SetSpeedRate(UnitMoveType.Walk, 1.0f);
+
+                        me.GetMotionMaster().Clear(false);
+                        me.GetMotionMaster().MovePoint(1, Misc.JedogaPosition[1]);
+                        bWalking = true;
+                    }
+                    if (!bWalking)
+                    {
+                        if (instance.GetBossState(DataTypes.JedogaShadowseeker) != EncounterState.InProgress && me.HasAura(SpellIds.SphereVisual))
+                        {
+                            me.RemoveAurasDueToSpell(SpellIds.SphereVisual);
+                            me.ApplySpellImmune(0, SpellImmunity.Damage, SpellSchoolMask.Normal, false);
+                            me.ApplySpellImmune(0, SpellImmunity.Damage, SpellSchoolMask.Magic, false);
+                            me.RemoveFlag(UnitFields.Flags, UnitFlags.NotSelectable | UnitFlags.NonAttackable);
+                        }
+                        if (instance.GetBossState(DataTypes.JedogaShadowseeker) == EncounterState.InProgress && !me.HasAura(SpellIds.SphereVisual))
+                        {
+                            DoCast(me, SpellIds.SphereVisual, false);
+                            me.ApplySpellImmune(0, SpellImmunity.Damage, SpellSchoolMask.Normal, true);
+                            me.ApplySpellImmune(0, SpellImmunity.Damage, SpellSchoolMask.Magic, true);
+                            me.SetFlag(UnitFields.Flags, UnitFlags.NotSelectable | UnitFlags.NonAttackable);
+                        }
+                    }
+                    bCheckTimer = 2 * Time.InMilliseconds;
+                }
+                else bCheckTimer -= diff;
+
+                //Return since we have no target
+                if (!UpdateVictim())
+                    return;
+
+                DoMeleeAttackIfReady();
+            }
+
+            InstanceScript instance;
+
+            uint bCheckTimer;
+            bool bWalking;
+        }
+
+        public override CreatureAI GetAI(Creature creature)
+        {
+            return GetInstanceAI<npc_jedoga_twilight_volunteerAI>(creature);
+        }
+    }
+
+    [Script]
+    class npc_jedoga_controller : CreatureScript
+    {
+        public npc_jedoga_controller() : base("npc_jedogas_aufseher_trigger") { }
+
+        class npc_jedoga_controllerAI : ScriptedAI
+        {
+            public npc_jedoga_controllerAI(Creature creature) : base(creature)
+            {
+                instance = creature.GetInstanceScript();
+                bRemoved = false;
+                bRemoved2 = false;
+                bCast = false;
+                bCast2 = false;
+
+                SetCombatMovement(false);
+            }
+
+            public override void Reset() { }
+
+            public override void EnterCombat(Unit who) { }
+
+            public override void AttackStart(Unit victim) { }
+
+            public override void MoveInLineOfSight(Unit who) { }
+
+            public override void UpdateAI(uint diff)
+            {
+                if (!bRemoved && me.GetPositionX() > 440.0f)
+                {
+                    if (instance.GetBossState(DataTypes.PrinceTaldaram) == EncounterState.Done)
+                    {
+                        me.InterruptNonMeleeSpells(true);
+                        bRemoved = true;
+                        return;
+                    }
+                    if (!bCast)
+                    {
+                        //DoCast(me, JedogaShadowseekerConst.SpellBeamVisualJedogasAufseher1, false);
+                        bCast = true;
+                    }
+                }
+                if (!bRemoved2 && me.GetPositionX() < 440.0f)
+                {
+                    if (!bCast2 && instance.GetData(DataTypes.JedogaTriggerSwitch) != 0)
+                    {
+                        //DoCast(me, JedogaShadowseekerConst.SpellBeamVisualJedogasAufseher2, false);
+                        bCast2 = true;
+                    }
+                    if (bCast2 && instance.GetData(DataTypes.JedogaTriggerSwitch) == 0)
+                    {
+                        me.InterruptNonMeleeSpells(true);
+                        bCast2 = false;
+                    }
+                    if (!bRemoved2 && instance.GetBossState(DataTypes.JedogaShadowseeker) == EncounterState.Done)
+                    {
+                        me.InterruptNonMeleeSpells(true);
+                        bRemoved2 = true;
+                    }
+                }
+            }
+
+            InstanceScript instance;
+
+            bool bRemoved;
+            bool bRemoved2;
+            bool bCast;
+            bool bCast2;
+        }
+
+        public override CreatureAI GetAI(Creature creature)
+        {
+            return GetInstanceAI<npc_jedoga_controllerAI>(creature);
+        }
+    }
+
+    [Script]
+    class achievement_volunteer_work : AchievementCriteriaScript
+    {
+        public achievement_volunteer_work() : base("achievement_volunteer_work") { }
+
+        public override bool OnCheck(Player player, Unit target)
+        {
+            if (!target)
+                return false;
+
+            Creature Jedoga = target.ToCreature();
+            if (Jedoga)
+                if (Jedoga.GetAI().GetData(Misc.DataVolunteerWork) != 0)
+                    return true;
+
+            return false;
+        }
+    }
+}

Scripts/Northrend/AzjolNerub/Ahnkahet/BossPrinceTaldaram.cs

@@ -0,0 +1,476 @@
+/*
+ * Copyright (C) 2012-2017 CypherCore <http://github.com/CypherCore>
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+using Framework.Constants;
+using Game.AI;
+using Game.Entities;
+using Game.Maps;
+using Game.Scripting;
+using Game.Spells;
+using System;
+
+namespace Scripts.Northrend.AzjolNerub.Ahnkahet.PrinceTaldaram
+{
+    struct SpellIds
+    {
+        public const uint Bloodthirst = 55968; // Trigger Spell + Add Aura
+        public const uint ConjureFlameSphere = 55931;
+        public const uint FlameSphereSummon1 = 55895; // 1x 30106
+        public const uint FlameSphereSummon2 = 59511; // 1x 31686
+        public const uint FlameSphereSummon3 = 59512; // 1x 31687
+        public const uint FlameSphereSpawnEffect = 55891;
+        public const uint FlameSphereVisual = 55928;
+        public const uint FlameSpherePeriodic = 55926;
+        public const uint FlameSphereDeathEffect = 55947;
+        public const uint EmbraceOfTheVampyr = 55959;
+        public const uint Vanish = 55964;
+
+        public const uint BeamVisual = 60342;
+        public const uint HoverFall = 60425;
+    }
+
+    struct CreatureIds
+    {
+        public const uint FlameSphere1 = 30106;
+        public const uint FlameSphere2 = 31686;
+        public const uint FlameSphere3 = 31687;
+    }
+
+    struct TextIds
+    {
+        public const uint Say1 = 0;
+        public const uint SayWarning = 1;
+        public const uint SayAggro = 2;
+        public const uint SaySlay = 3;
+        public const uint SayDeath = 4;
+        public const uint SayFeed = 5;
+        public const uint SayVanish = 6;
+    }
+
+    struct Misc
+    {
+        public const uint EventConjureFlameSpheres = 1;
+        public const uint EventBloodthirst = 2;
+        public const uint EventVanish = 3;
+        public const uint EventJustVanished = 4;
+        public const uint EventVanished = 5;
+        public const uint EventFeeding = 6;
+
+        // Flame Sphere
+        public const uint EventStartMove = 7;
+        public const uint EventDespawn = 8;
+
+        public const uint DataEmbraceDmg = 20000;
+        public const uint DataEmbraceDmgH = 40000;
+        public const float DataSphereDistance = 25.0f;
+        public const float DataSphereAngleOffset = MathFunctions.PI / 2;
+        public const float DataGroundPositionZ = 11.30809f;
+    }
+
+    [Script]
+    class boss_prince_taldaram : CreatureScript
+    {
+        public boss_prince_taldaram() : base("boss_prince_taldaram") { }
+
+        public class boss_prince_taldaramAI : BossAI
+        {
+            public boss_prince_taldaramAI(Creature creature) : base(creature, DataTypes.PrinceTaldaram)
+            {
+                me.SetDisableGravity(true);
+                _embraceTakenDamage = 0;
+            }
+
+            public override void Reset()
+            {
+                _Reset();
+                _flameSphereTargetGUID.Clear();
+                _embraceTargetGUID.Clear();
+                _embraceTakenDamage = 0;
+            }
+
+            public override void EnterCombat(Unit who)
+            {
+                _EnterCombat();
+                Talk(TextIds.SayAggro);
+                _events.ScheduleEvent(Misc.EventBloodthirst, 10000);
+                _events.ScheduleEvent(Misc.EventVanish, RandomHelper.URand(25000, 35000));
+                _events.ScheduleEvent(Misc.EventConjureFlameSpheres, 5000);
+            }
+
+            public override void JustSummoned(Creature summon)
+            {
+                base.JustSummoned(summon);
+
+                switch (summon.GetEntry())
+                {
+                    case CreatureIds.FlameSphere1:
+                    case CreatureIds.FlameSphere2:
+                    case CreatureIds.FlameSphere3:
+                        summon.GetAI().SetGUID(_flameSphereTargetGUID);
+                        break;
+                }
+            }
+
+            public override void UpdateAI(uint diff)
+            {
+                if (!UpdateVictim())
+                    return;
+
+                _events.Update(diff);
+
+                if (me.HasUnitState(UnitState.Casting))
+                    return;
+
+                _events.ExecuteEvents(eventId =>
+                {
+                    switch (eventId)
+                    {
+                        case Misc.EventBloodthirst:
+                            DoCast(me, SpellIds.Bloodthirst);
+                            _events.ScheduleEvent(Misc.EventBloodthirst, 10000);
+                            break;
+                        case Misc.EventConjureFlameSpheres:
+                            // random target?
+                            Unit victim = me.GetVictim();
+                            if (victim)
+                            {
+                                _flameSphereTargetGUID = victim.GetGUID();
+                                DoCast(victim, SpellIds.ConjureFlameSphere);
+                            }
+                            _events.ScheduleEvent(Misc.EventConjureFlameSpheres, 15000);
+                            break;
+                        case Misc.EventVanish:
+                            {
+                                var players = me.GetMap().GetPlayers();
+                                uint targets = 0;
+                                foreach (var player in players)
+                                {
+                                    if (player && player.IsAlive())
+                                        ++targets;
+                                }
+
+                                if (targets > 2)
+                                {
+                                    Talk(TextIds.SayVanish);
+                                    DoCast(me, SpellIds.Vanish);
+                                    me.SetInCombatState(true); // Prevents the boss from resetting
+                                    _events.DelayEvents(500);
+                                    _events.ScheduleEvent(Misc.EventJustVanished, 500);
+                                    Unit embraceTarget = SelectTarget(SelectAggroTarget.Random, 0, 100.0f, true);
+                                    if (embraceTarget)
+                                        _embraceTargetGUID = embraceTarget.GetGUID();
+                                }
+                                _events.ScheduleEvent(Misc.EventVanish, RandomHelper.URand(25000, 35000));
+                                break;
+                            }
+                        case Misc.EventJustVanished:
+                            {
+                                Unit embraceTarget = GetEmbraceTarget();
+                                if (embraceTarget)
+                                {
+                                    me.GetMotionMaster().Clear();
+                                    me.SetSpeedRate(UnitMoveType.Walk, 2.0f);
+                                    me.GetMotionMaster().MoveChase(embraceTarget);
+                                }
+                                _events.ScheduleEvent(Misc.EventVanished, 1300);
+                            }
+                            break;
+                        case Misc.EventVanished:
+                            {
+                                Unit embraceTarget = GetEmbraceTarget();
+                                if (embraceTarget)
+                                    DoCast(embraceTarget, SpellIds.EmbraceOfTheVampyr);
+                                Talk(TextIds.SayFeed);
+                                me.GetMotionMaster().Clear();
+                                me.SetSpeedRate(UnitMoveType.Walk, 1.0f);
+                                me.GetMotionMaster().MoveChase(me.GetVictim());
+                                _events.ScheduleEvent(Misc.EventFeeding, 20000);
+                            }
+                            break;
+                        case Misc.EventFeeding:
+                            _embraceTargetGUID.Clear();
+                            break;
+                        default:
+                            break;
+                    }
+                });
+
+                DoMeleeAttackIfReady();
+            }
+
+            public override void DamageTaken(Unit doneBy, ref uint damage)
+            {
+                Unit embraceTarget = GetEmbraceTarget();
+
+                if (embraceTarget && embraceTarget.IsAlive())
+                {
+                    _embraceTakenDamage += damage;
+                    if (_embraceTakenDamage > DungeonMode<uint>(Misc.DataEmbraceDmg, Misc.DataEmbraceDmgH))
+                    {
+                        _embraceTargetGUID.Clear();
+                        me.CastStop();
+                    }
+                }
+            }
+
+            public override void JustDied(Unit killer)
+            {
+                Talk(TextIds.SayDeath);
+                _JustDied();
+            }
+
+            public override void KilledUnit(Unit victim)
+            {
+                if (!victim.IsTypeId(TypeId.Player))
+                    return;
+
+                if (victim.GetGUID() == _embraceTargetGUID)
+                    _embraceTargetGUID.Clear();
+
+                Talk(TextIds.SaySlay);
+            }
+
+            public bool CheckSpheres()
+            {
+                for (byte i = 0; i < 2; ++i)
+                {
+                    if (instance.GetData(DataTypes.Sphere1 + i) == 0)
+                        return false;
+                }
+
+                RemovePrison();
+                return true;
+            }
+
+            Unit GetEmbraceTarget()
+            {
+                if (!_embraceTargetGUID.IsEmpty())
+                    return Global.ObjAccessor.GetUnit(me, _embraceTargetGUID);
+
+                return null;
+            }
+
+            void RemovePrison()
+            {
+                me.RemoveFlag(UnitFields.Flags, UnitFlags.NotSelectable);
+                me.RemoveAurasDueToSpell(SpellIds.BeamVisual);
+                me.SetHomePosition(me.GetPositionX(), me.GetPositionY(), Misc.DataGroundPositionZ, me.GetOrientation());
+                DoCast(SpellIds.HoverFall);
+                me.SetDisableGravity(false);
+                me.GetMotionMaster().MoveLand(0, me.GetHomePosition());
+                Talk(TextIds.SayWarning);
+                instance.HandleGameObject(instance.GetGuidData(DataTypes.PrinceTaldaramPlatform), true);
+            }
+
+            ObjectGuid _flameSphereTargetGUID;
+            ObjectGuid _embraceTargetGUID;
+            uint _embraceTakenDamage;
+        }
+
+        public override CreatureAI GetAI(Creature creature)
+        {
+            return GetInstanceAI<boss_prince_taldaramAI>(creature);
+        }
+    }
+    
+    [Script] // 30106, 31686, 31687 - Flame Sphere
+    class npc_prince_taldaram_flame_sphere : CreatureScript
+    {
+        public npc_prince_taldaram_flame_sphere() : base("npc_prince_taldaram_flame_sphere") { }
+
+        class npc_prince_taldaram_flame_sphereAI : ScriptedAI
+        {
+            public npc_prince_taldaram_flame_sphereAI(Creature creature) : base(creature)
+            {
+            }
+
+            public override void Reset()
+            {
+                DoCast(me, SpellIds.FlameSphereSpawnEffect, true);
+                DoCast(me, SpellIds.FlameSphereVisual, true);
+
+                _flameSphereTargetGUID.Clear();
+                _events.Reset();
+                _events.ScheduleEvent(Misc.EventStartMove, 3 * Time.InMilliseconds);
+                _events.ScheduleEvent(Misc.EventDespawn, 13 * Time.InMilliseconds);
+            }
+
+            public override void SetGUID(ObjectGuid guid, int id = 0)
+            {
+                _flameSphereTargetGUID = guid;
+            }
+
+            public override void EnterCombat(Unit who) { }
+
+            public override void MoveInLineOfSight(Unit who) { }
+
+            public override void UpdateAI(uint diff)
+            {
+                _events.Update(diff);
+
+                _events.ExecuteEvents(eventId =>
+                {
+                    switch (eventId)
+                    {
+                        case Misc.EventStartMove:
+                            {
+                                DoCast(me, SpellIds.FlameSpherePeriodic, true);
+
+                                /// @todo: find correct values
+                                float angleOffset = 0.0f;
+                                float distOffset = Misc.DataSphereDistance;
+
+                                switch (me.GetEntry())
+                                {
+                                    case CreatureIds.FlameSphere1:
+                                        break;
+                                    case CreatureIds.FlameSphere2:
+                                        angleOffset = Misc.DataSphereAngleOffset;
+                                        break;
+                                    case CreatureIds.FlameSphere3:
+                                        angleOffset = -Misc.DataSphereAngleOffset;
+                                        break;
+                                    default:
+                                        return;
+                                }
+
+                                Unit sphereTarget = Global.ObjAccessor.GetUnit(me, _flameSphereTargetGUID);
+                                if (!sphereTarget)
+                                    return;
+
+                                float angle = me.GetAngle(sphereTarget) + angleOffset;
+                                float x = me.GetPositionX() + distOffset * (float)Math.Cos(angle);
+                                float y = me.GetPositionY() + distOffset * (float)Math.Sin(angle);
+
+                                /// @todo: correct speed
+                                me.GetMotionMaster().MovePoint(0, x, y, me.GetPositionZ());
+                                break;
+                            }
+                        case Misc.EventDespawn:
+                            DoCast(me, SpellIds.FlameSphereDeathEffect, true);
+                            me.DespawnOrUnsummon(1000);
+                            break;
+                        default:
+                            break;
+                    }
+                });
+            }
+
+            ObjectGuid _flameSphereTargetGUID;
+        }
+
+        public override CreatureAI GetAI(Creature creature)
+        {
+            return new npc_prince_taldaram_flame_sphereAI(creature);
+        }
+    }
+    
+    [Script] // 193093, 193094 - Ancient Nerubian Device
+    class go_prince_taldaram_sphere : GameObjectScript
+    {
+        public go_prince_taldaram_sphere() : base("go_prince_taldaram_sphere") { }
+
+        public override bool OnGossipHello(Player player, GameObject go)
+        {
+            InstanceScript instance = go.GetInstanceScript();
+            if (instance == null)
+                return false;
+
+            Creature PrinceTaldaram = ObjectAccessor.GetCreature(go, instance.GetGuidData(DataTypes.PrinceTaldaram));
+            if (PrinceTaldaram && PrinceTaldaram.IsAlive())
+            {
+                go.SetFlag(GameObjectFields.Flags, GameObjectFlags.NotSelectable);
+                go.SetGoState(GameObjectState.Active);
+
+                switch (go.GetEntry())
+                {
+                    case GameObjectIds.Sphere1:
+                        instance.SetData(DataTypes.Sphere1, (uint)EncounterState.InProgress);
+                        PrinceTaldaram.GetAI().Talk(TextIds.Say1);
+                        break;
+                    case GameObjectIds.Sphere2:
+                        instance.SetData(DataTypes.Sphere2, (uint)EncounterState.InProgress);
+                        PrinceTaldaram.GetAI().Talk(TextIds.Say1);
+                        break;
+                }
+
+                PrinceTaldaram.GetAI<boss_prince_taldaram.boss_prince_taldaramAI>().CheckSpheres();
+            }
+            return true;
+        }
+    }
+    
+    [Script] // 55931 - Conjure Flame Sphere
+    class spell_prince_taldaram_conjure_flame_sphere : SpellScriptLoader
+    {
+        public spell_prince_taldaram_conjure_flame_sphere() : base("spell_prince_taldaram_conjure_flame_sphere") { }
+
+        class spell_prince_taldaram_conjure_flame_sphere_SpellScript : SpellScript
+        {
+            public override bool Validate(SpellInfo spellInfo)
+            {
+                return ValidateSpellInfo(SpellIds.FlameSphereSummon1, SpellIds.FlameSphereSummon2, SpellIds.FlameSphereSummon3);
+            }
+
+            void HandleScript(uint effIndex)
+            {
+                Unit caster = GetCaster();
+                caster.CastSpell(caster, SpellIds.FlameSphereSummon1, true);
+
+                if (caster.GetMap().IsHeroic())
+                {
+                    caster.CastSpell(caster, SpellIds.FlameSphereSummon2, true);
+                    caster.CastSpell(caster, SpellIds.FlameSphereSummon3, true);
+                }
+            }
+
+            public override void Register()
+            {
+                OnEffectHitTarget.Add(new EffectHandler(HandleScript, 0, SpellEffectName.Dummy));
+            }
+        }
+
+        public override SpellScript GetSpellScript()
+        {
+            return new spell_prince_taldaram_conjure_flame_sphere_SpellScript();
+        }
+    }
+    
+    [Script] // 55895, 59511, 59512 - Flame Sphere Summon
+    class spell_prince_taldaram_flame_sphere_summon : SpellScriptLoader
+    {
+        public spell_prince_taldaram_flame_sphere_summon() : base("spell_prince_taldaram_flame_sphere_summon") { }
+
+        class spell_prince_taldaram_flame_sphere_summon_SpellScript : SpellScript
+        {
+            void SetDest(ref SpellDestination dest)
+            {
+                dest.RelocateOffset(new Position(0.0f, 0.0f, 5.5f, 0.0f));
+            }
+
+            public override void Register()
+            {
+                OnDestinationTargetSelect.Add(new DestinationTargetSelectHandler(SetDest, 0, Targets.DestCaster));
+            }
+        }
+
+        public override SpellScript GetSpellScript()
+        {
+            return new spell_prince_taldaram_flame_sphere_summon_SpellScript();
+        }
+    }
+}

Scripts/Northrend/AzjolNerub/Ahnkahet/InstanceAhnahet.cs

@@ -0,0 +1,334 @@
+/*
+ * Copyright (C) 2012-2017 CypherCore <http://github.com/CypherCore>
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+using Framework.Constants;
+using Game.Entities;
+using Game.Maps;
+using Game.Scripting;
+using System.Collections.Generic;
+
+namespace Scripts.Northrend.AzjolNerub.Ahnkahet
+{
+    [Script]
+    class instance_ahnkahet : InstanceMapScript
+    {
+        public instance_ahnkahet() : base("instance_ahnkahet", 619) { }
+
+        class instance_ahnkahet_InstanceScript : InstanceScript
+        {
+            public instance_ahnkahet_InstanceScript(Map map) : base(map)
+            {
+                SetHeaders("AK");
+                SetBossNumber(DataTypes.HeraldVolazj + 1);
+                LoadDoorData(new DoorData(GameObjectIds.PrinceTaldaramGate, DataTypes.PrinceTaldaram, DoorType.Passage));
+
+                SwitchTrigger = 0;
+
+                SpheresState[0] = 0;
+                SpheresState[1] = 0;
+            }
+
+            public override void OnCreatureCreate(Creature creature)
+            {
+                switch (creature.GetEntry())
+                {
+                    case AKCreatureIds.ElderNadox:
+                        ElderNadoxGUID = creature.GetGUID();
+                        break;
+                    case AKCreatureIds.PrinceTaldaram:
+                        PrinceTaldaramGUID = creature.GetGUID();
+                        break;
+                    case AKCreatureIds.JedogaShadowseeker:
+                        JedogaShadowseekerGUID = creature.GetGUID();
+                        break;
+                    case AKCreatureIds.Amanitar:
+                        AmanitarGUID = creature.GetGUID();
+                        break;
+                    case AKCreatureIds.HeraldVolazj:
+                        HeraldVolazjGUID = creature.GetGUID();
+                        break;
+                    case AKCreatureIds.Initiand:
+                        InitiandGUIDs.Add(creature.GetGUID());
+                        break;
+                    default:
+                        break;
+                }
+            }
+
+            public override void OnGameObjectCreate(GameObject go)
+            {
+                switch (go.GetEntry())
+                {
+                    case GameObjectIds.PrinceTaldaramPlatform:
+                        PrinceTaldaramPlatformGUID = go.GetGUID();
+                        if (GetBossState(DataTypes.PrinceTaldaram) == EncounterState.Done)
+                            HandleGameObject(ObjectGuid.Empty, true, go);
+                        break;
+                    case GameObjectIds.Sphere1:
+                        if (SpheresState[0] != 0)
+                        {
+                            go.SetGoState(GameObjectState.Active);
+                            go.SetFlag(GameObjectFields.Flags, GameObjectFlags.NotSelectable);
+                        }
+                        else
+                            go.RemoveFlag(GameObjectFields.Flags, GameObjectFlags.NotSelectable);
+                        break;
+                    case GameObjectIds.Sphere2:
+                        if (SpheresState[1] != 0)
+                        {
+                            go.SetGoState(GameObjectState.Active);
+                            go.SetFlag(GameObjectFields.Flags, GameObjectFlags.NotSelectable);
+                        }
+                        else
+                            go.RemoveFlag(GameObjectFields.Flags, GameObjectFlags.NotSelectable);
+                        break;
+                    case GameObjectIds.PrinceTaldaramGate:
+                        AddDoor(go, true);
+                        break;
+                    default:
+                        break;
+                }
+            }
+
+            public override void OnGameObjectRemove(GameObject go)
+            {
+                switch (go.GetEntry())
+                {
+                    case GameObjectIds.PrinceTaldaramGate:
+                        AddDoor(go, false);
+                        break;
+                    default:
+                        break;
+                }
+            }
+
+            public override void SetData(uint type, uint data)
+            {
+                switch (type)
+                {
+                    case DataTypes.Sphere1:
+                    case DataTypes.Sphere2:
+                        SpheresState[type - DataTypes.Sphere1] = data;
+                        break;
+                    case DataTypes.JedogaTriggerSwitch:
+                        SwitchTrigger = (byte)data;
+                        break;
+                    case DataTypes.JedogaResetInitiands:
+                        foreach (ObjectGuid guid in InitiandGUIDs)
+                        {
+                            Creature creature = instance.GetCreature(guid);
+                            if (creature)
+                            {
+                                creature.Respawn();
+                                if (!creature.IsInEvadeMode())
+                                    creature.GetAI().EnterEvadeMode();
+                            }
+                        }
+                        break;
+                    default:
+                        break;
+                }
+            }
+
+            public override uint GetData(uint type)
+            {
+                switch (type)
+                {
+                    case DataTypes.Sphere1:
+                    case DataTypes.Sphere2:
+                        return SpheresState[type - DataTypes.Sphere1];
+                        case DataTypes.AllInitiandDead:
+                        foreach (ObjectGuid guid in InitiandGUIDs)
+                        {
+                            Creature cr = instance.GetCreature(guid);
+                            if (!cr || cr.IsAlive())
+                                return 0;
+                        }
+                        return 1;
+                    case DataTypes.JedogaTriggerSwitch:
+                        return SwitchTrigger;
+                    default:
+                        break;
+                }
+                return 0;
+            }
+
+            public override void SetGuidData(uint type, ObjectGuid data)
+            {
+                switch (type)
+                {
+                    case DataTypes.AddJedogaVictim:
+                        JedogaSacrifices = data;
+                        break;
+                    case DataTypes.PlJedogaTarget:
+                        JedogaTarget = data;
+                        break;
+                    default:
+                        break;
+                }
+            }
+
+            public override ObjectGuid GetGuidData(uint type)
+            {
+                switch (type)
+                {
+                    case DataTypes.ElderNadox:
+                        return ElderNadoxGUID;
+                    case DataTypes.PrinceTaldaram:
+                        return PrinceTaldaramGUID;
+                    case DataTypes.JedogaShadowseeker:
+                        return JedogaShadowseekerGUID;
+                    case DataTypes.Amanitar:
+                        return AmanitarGUID;
+                    case DataTypes.HeraldVolazj:
+                        return HeraldVolazjGUID;
+                    case DataTypes.PrinceTaldaramPlatform:
+                        return PrinceTaldaramPlatformGUID;
+                    case DataTypes.AddJedogaInitiand:
+                        {
+                            List<ObjectGuid> vInitiands = new List<ObjectGuid>();
+                            foreach (ObjectGuid guid in InitiandGUIDs)
+                            {
+                                Creature cr = instance.GetCreature(guid);
+                                if (cr && cr.IsAlive())
+                                    vInitiands.Add(guid);
+                            }
+                            if (vInitiands.Empty())
+                                return ObjectGuid.Empty;
+
+                            return vInitiands.PickRandom();
+                        }
+                    case DataTypes.AddJedogaVictim:
+                        return JedogaSacrifices;
+                    case DataTypes.PlJedogaTarget:
+                        return JedogaTarget;
+                    default:
+                        break;
+                }
+                return ObjectGuid.Empty;
+            }
+
+            public override bool SetBossState(uint type, EncounterState state)
+            {
+                if (!base.SetBossState(type, state))
+                    return false;
+
+                switch (type)
+                {
+                    case DataTypes.JedogaShadowseeker:
+                        if (state == EncounterState.Done)
+                        {
+                            foreach (ObjectGuid guid in InitiandGUIDs)
+                            {
+                                Creature cr = instance.GetCreature(guid);
+                                if (cr)
+                                    cr.DespawnOrUnsummon();
+                            }
+                        }
+                        break;
+                    default:
+                        break;
+                }
+                return true;
+            }
+
+            void WriteSaveDataMore(string data)
+            {
+                data += SpheresState[0] + ' ' + SpheresState[1];
+            }
+
+            void ReadSaveDataMore(string data)
+            {
+                data += SpheresState[0];
+                data += SpheresState[1];
+            }
+
+            ObjectGuid ElderNadoxGUID;
+            ObjectGuid PrinceTaldaramGUID;
+            ObjectGuid JedogaShadowseekerGUID;
+            ObjectGuid AmanitarGUID;
+            ObjectGuid HeraldVolazjGUID;
+
+            ObjectGuid PrinceTaldaramPlatformGUID;
+            ObjectGuid JedogaSacrifices;
+            ObjectGuid JedogaTarget;
+
+            List<ObjectGuid> InitiandGUIDs = new List<ObjectGuid>();
+
+            uint[] SpheresState = new uint[2];
+            byte SwitchTrigger;
+        }
+
+        public override InstanceScript GetInstanceScript(InstanceMap map)
+        {
+            return new instance_ahnkahet_InstanceScript(map);
+        }
+    }
+
+    struct DataTypes
+    {
+        // Encounter States/Boss GUIDs
+        public const uint ElderNadox = 0;
+        public const uint PrinceTaldaram = 1;
+        public const uint JedogaShadowseeker = 2;
+        public const uint Amanitar = 3;
+        public const uint HeraldVolazj = 4;
+
+        // Additional Data
+        public const uint Sphere1 = 5;
+        public const uint Sphere2 = 6;
+        public const uint PrinceTaldaramPlatform = 7;
+        public const uint PlJedogaTarget = 8;
+        public const uint AddJedogaVictim = 9;
+        public const uint AddJedogaInitiand = 10;
+        public const uint JedogaTriggerSwitch = 11;
+        public const uint JedogaResetInitiands = 12;
+        public const uint AllInitiandDead = 13;
+    }
+
+    struct AKCreatureIds
+    {
+        public const uint ElderNadox = 29309;
+        public const uint PrinceTaldaram = 29308;
+        public const uint JedogaShadowseeker = 29310;
+        public const uint Amanitar = 30258;
+        public const uint HeraldVolazj = 29311;
+
+        // Elder Nadox
+        public const uint AhnkaharGuardian = 30176;
+        public const uint AhnkaharSwarmer = 30178;
+
+        // Jedoga Shadowseeker
+        public const uint Initiand = 30114;
+        public const uint JedogaController = 30181;
+
+        // Herald Volazj
+        //public const uint TwistedVisage1          = 30621,
+        //public const uint TwistedVisage2          = 30622,
+        //public const uint TwistedVisage3          = 30623,
+        //public const uint TwistedVisage4          = 30624,
+        public const uint TwistedVisage = 30625;
+    }
+
+    struct GameObjectIds
+    {
+        public const uint PrinceTaldaramGate = 192236;
+        public const uint PrinceTaldaramPlatform = 193564;
+        public const uint Sphere1 = 193093;
+        public const uint Sphere2 = 193094;
+    }
+}

Scripts/Northrend/AzjolNerub/AzjolNerub/BossAnubarak.cs

@@ -0,0 +1,722 @@
+/*
+ * Copyright (C) 2012-2017 CypherCore <http://github.com/CypherCore>
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+using Framework.Constants;
+using Game.AI;
+using Game.Entities;
+using Game.Maps;
+using Game.Scripting;
+using Game.Spells;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Scripts.Northrend.AzjolNerub.AzjolNerub.Anubarak
+{
+    struct SpellIds
+    {
+        public const uint Emerge = 53500;
+        public const uint Submerge = 53421;
+        public const uint ImpaleAura = 53456;
+        public const uint ImpaleVisual = 53455;
+        public const uint ImpaleDamage = 53454;
+        public const uint LeechingSwarm = 53467;
+        public const uint Pound = 59433;
+        public const uint PoundDamage = 59432;
+        public const uint CarrionBeetles = 53520;
+        public const uint CarrionBeetle = 53521;
+
+        public const uint SummonDarter = 53599;
+        public const uint SummonAssassin = 53609;
+        public const uint SummonGuardian = 53614;
+        public const uint SummonVenomancer = 53615;
+
+        public const uint Dart = 59349;
+        public const uint Backstab = 52540;
+        public const uint AssassinVisual = 53611;
+        public const uint SunderArmor = 53618;
+        public const uint PoisonBolt = 53617;
+    }
+
+    struct CreatureIds
+    {
+         public const uint WorldTrigger = 22515;
+    }
+
+    struct TextIds
+    {
+        public const uint SayAggro = 0;
+        public const uint SaySlay = 1;
+        public const uint SayDeath = 2;
+        public const uint SayLocust = 3;
+        public const uint SaySubmerge = 4;
+        public const uint SayIntro = 5;
+    }
+
+    struct EventIds
+    {
+        public const uint Pound = 1;
+        public const uint Impale = 2;
+        public const uint LeechingSwarm = 3;
+        public const uint CarrionBeetles = 4;
+        public const uint Submerge = 5; // Use Event For This So We Don'T Submerge Mid-Cast
+        public const uint Darter = 6;
+        public const uint Assassin = 7;
+        public const uint Guardian = 8;
+        public const uint Venomancer = 9;
+        public const uint CloseDoor = 10;
+    }
+
+    struct Misc
+    {
+        public const uint AchievGottaGoStartEvent = 20381;
+
+        public const byte PhaseEmerge = 1;
+        public const byte PhaseSubmerge = 2;
+
+        public const int GuidTypePet = 0;
+        public const int GuidTypeImpale = 1;
+
+        public const byte SummonGroupWorldTriggerGuardian = 1;
+
+        public const int ActionPetDied = 1;
+        public const int ActionPetEvade = 2;
+    }
+
+    [Script]
+    class boss_anub_arak : CreatureScript
+    {
+        public boss_anub_arak() : base("boss_anub_arak") { }
+
+        class boss_anub_arakAI : BossAI
+        {
+            public boss_anub_arakAI(Creature creature) : base(creature, ANDataTypes.Anubarak) { }
+
+            public override void Reset()
+            {
+                base.Reset();
+                me.RemoveFlag(UnitFields.Flags, UnitFlags.NonAttackable | UnitFlags.NotSelectable);
+                instance.DoStopCriteriaTimer(CriteriaTimedTypes.Event, Misc.AchievGottaGoStartEvent);
+                _nextSubmerge = 75;
+                _petCount = 0;
+            }
+
+            public override void EnterCombat(Unit who)
+            {
+                base.EnterCombat(who);
+
+                GameObject door = instance.GetGameObject(ANDataTypes.AnubarakWall);
+                if (door)
+                    door.SetGoState(GameObjectState.Active); // open door for now
+
+                Talk(TextIds.SayAggro);
+                instance.DoStartCriteriaTimer(CriteriaTimedTypes.Event, Misc.AchievGottaGoStartEvent);
+
+                _events.SetPhase(Misc.PhaseEmerge);
+                _events.ScheduleEvent(EventIds.CloseDoor, TimeSpan.FromSeconds(5));
+                _events.ScheduleEvent(EventIds.Pound, TimeSpan.FromSeconds(2), TimeSpan.FromSeconds(4), 0, Misc.PhaseEmerge);
+                _events.ScheduleEvent(EventIds.LeechingSwarm, TimeSpan.FromSeconds(5), TimeSpan.FromSeconds(7), 0, Misc.PhaseEmerge);
+                _events.ScheduleEvent(EventIds.CarrionBeetles, TimeSpan.FromSeconds(14), TimeSpan.FromSeconds(17), 0, Misc.PhaseEmerge);
+
+                // set up world triggers
+                List<TempSummon> summoned;
+                me.SummonCreatureGroup(Misc.SummonGroupWorldTriggerGuardian, out summoned);
+                if (summoned.Empty()) // something went wrong
+                {
+                    EnterEvadeMode(EvadeReason.Other);
+                    return;
+                }
+                _guardianTrigger = summoned.First().GetGUID();
+
+                Creature trigger = DoSummon(CreatureIds.WorldTrigger, me.GetPosition(), 0u, TempSummonType.ManualDespawn);
+                if (trigger)
+                    _assassinTrigger = trigger.GetGUID();
+                else
+                {
+                    EnterEvadeMode(EvadeReason.Other);
+                    return;
+                }
+            }
+
+            public override void EnterEvadeMode(EvadeReason why)
+            {
+                summons.DespawnAll();
+                _DespawnAtEvade();
+            }
+
+            public override void UpdateAI(uint diff)
+            {
+                if (!UpdateVictim())
+                    return;
+
+                _events.Update(diff);
+
+                if (me.HasUnitState(UnitState.Casting))
+                    return;
+
+                _events.ExecuteEvents(eventId =>
+                {
+                    switch (eventId)
+                    {
+                        case EventIds.CloseDoor:
+                            GameObject door = instance.GetGameObject(ANDataTypes.AnubarakWall);
+                            if (door)
+                                door.SetGoState(GameObjectState.Ready);
+                            break;
+                        case EventIds.Pound:
+                            DoCastVictim(SpellIds.Pound);
+                            _events.Repeat(TimeSpan.FromSeconds(26), TimeSpan.FromSeconds(32));
+                            break;
+                        case EventIds.LeechingSwarm:
+                            Talk(TextIds.SayLocust);
+                            DoCastAOE(SpellIds.LeechingSwarm);
+                            _events.Repeat(TimeSpan.FromSeconds(25), TimeSpan.FromSeconds(28));
+                            break;
+                        case EventIds.CarrionBeetles:
+                            DoCastAOE(SpellIds.CarrionBeetles);
+                            _events.Repeat(TimeSpan.FromSeconds(24), TimeSpan.FromSeconds(27));
+                            break;
+                        case EventIds.Impale:
+                            Creature impaleTarget = ObjectAccessor.GetCreature(me, _impaleTarget);
+                            if (impaleTarget)
+                                DoCast(impaleTarget, SpellIds.ImpaleDamage, true);
+                            break;
+                        case EventIds.Submerge:
+                            Talk(TextIds.SaySubmerge);
+                            DoCastSelf(SpellIds.Submerge);
+                            break;
+                        case EventIds.Darter:
+                            {
+                                List<Creature> triggers = new List<Creature>();
+                                me.GetCreatureListWithEntryInGrid(triggers, CreatureIds.WorldTrigger);
+                                if (!triggers.Empty())
+                                {
+                                    var it = triggers.PickRandom();
+                                    it.CastSpell(it, SpellIds.SummonDarter, true);
+                                    _events.Repeat(TimeSpan.FromSeconds(11));
+                                }
+                                else
+                                    EnterEvadeMode(EvadeReason.Other);
+                                break;
+                            }
+                        case EventIds.Assassin:
+                            {
+                                Creature trigger = ObjectAccessor.GetCreature(me, _assassinTrigger);
+                                if (trigger)
+                                {
+                                    trigger.CastSpell(trigger, SpellIds.SummonAssassin, true);
+                                    trigger.CastSpell(trigger, SpellIds.SummonAssassin, true);
+                                    if (_assassinCount > 2)
+                                    {
+                                        _assassinCount -= 2;
+                                        _events.Repeat(TimeSpan.FromSeconds(20));
+                                    }
+                                    else
+                                        _assassinCount = 0;
+                                }
+                                else // something went wrong
+                                    EnterEvadeMode(EvadeReason.Other);
+                                break;
+                            }
+                        case EventIds.Guardian:
+                            {
+                                Creature trigger = ObjectAccessor.GetCreature(me, _guardianTrigger);
+                                if (trigger)
+                                {
+                                    trigger.CastSpell(trigger, SpellIds.SummonGuardian, true);
+                                    trigger.CastSpell(trigger, SpellIds.SummonGuardian, true);
+                                    if (_guardianCount > 2)
+                                    {
+                                        _guardianCount -= 2;
+                                        _events.Repeat(TimeSpan.FromSeconds(20));
+                                    }
+                                    else
+                                        _guardianCount = 0;
+                                }
+                                else
+                                    EnterEvadeMode(EvadeReason.Other);
+                            }
+                            break;
+                        case EventIds.Venomancer:
+                            {
+                                Creature trigger = ObjectAccessor.GetCreature(me, _guardianTrigger);
+                                if (trigger)
+                                {
+                                    trigger.CastSpell(trigger, SpellIds.SummonVenomancer, true);
+                                    trigger.CastSpell(trigger, SpellIds.SummonVenomancer, true);
+                                    if (_venomancerCount > 2)
+                                    {
+                                        _venomancerCount -= 2;
+                                        _events.Repeat(TimeSpan.FromSeconds(20));
+                                    }
+                                    else
+                                        _venomancerCount = 0;
+                                }
+                                else
+                                    EnterEvadeMode(EvadeReason.Other);
+                            }
+                            break;
+                        default:
+                            break;
+                    }
+
+                    if (me.HasUnitState(UnitState.Casting))
+                        return;
+                });
+
+
+                DoMeleeAttackIfReady();
+            }
+
+            public override void JustDied(Unit killer)
+            {
+                _JustDied();
+                Talk(TextIds.SayDeath);
+            }
+
+            public override void KilledUnit(Unit victim)
+            {
+                if (victim.IsTypeId(TypeId.Player))
+                    Talk(TextIds.SaySlay);
+            }
+
+            public override void SetGUID(ObjectGuid guid, int type)
+            {
+                switch (type)
+                {
+                    case Misc.GuidTypePet:
+                        {
+                            Creature creature = ObjectAccessor.GetCreature(me, guid);
+                            if (creature)
+                                JustSummoned(creature);
+                            else // something has gone horribly wrong
+                                EnterEvadeMode(EvadeReason.Other);
+                            break;
+                        }
+                    case Misc.GuidTypeImpale:
+                        _impaleTarget = guid;
+                        _events.ScheduleEvent(EventIds.Impale, TimeSpan.FromSeconds(4));
+                        break;
+                }
+            }
+
+            public override void DoAction(int action)
+            {
+                switch (action)
+                {
+                    case Misc.ActionPetDied:
+                        if (_petCount == 0) // underflow check - something has gone horribly wrong
+                        {
+                            EnterEvadeMode(EvadeReason.Other);
+                            return;
+                        }
+                        if (--_petCount == 0) // last pet died, emerge
+                        {
+                            me.RemoveAurasDueToSpell(SpellIds.Submerge);
+                            me.RemoveAurasDueToSpell(SpellIds.ImpaleAura);
+                            me.RemoveFlag(UnitFields.Flags, UnitFlags.NonAttackable | UnitFlags.NotSelectable);
+                            DoCastSelf(SpellIds.Emerge);
+                            _events.SetPhase(Misc.PhaseEmerge);
+                            _events.ScheduleEvent(EventIds.Pound, TimeSpan.FromSeconds(13), TimeSpan.FromSeconds(18), 0, Misc.PhaseEmerge);
+                            _events.ScheduleEvent(EventIds.LeechingSwarm, TimeSpan.FromSeconds(3), TimeSpan.FromSeconds(7), 0, Misc.PhaseEmerge);
+                            _events.ScheduleEvent(EventIds.CarrionBeetles, TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(15), 0, Misc.PhaseEmerge);
+                        }
+                        break;
+                    case Misc.ActionPetEvade:
+                        EnterEvadeMode(EvadeReason.Other);
+                        break;
+                }
+            }
+
+            public override void DamageTaken(Unit source, ref uint damage)
+            {
+                if (me.HasAura(SpellIds.Submerge))
+                    damage = 0;
+                else
+                    if (_nextSubmerge != 0 && me.HealthBelowPctDamaged((int)_nextSubmerge, damage))
+                {
+                    _events.CancelEvent(EventIds.Submerge);
+                    _events.ScheduleEvent(EventIds.Submerge, 0, 0, Misc.PhaseEmerge);
+                    _nextSubmerge = _nextSubmerge - 25;
+                }
+            }
+
+            public override void SpellHit(Unit whose, SpellInfo spell)
+            {
+                if (spell.Id == SpellIds.Submerge)
+                {
+                    me.SetFlag(UnitFields.Flags, UnitFlags.NonAttackable | UnitFlags.NotSelectable);
+                    me.RemoveAurasDueToSpell(SpellIds.LeechingSwarm);
+                    DoCastSelf(SpellIds.ImpaleAura, true);
+
+                    _events.SetPhase(Misc.PhaseSubmerge);
+                    switch (_nextSubmerge)
+                    {
+                        case 50: // first submerge phase
+                            _assassinCount = 4;
+                            _guardianCount = 2;
+                            _venomancerCount = 0;
+                            break;
+                        case 25: // second submerge phase
+                            _assassinCount = 6;
+                            _guardianCount = 2;
+                            _venomancerCount = 2;
+                            break;
+                        case 0:  // third submerge phase
+                            _assassinCount = 6;
+                            _guardianCount = 2;
+                            _venomancerCount = 2;
+                            _events.ScheduleEvent(EventIds.Darter, TimeSpan.FromSeconds(0), 0, Misc.PhaseSubmerge);
+                            break;
+                    }
+                    _petCount = (uint)(_guardianCount + _venomancerCount);
+                    if (_assassinCount != 0)
+                        _events.ScheduleEvent(EventIds.Assassin, TimeSpan.FromSeconds(0), 0, Misc.PhaseSubmerge);
+                    if (_guardianCount != 0)
+                        _events.ScheduleEvent(EventIds.Guardian, TimeSpan.FromSeconds(4), 0, Misc.PhaseSubmerge);
+                    if (_venomancerCount != 0)
+                        _events.ScheduleEvent(EventIds.Venomancer, TimeSpan.FromSeconds(20), 0, Misc.PhaseSubmerge);
+                }
+            }
+
+            ObjectGuid _impaleTarget;
+            uint _nextSubmerge;
+            uint _petCount;
+            ObjectGuid _guardianTrigger;
+            ObjectGuid _assassinTrigger;
+            byte _assassinCount;
+            byte _guardianCount;
+            byte _venomancerCount;
+        }
+
+        public override CreatureAI GetAI(Creature creature)
+        {
+            return GetInstanceAI<boss_anub_arakAI>(creature);
+        }
+    }
+
+    [Script]
+    class npc_anubarak_pet_template : ScriptedAI
+    {
+        public npc_anubarak_pet_template(Creature creature, bool isLarge) : base(creature)
+        {
+            _instance = creature.GetInstanceScript();
+            _isLarge = isLarge;
+        }
+
+        public override void InitializeAI()
+        {
+            base.InitializeAI();
+
+            Creature anubarak = _instance.GetCreature(ANDataTypes.Anubarak);
+            if (anubarak)
+                anubarak.GetAI().SetGUID(me.GetGUID(), Misc.GuidTypePet);
+            else
+                me.DespawnOrUnsummon();
+        }
+
+        public override void JustDied(Unit killer)
+        {
+            base.JustDied(killer);
+            if (_isLarge)
+            {
+                Creature anubarak = _instance.GetCreature(ANDataTypes.Anubarak);
+                if (anubarak)
+                    anubarak.GetAI().DoAction(Misc.ActionPetDied);
+            }
+        }
+
+        public override void EnterEvadeMode(EvadeReason why)
+        {
+            Creature anubarak = _instance.GetCreature(ANDataTypes.Anubarak);
+            if (anubarak)
+                anubarak.GetAI().DoAction(Misc.ActionPetEvade);
+            else
+                me.DespawnOrUnsummon();
+        }
+
+        protected InstanceScript _instance;
+        bool _isLarge;
+    }
+
+    [Script]
+    class npc_anubarak_anub_ar_darter : CreatureScript
+    {
+        public npc_anubarak_anub_ar_darter() : base("npc_anubarak_anub_ar_darter") { }
+
+        class npc_anubarak_anub_ar_darterAI : npc_anubarak_pet_template
+        {
+            public npc_anubarak_anub_ar_darterAI(Creature creature) : base(creature, false) { }
+
+            public override void InitializeAI()
+            {
+                base.InitializeAI();
+                DoCastAOE(SpellIds.Dart);
+            }
+        }
+
+        public override CreatureAI GetAI(Creature creature)
+        {
+            return GetInstanceAI<npc_anubarak_anub_ar_darterAI>(creature);
+        }
+    }
+
+    [Script]
+    class npc_anubarak_anub_ar_assassin : CreatureScript
+    {
+        public npc_anubarak_anub_ar_assassin() : base("npc_anubarak_anub_ar_assassin") { }
+
+        class npc_anubarak_anub_ar_assassinAI : npc_anubarak_pet_template
+        {
+            public npc_anubarak_anub_ar_assassinAI(Creature creature) : base(creature, false)
+            {
+                _backstabTimer = 6 * Time.InMilliseconds;
+            }
+
+            bool IsInBounds(Position jumpTo, List<AreaBoundary> boundary)
+            {
+                if (boundary == null)
+                    return true;
+                foreach (var it in boundary)
+                    if (!it.IsWithinBoundary(jumpTo))
+                        return false;
+                return true;
+            }
+
+            Position GetRandomPositionAround(Creature anubarak)
+            {
+                float DISTANCE_MIN = 10.0f;
+                float DISTANCE_MAX = 30.0f;
+                double angle = RandomHelper.NextDouble() * 2.0 * Math.PI;
+                return new Position(anubarak.GetPositionX() + (float)(RandomHelper.FRand(DISTANCE_MIN, DISTANCE_MAX) * Math.Sin(angle)), anubarak.GetPositionY() + (float)(RandomHelper.FRand(DISTANCE_MIN, DISTANCE_MAX) * Math.Cos(angle)), anubarak.GetPositionZ());
+            }
+
+            public override void InitializeAI()
+            {
+                base.InitializeAI();
+                var boundary = _instance.GetBossBoundary(ANDataTypes.Anubarak);
+                Creature anubarak = _instance.GetCreature(ANDataTypes.Anubarak);
+                if (anubarak)
+                {
+                    Position jumpTo;
+                    do
+                        jumpTo = GetRandomPositionAround(anubarak);
+                    while (!IsInBounds(jumpTo, boundary));
+                    me.GetMotionMaster().MoveJump(jumpTo, 40.0f, 40.0f);
+                    DoCastSelf(SpellIds.AssassinVisual, true);
+                }
+            }
+
+            public override void UpdateAI(uint diff)
+            {
+                if (!UpdateVictim())
+                    return;
+
+                if (diff >= _backstabTimer)
+                {
+                    if (me.GetVictim() && me.GetVictim().isInBack(me))
+                        DoCastVictim(SpellIds.Backstab);
+                    _backstabTimer = 6 * Time.InMilliseconds;
+                }
+                else
+                    _backstabTimer -= diff;
+
+                DoMeleeAttackIfReady();
+            }
+
+            public override void MovementInform(MovementGeneratorType type, uint id)
+            {
+                if (id == EventId.Jump)
+                {
+                    me.RemoveAurasDueToSpell(SpellIds.AssassinVisual);
+                    DoZoneInCombat();
+                }
+            }
+
+            uint _backstabTimer;
+        }
+
+        public override CreatureAI GetAI(Creature creature)
+        {
+            return GetInstanceAI<npc_anubarak_anub_ar_assassinAI>(creature);
+        }
+    }
+
+    [Script]
+    class npc_anubarak_anub_ar_guardian : CreatureScript
+    {
+        public npc_anubarak_anub_ar_guardian() : base("npc_anubarak_anub_ar_guardian") { }
+
+        class npc_anubarak_anub_ar_guardianAI : npc_anubarak_pet_template
+        {
+            public npc_anubarak_anub_ar_guardianAI(Creature creature) : base(creature, true)
+            {
+                _sunderTimer = 6 * Time.InMilliseconds;
+            }
+
+            public override void UpdateAI(uint diff)
+            {
+                if (!UpdateVictim())
+                    return;
+
+                if (diff >= _sunderTimer)
+                {
+                    DoCastVictim(SpellIds.SunderArmor);
+                    _sunderTimer = 12 * Time.InMilliseconds;
+                }
+                else
+                    _sunderTimer -= diff;
+
+                DoMeleeAttackIfReady();
+            }
+
+            uint _sunderTimer;
+        }
+
+        public override CreatureAI GetAI(Creature creature)
+        {
+            return GetInstanceAI<npc_anubarak_anub_ar_guardianAI>(creature);
+        }
+    }
+
+    [Script]
+    class npc_anubarak_anub_ar_venomancer : CreatureScript
+    {
+        public npc_anubarak_anub_ar_venomancer() : base("npc_anubarak_anub_ar_venomancer") { }
+
+        class npc_anubarak_anub_ar_venomancerAI : npc_anubarak_pet_template
+        {
+            public npc_anubarak_anub_ar_venomancerAI(Creature creature) : base(creature, true)
+            {
+                _boltTimer = 5 * Time.InMilliseconds;
+            }
+
+            public override void UpdateAI(uint diff)
+            {
+                if (!UpdateVictim())
+                    return;
+
+                if (diff >= _boltTimer)
+                {
+                    DoCastVictim(SpellIds.PoisonBolt);
+                    _boltTimer = RandomHelper.URand(2, 3) * Time.InMilliseconds;
+                }
+                else
+                    _boltTimer -= diff;
+
+                DoMeleeAttackIfReady();
+            }
+
+            uint _boltTimer;
+        }
+
+        public override CreatureAI GetAI(Creature creature)
+        {
+            return GetInstanceAI<npc_anubarak_anub_ar_venomancerAI>(creature);
+        }
+    }
+
+    [Script]
+    class npc_anubarak_impale_target : CreatureScript
+    {
+        public npc_anubarak_impale_target() : base("npc_anubarak_impale_target") { }
+
+        class npc_anubarak_impale_targetAI : NullCreatureAI
+        {
+            public npc_anubarak_impale_targetAI(Creature creature) : base(creature) { }
+
+            public override void InitializeAI()
+            {
+                Creature anubarak = me.GetInstanceScript().GetCreature(ANDataTypes.Anubarak);
+                if (anubarak)
+                {
+                    DoCastSelf(SpellIds.ImpaleVisual);
+                    me.DespawnOrUnsummon(TimeSpan.FromSeconds(6));
+                    anubarak.GetAI().SetGUID(me.GetGUID(), Misc.GuidTypeImpale);
+                }
+                else
+                    me.DespawnOrUnsummon();
+            }
+        }
+
+        public override CreatureAI GetAI(Creature creature)
+        {
+            return GetInstanceAI<npc_anubarak_impale_targetAI>(creature);
+        }
+    }
+
+    [Script]
+    class spell_anubarak_pound : SpellScriptLoader
+    {
+        public spell_anubarak_pound() : base("spell_anubarak_pound") { }
+
+        class spell_anubarak_pound_SpellScript : SpellScript
+        {
+            public override bool Validate(SpellInfo spell)
+            {
+                return ValidateSpellInfo(SpellIds.PoundDamage);
+            }
+
+            void HandleDummy(uint effIndex)
+            {
+                Unit target = GetHitUnit();
+                if (target)
+                    GetCaster().CastSpell(target, SpellIds.PoundDamage, true);
+            }
+
+            public override void Register()
+            {
+                OnEffectHitTarget.Add(new EffectHandler(HandleDummy, 0, SpellEffectName.ApplyAura));
+            }
+        }
+
+        public override SpellScript GetSpellScript()
+        {
+            return new spell_anubarak_pound_SpellScript();
+        }
+    }
+
+    [Script]
+    class spell_anubarak_carrion_beetles : SpellScriptLoader
+    {
+        public spell_anubarak_carrion_beetles() : base("spell_anubarak_carrion_beetles") { }
+
+        class spell_anubarak_carrion_beetles_AuraScript : AuraScript
+        {
+            public override bool Validate(SpellInfo spell)
+            {
+                return ValidateSpellInfo(SpellIds.CarrionBeetle);
+            }
+
+            void HandlePeriodic(AuraEffect eff)
+            {
+                GetCaster().CastSpell(GetCaster(), SpellIds.CarrionBeetle, true);
+                GetCaster().CastSpell(GetCaster(), SpellIds.CarrionBeetle, true);
+            }
+
+            public override void Register()
+            {
+                OnEffectPeriodic.Add(new EffectPeriodicHandler(HandlePeriodic, 0, AuraType.PeriodicDummy));
+            }
+        }
+
+        public override AuraScript GetAuraScript()
+        {
+            return new spell_anubarak_carrion_beetles_AuraScript();
+        }
+    }
+}

Scripts/Northrend/AzjolNerub/AzjolNerub/InstanceAzjolNerub.cs

@@ -0,0 +1,131 @@
+/*
+ * Copyright (C) 2012-2017 CypherCore <http://github.com/CypherCore>
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+using Framework.Constants;
+using Game.Entities;
+using Game.Maps;
+using Game.Scripting;
+
+namespace Scripts.Northrend.AzjolNerub.AzjolNerub
+{
+    [Script]
+    class instance_azjol_nerub : InstanceMapScript
+    {
+        public instance_azjol_nerub() : base(nameof(instance_azjol_nerub), 601) { }
+
+        class instance_azjol_nerub_InstanceScript : InstanceScript
+        {
+            public instance_azjol_nerub_InstanceScript(Map map) : base(map)
+            {
+                SetHeaders(ANInstanceMisc.DataHeader);
+                SetBossNumber(ANInstanceMisc.EncounterCount);
+                LoadBossBoundaries(ANInstanceMisc.boundaries);
+                LoadDoorData(ANInstanceMisc.doorData);
+                LoadObjectData(ANInstanceMisc.creatureData, ANInstanceMisc.gameobjectData);
+            }
+
+            public override void OnUnitDeath(Unit who)
+            {
+                base.OnUnitDeath(who);
+                Creature creature = who.ToCreature();
+                if (!creature || creature.IsCritter() || creature.IsControlledByPlayer())
+                    return;
+
+                Creature gatewatcher = GetCreature(ANDataTypes.KrikthirTheGatewatcher);
+                if (gatewatcher)
+                    gatewatcher.GetAI().DoAction(-ANInstanceMisc.ActionGatewatcherGreet);
+            }
+        }
+
+        public override InstanceScript GetInstanceScript(InstanceMap map)
+        {
+            return new instance_azjol_nerub_InstanceScript(map);
+        }
+    }
+
+    struct ANDataTypes
+    {
+        // Encounter States/Boss Guids
+        public const uint KrikthirTheGatewatcher = 0;
+        public const uint Hadronox = 1;
+        public const uint Anubarak = 2;
+
+        // Additional Data
+        public const uint WatcherNarjil = 3;
+        public const uint WatcherGashra = 4;
+        public const uint WatcherSilthik = 5;
+        public const uint AnubarakWall = 6;
+    }
+
+    struct ANCreatureIds
+    {
+        public const uint Krikthir = 28684;
+        public const uint Hadronox = 28921;
+        public const uint Anubarak = 29120;
+
+        public const uint WatcherNarjil = 28729;
+        public const uint WatcherGashra = 28730;
+        public const uint WatcherSilthik = 28731;
+    }
+
+    struct ANGameObjectIds
+    {
+        public const uint KrikthirDoor = 192395;
+        public const uint AnubarakDoor1 = 192396;
+        public const uint AnubarakDoor2 = 192397;
+        public const uint AnubarakDoor3 = 192398;
+    }
+
+    // These are passed as -action to AI's DoAction to differentiate between them and boss scripts' own actions
+    struct ANInstanceMisc
+    {
+        public const string DataHeader = "AN";
+        public const uint EncounterCount = 3;
+
+        public const int ActionGatewatcherGreet = 1;
+
+        public static DoorData[] doorData =
+        {
+            new DoorData(ANGameObjectIds.KrikthirDoor,    ANDataTypes.KrikthirTheGatewatcher, DoorType.Passage),
+            new DoorData(ANGameObjectIds.AnubarakDoor1,   ANDataTypes.Anubarak,               DoorType.Room   ),
+            new DoorData(ANGameObjectIds.AnubarakDoor2,   ANDataTypes.Anubarak,               DoorType.Room   ),
+            new DoorData(ANGameObjectIds.AnubarakDoor3,   ANDataTypes.Anubarak,               DoorType.Room   )
+        };
+
+        public static ObjectData[] creatureData =
+        {
+            new ObjectData(ANCreatureIds.Krikthir,       ANDataTypes.KrikthirTheGatewatcher ),
+            new ObjectData(ANCreatureIds.Hadronox,       ANDataTypes.Hadronox               ),
+            new ObjectData(ANCreatureIds.Anubarak,       ANDataTypes.Anubarak               ),
+            new ObjectData(ANCreatureIds.WatcherNarjil,  ANDataTypes.WatcherGashra          ),
+            new ObjectData(ANCreatureIds.WatcherGashra,  ANDataTypes.WatcherSilthik         ),
+            new ObjectData(ANCreatureIds.WatcherSilthik, ANDataTypes.WatcherNarjil          )
+        };
+
+        public static ObjectData[] gameobjectData =
+        {
+            new ObjectData(ANGameObjectIds.AnubarakDoor3, ANDataTypes.AnubarakWall)
+        };
+
+        public static BossBoundaryEntry[] boundaries =
+        {
+            new BossBoundaryEntry(ANDataTypes.KrikthirTheGatewatcher, new RectangleBoundary(400.0f, 580.0f, 623.5f, 810.0f)),
+            new BossBoundaryEntry(ANDataTypes.Hadronox, new ZRangeBoundary(666.0f, 776.0f)),
+            new BossBoundaryEntry(ANDataTypes.Anubarak, new CircleBoundary(new Position(550.6178f, 253.5917f), 26.0f))
+        };
+    }
+}