Ported .Net Core commits:

hondacrx: - Initial commit: Switch to .Net Core 2.0 - Fix build and removed not needed files Fabi: - Updated solution platforms. - Changed folder structure. - Change library target framework to netstandard2.0. - Updated solution platforms again... - Removed windows specific kernel32 function usage (Ctrl-C handler).
2017-10-26 17:23:44 +02:00
parent 227702e19c
commit a3dc7b3f48
844 changed files with 26064 additions and 1824 deletions
@@ -0,0 +1,189 @@
+/*
+ * 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 : BossAI
+    {
+        public boss_amanitar(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();
+        }
+    }
+
+    [Script]
+    class npc_amanitar_mushrooms : ScriptedAI
+    {
+        public npc_amanitar_mushrooms(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;
+        }
+    }
+}
@@ -0,0 +1,247 @@
+/*
+ * 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 : BossAI
+    {
+        public boss_elder_nadox(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;
+    }
+
+    [Script]
+    class npc_ahnkahar_nerubian : ScriptedAI
+    {
+        public npc_ahnkahar_nerubian(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();
+        }
+    }
+
+    // 56159 - Swarm
+    [Script]
+    class spell_ahn_kahet_swarm : SpellScript
+    {
+        public spell_ahn_kahet_swarm()
+        {
+            _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;
+    }
+
+    [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;
+        }
+    }
+}
@@ -0,0 +1,288 @@
+/*
+ * 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 : ScriptedAI
+    {
+        public boss_volazj(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;
+    }
+}
@@ -0,0 +1,569 @@
+/*
+ * 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 BeamVisualJedogasAufseher1 = 60342;
+        public const uint BeamVisualJedogasAufseher2 = 56312;
+    }
+
+    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]
+    public class boss_jedoga_shadowseeker : ScriptedAI
+    {
+        public boss_jedoga_shadowseeker(Creature creature) : base(creature)
+        {
+            Initialize();
+            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();
+
+            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;
+    }
+
+    [Script]
+    class npc_jedoga_initiand : ScriptedAI
+    {
+        public npc_jedoga_initiand(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>().bOpFerok)
+                        boss.GetAI<boss_jedoga_shadowseeker>().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>().bOpFerok = true;
+                            boss.GetAI<boss_jedoga_shadowseeker>().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;
+    }
+
+
+    [Script]
+    class npc_jedogas_aufseher_trigger : ScriptedAI
+    {
+        public npc_jedogas_aufseher_trigger(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, SpellIds.BeamVisualJedogasAufseher1, false);
+                    bCast = true;
+                }
+            }
+            if (!bRemoved2 && me.GetPositionX() < 440.0f)
+            {
+                if (!bCast2 && instance.GetData(DataTypes.JedogaTriggerSwitch) != 0)
+                {
+                    DoCast(me, SpellIds.BeamVisualJedogasAufseher2, 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;
+    }
+
+    [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;
+        }
+    }
+}
@@ -0,0 +1,436 @@
+/*
+ * 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]
+    public class boss_prince_taldaram : BossAI
+    {
+        public boss_prince_taldaram(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;
+    }
+
+    [Script] // 30106, 31686, 31687 - Flame Sphere
+    class npc_prince_taldaram_flame_sphere : ScriptedAI
+    {
+        public npc_prince_taldaram_flame_sphere(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;
+    }
+
+    [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>().CheckSpheres();
+            }
+            return true;
+        }
+    }
+
+    [Script] // 55931 - Conjure Flame Sphere
+    class spell_prince_taldaram_conjure_flame_sphere : 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));
+        }
+    }
+
+    [Script] // 55895, 59511, 59512 - Flame Sphere Summon
+    class spell_prince_taldaram_flame_sphere_summon : 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));
+        }
+    }
+}
@@ -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
+{
+    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;
+    }
+
+    [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.SelectRandom();
+                        }
+                    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);
+        }
+    }
+}