// Pet thread
 private static void PetThread(object sender, DoWorkEventArgs args)
 {
     while (Main._isLaunched)
     {
         try
         {
             if (Conditions.InGameAndConnectedAndProductStartedNotInPause && !ObjectManager.Me.IsOnTaxi && ObjectManager.Me.IsAlive &&
                 ObjectManager.Pet.IsValid && !Main.HMPrunningAway)
             {
                 // Voidwalker Torment
                 if (PetAndConsumables.MyWarlockPet().Equals("Voidwalker") &&
                     ObjectManager.Target.Target == Me.Guid &&
                     Me.InCombatFlagOnly &&
                     !_settings.AutoTorment)
                 {
                     ToolBox.PetSpellCast("Torment");
                 }
             }
         }
         catch (Exception arg)
         {
             Logging.WriteError(string.Concat(arg), true);
         }
         Thread.Sleep(300);
     }
 }
    public static void Initialize()
    {
        Main.Log("Initialized");
        ZEWarlockSettings.Load();
        _settings = ZEWarlockSettings.CurrentSetting;
        Talents.InitTalents(_settings.AssignTalents, _settings.UseDefaultTalents, _settings.TalentCodes);

        Main.SetRange(_maxRange);
        _petPulseThread.DoWork += PetThread;
        _petPulseThread.RunWorkerAsync();

        // Set pet mode
        if (_settings.PetInPassiveWhenOOC)
        {
            Lua.LuaDoString("PetPassiveMode();");
        }
        else
        {
            Lua.LuaDoString("PetDefensiveMode();");
        }

        // Fight end
        FightEvents.OnFightEnd += (ulong guid) =>
        {
            _usingWand   = false;
            _iCanUseWand = false;
            Main.SetRange(_maxRange);
            _addCheckTimer.Reset();
            if (_settings.PetInPassiveWhenOOC)
            {
                Lua.LuaDoString("PetPassiveMode();");
            }
        };

        // Fight start
        FightEvents.OnFightStart += (WoWUnit unit, CancelEventArgs cancelable) =>
        {
            if (UseWand.IsSpellUsable)
            {
                _iCanUseWand = true;
            }
            Lua.LuaDoString("PetDefensiveMode();");

            // Imp Firebolt
            if (PetAndConsumables.MyWarlockPet().Equals("Imp"))
            {
                ToolBox.TogglePetSpellAuto("Firebolt", true);
            }

            // Imp BloodPact
            if (PetAndConsumables.MyWarlockPet().Equals("Imp"))
            {
                ToolBox.TogglePetSpellAuto("Blood Pact", true);
            }
        };

        Rotation();
    }
    internal static void CombatRotation()
    {
        _usingWand = Lua.LuaDoString <bool>("isAutoRepeat = false; local name = GetSpellInfo(5019); " +
                                            "if IsAutoRepeatSpell(name) then isAutoRepeat = true end", "isAutoRepeat");
        WoWUnit Me                    = ObjectManager.Me;
        WoWUnit Target                = ObjectManager.Target;
        double  _myManaPC             = Me.ManaPercentage;
        bool    _overLowManaThreshold = _myManaPC > _innerManaSaveThreshold;

        // Multi aggro

        /*if (ObjectManager.GetNumberAttackPlayer() > 1 && Fear.KnownSpell &&
         *  (_addCheckTimer.ElapsedMilliseconds > 3000 || _addCheckTimer.ElapsedMilliseconds <= 0))
         * {
         *  _addCheckTimer.Restart();
         *  WoWUnit _currenTarget = ObjectManager.Target;
         *  List<WoWUnit> _listUnitsAttackingMe = ObjectManager.GetUnitAttackPlayer();
         *  foreach (WoWUnit unit in _listUnitsAttackingMe)
         *  {
         *      Thread.Sleep(500);
         *      if (unit.Target == Me.Guid && unit.Guid != Me.Target && PetAndConsumables.MyWarlockPet().Equals("Voidwalker"))
         *      {
         *          ulong saveTarget = Me.Target;
         *          if (Cast(SoulShatter))
         *          {
         *              _addCheckTimer.Reset();
         *              Thread.Sleep(500 + Usefuls.Latency);
         *              return;
         *          }
         *          Lua.RunMacroText("/cleartarget");
         *          Me.Target = unit.Guid;
         *          Thread.Sleep(200 + Usefuls.Latency);
         *          if (_settings.FearAdds)
         *              if (Cast(Fear))
         *              {
         *                  Thread.Sleep(200 + Usefuls.Latency);
         *                  Me.Target = saveTarget;
         *              }
         *      }
         *  }
         * }*/

        // Pet attack
        if (ObjectManager.Pet.Target != ObjectManager.Me.Target)
        {
            Lua.LuaDoString("PetAttack();", false);
        }

        // Mana Tap
        if (Target.Mana > 0 && Target.ManaPercentage > 10)
        {
            if (Cast(ManaTap))
            {
                return;
            }
        }

        // Arcane Torrent
        if ((Me.HaveBuff("Mana Tap") && Me.ManaPercentage < 50) ||
            (Target.IsCast && Target.GetDistance < 8))
        {
            if (Cast(ArcaneTorrent))
            {
                return;
            }
        }

        // Will of the Forsaken
        if (Me.HaveBuff("Fear") || Me.HaveBuff("Charm") || Me.HaveBuff("Sleep"))
        {
            if (Cast(WillOfTheForsaken))
            {
                return;
            }
        }

        // Escape Artist
        if (Me.Rooted || Me.HaveBuff("Frostnova"))
        {
            if (Cast(EscapeArtist))
            {
                return;
            }
        }

        // Berserking
        if (Target.HealthPercent > 70)
        {
            if (Cast(Berserking))
            {
                return;
            }
        }

        // Drain Soul
        if (ToolBox.CountItemStacks("Soul Shard") < _settings.NumberOfSoulShards &&
            Target.HealthPercent < 40)
        {
            if (Cast(DrainSoul))
            {
                return;
            }
        }

        // Use Health Stone
        if (Me.HealthPercent < 15)
        {
            PetAndConsumables.UseHealthstone();
        }

        // Shadow Trance
        if (Me.HaveBuff("Shadow Trance") && _overLowManaThreshold)
        {
            if (Cast(ShadowBolt))
            {
                return;
            }
        }

        // Siphon Life
        if (Me.HealthPercent < 90 &&
            _overLowManaThreshold &&
            Target.HealthPercent > 20 &&
            !Target.HaveBuff("Siphon Life") &&
            _settings.UseSiphonLife)
        {
            if (Cast(SiphonLife))
            {
                return;
            }
        }

        // Death Coil
        if (Me.HealthPercent < 20)
        {
            if (Cast(DeathCoil))
            {
                return;
            }
        }

        // Drain Life low
        if (Me.HealthPercent < 30 &&
            Target.HealthPercent > 20)
        {
            if (Cast(DrainLife))
            {
                return;
            }
        }

        // Curse of Agony
        if (ObjectManager.Target.GetDistance < _maxRange &&
            !Target.HaveBuff("Curse of Agony") &&
            _overLowManaThreshold &&
            Target.HealthPercent > 20)
        {
            if (Cast(CurseOfAgony))
            {
                return;
            }
        }

        // Unstable Affliction
        if (ObjectManager.Target.GetDistance < _maxRange &&
            !Target.HaveBuff("Unstable Affliction") &&
            _overLowManaThreshold &&
            Target.HealthPercent > 30)
        {
            if (Cast(UnstableAffliction))
            {
                return;
            }
        }

        // Corruption
        if (ObjectManager.Target.GetDistance < _maxRange &&
            !Target.HaveBuff("Corruption") &&
            _overLowManaThreshold &&
            Target.HealthPercent > 20)
        {
            if (Cast(Corruption))
            {
                return;
            }
        }

        // Immolate
        if (ObjectManager.Target.GetDistance < _maxRange &&
            !Target.HaveBuff("Immolate") &&
            _overLowManaThreshold &&
            Target.HealthPercent > 30 &&
            (_settings.UseImmolateHighLevel || !UnstableAffliction.KnownSpell) &&
            ToolBox.CanBleed(ObjectManager.Target))
        {
            if (Cast(Immolate))
            {
                return;
            }
        }

        // Drain Life high
        if (Me.HealthPercent < 70 &&
            Target.HealthPercent > 20)
        {
            if (Cast(DrainLife))
            {
                return;
            }
        }

        // Health Funnel
        if (ObjectManager.Pet.IsValid &&
            ObjectManager.Pet.HealthPercent < 30 &&
            Me.HealthPercent > 30)
        {
            Main.SetRange(19f);
            if (HealthFunnel.IsDistanceGood && Cast(HealthFunnel))
            {
                return;
            }
        }

        // Dark Pact
        if (Me.ManaPercentage < 70 &&
            ObjectManager.Pet.Mana > 0 &&
            ObjectManager.Pet.ManaPercentage > 60 &&
            _settings.UseDarkPact)
        {
            if (Cast(DarkPact))
            {
                return;
            }
        }

        // Drain Mana
        if (Me.ManaPercentage < 70 &&
            Target.Mana > 0 &&
            Target.ManaPercentage > 30)
        {
            if (Cast(DrainMana))
            {
                return;
            }
        }

        // Incinerate
        if (ObjectManager.Target.GetDistance < _maxRange && Target.HaveBuff("Immolate") &&
            _overLowManaThreshold &&
            Target.HealthPercent > 30 &&
            (_settings.UseIncinerate))
        {
            if (Cast(Incinerate))
            {
                return;
            }
        }

        // Shadow Bolt
        if ((!_settings.PrioritizeWandingOverSB || !_iCanUseWand) &&
            (ObjectManager.Target.HealthPercent > 50 || (Me.ManaPercentage > 90 && ObjectManager.Target.HealthPercent > 10)) &&
            _myManaPC > 40 &&
            ObjectManager.Target.GetDistance < _maxRange)
        {
            if (Cast(ShadowBolt))
            {
                return;
            }
        }

        // Life Tap
        if (Me.HealthPercent > 50 &&
            Me.ManaPercentage < 40 &&
            !ObjectManager.Target.IsTargetingMe &&
            _settings.UseLifeTap)
        {
            if (Cast(LifeTap))
            {
                return;
            }
        }

        // Use Wand
        if (!_usingWand &&
            _iCanUseWand &&
            ObjectManager.Target.GetDistance <= _maxRange + 2)
        {
            Main.SetRange(_maxRange);
            if (Cast(UseWand, false))
            {
                return;
            }
        }

        // Go in melee because nothing else to do
        if (!_usingWand && !UseWand.IsSpellUsable &&
            !Main.CurrentRangeIsMelee() &&
            Target.IsAlive)
        {
            Main.Log("Going in melee");
            Main.SetRangeToMelee();
            return;
        }
    }
    internal static void BuffRotation()
    {
        if (!Me.IsMounted)
        {
            // Make sure we have mana to summon
            if (!ObjectManager.Pet.IsValid &&
                ObjectManager.Me.ManaPercentage < 95 &&
                !ObjectManager.Me.HaveBuff("Drink") &&
                (SummonVoidwalker.KnownSpell && !SummonVoidwalker.IsSpellUsable && ToolBox.CountItemStacks("Soul Shard") > 0 ||
                 (SummonImp.KnownSpell && !SummonImp.IsSpellUsable && !SummonVoidwalker.KnownSpell)))
            {
                Main.Log("Not enough mana to summon, forcing regen");
                wManager.wManagerSetting.CurrentSetting.DrinkPercent = 95;
                Thread.Sleep(1000);
                return;
            }
            else
            {
                wManager.wManagerSetting.CurrentSetting.DrinkPercent = _saveDrinkPercent;
            }

            // Switch Auto Torment & Suffering off
            if (PetAndConsumables.MyWarlockPet().Equals("Voidwalker"))
            {
                ToolBox.TogglePetSpellAuto("Torment", _settings.AutoTorment);
                ToolBox.TogglePetSpellAuto("Suffering", false);
            }

            // Summon Felguard
            if ((!ObjectManager.Pet.IsValid ||
                 PetAndConsumables.MyWarlockPet().Equals("Voidwalker") || PetAndConsumables.MyWarlockPet().Equals("Imp")) &&
                SummonFelguard.KnownSpell)
            {
                Thread.Sleep(Usefuls.Latency + 500); // Safety for Mount check
                if (!ObjectManager.Me.IsMounted)
                {
                    if (Cast(FelDomination))
                    {
                        Thread.Sleep(200);
                    }
                    if (Cast(SummonFelguard))
                    {
                        return;
                    }
                }
            }

            // Summon Felguard for mana or health
            if (SummonFelguard.KnownSpell &&
                (ObjectManager.Pet.ManaPercentage < 20 || ObjectManager.Pet.HealthPercent < 20) &&
                ObjectManager.Pet.IsValid)
            {
                Thread.Sleep(Usefuls.Latency + 500); // Safety for Mount check
                if (!ObjectManager.Me.IsMounted)
                {
                    if (Cast(FelDomination))
                    {
                        Thread.Sleep(200);
                    }
                    if (Cast(SummonFelguard))
                    {
                        return;
                    }
                }
            }

            // Summon Void Walker
            if ((!ObjectManager.Pet.IsValid || !PetAndConsumables.MyWarlockPet().Equals("Voidwalker")) &&
                SummonVoidwalker.KnownSpell &&
                !SummonFelguard.KnownSpell)
            {
                Thread.Sleep(Usefuls.Latency + 500); // Safety for Mount check
                if (!ObjectManager.Me.IsMounted)
                {
                    if (Cast(FelDomination))
                    {
                        Thread.Sleep(200);
                    }
                    if (Cast(SummonVoidwalker))
                    {
                        return;
                    }
                }
            }

            // Summon Void Walker for mana
            if (PetAndConsumables.MyWarlockPet().Equals("Voidwalker") &&
                SummonVoidwalker.KnownSpell &&
                ObjectManager.Pet.ManaPercentage < 20 &&
                !SummonFelguard.KnownSpell)
            {
                Thread.Sleep(Usefuls.Latency + 500); // Safety for Mount check
                if (!ObjectManager.Me.IsMounted)
                {
                    if (Cast(FelDomination))
                    {
                        Thread.Sleep(200);
                    }
                    if (Cast(SummonVoidwalker))
                    {
                        return;
                    }
                }
            }

            // Summon Imp
            if (!ObjectManager.Pet.IsValid && SummonImp.KnownSpell &&
                (!SummonVoidwalker.KnownSpell || ToolBox.CountItemStacks("Soul Shard") < 1))
            {
                Thread.Sleep(Usefuls.Latency + 500); // Safety for Mount check
                if (!ObjectManager.Me.IsMounted)
                {
                    if (Cast(FelDomination))
                    {
                        Thread.Sleep(200);
                    }
                    if (Cast(SummonImp))
                    {
                        return;
                    }
                }
            }

            // Life Tap
            if (Me.HealthPercent > Me.ManaPercentage &&
                _settings.UseLifeTap)
            {
                if (Cast(LifeTap))
                {
                    return;
                }
            }

            // Unending Breath
            if (!Me.HaveBuff("Unending Breath") &&
                UnendingBreath.KnownSpell &&
                UnendingBreath.IsSpellUsable &&
                _settings.UseUnendingBreath)
            {
                Lua.RunMacroText("/target player");
                if (Cast(UnendingBreath))
                {
                    Lua.RunMacroText("/cleartarget");
                    return;
                }
            }

            // Demon Skin
            if (!Me.HaveBuff("Demon Skin") &&
                !DemonArmor.KnownSpell &&
                DemonSkin.KnownSpell)
            {
                if (Cast(DemonSkin))
                {
                    return;
                }
            }

            // Demon Armor
            if ((!Me.HaveBuff("Demon Armor") || Me.HaveBuff("Demon Skin")) &&
                DemonArmor.KnownSpell &&
                (!FelArmor.KnownSpell || (FelArmor.KnownSpell && !_settings.UseFelArmor)))
            {
                if (Cast(DemonArmor))
                {
                    return;
                }
            }

            // Soul Link
            if (SoulLink.KnownSpell &&
                !Me.HaveBuff("Soul Link"))
            {
                if (Cast(SoulLink))
                {
                    return;
                }
            }

            // Fel Armor
            if (!Me.HaveBuff("Fel Armor") &&
                FelArmor.KnownSpell &&
                _settings.UseFelArmor)
            {
                if (Cast(FelArmor))
                {
                    return;
                }
            }

            // Health Funnel
            if (ObjectManager.Pet.HealthPercent < 50 &&
                Me.HealthPercent > 40 &&
                ObjectManager.Pet.GetDistance < 19 &&
                !ObjectManager.Pet.InCombatFlagOnly &&
                HealthFunnel.KnownSpell)
            {
                Fight.StopFight();
                MovementManager.StopMove();
                if (PetAndConsumables.MyWarlockPet().Equals("Voidwalker") &&
                    ToolBox.GetPetSpellIndex("Consume Shadows") != 0)
                {
                    ToolBox.PetSpellCast("Consume Shadows");
                    Usefuls.WaitIsCasting();
                    MovementManager.StopMove();
                    Thread.Sleep(500);
                }


                ToolBox.StopWandWaitGCD(UseWand, ShadowBolt);
                MovementManager.StopMove();
                MovementManager.StopMoveNewThread();
                if (Cast(HealthFunnel))
                {
                    Thread.Sleep(500);
                    Usefuls.WaitIsCasting();
                    return;
                }
            }

            // Health Stone
            if (!PetAndConsumables.HaveHealthstone())
            {
                if (Cast(CreateHealthStone))
                {
                    return;
                }
            }

            // Create Soul Stone
            if (!PetAndConsumables.HaveSoulstone() &&
                CreateSoulstone.KnownSpell)
            {
                if (Cast(CreateSoulstone))
                {
                    return;
                }
            }

            // Use Soul Stone
            if (!Me.HaveBuff("Soulstone Resurrection") &&
                CreateSoulstone.KnownSpell &&
                ToolBox.HaveOneInList(PetAndConsumables.SoulStones()) &&
                ToolBox.GetItemCooldown(PetAndConsumables.SoulStones()) <= 0)
            {
                MovementManager.StopMove();
                Lua.RunMacroText("/target player");
                PetAndConsumables.UseSoulstone();
                Usefuls.WaitIsCasting();
                Lua.RunMacroText("/cleartarget");
            }

            // Cannibalize
            if (ObjectManager.GetObjectWoWUnit().Where(u => u.GetDistance <= 8 && u.IsDead && (u.CreatureTypeTarget == "Humanoid" || u.CreatureTypeTarget == "Undead")).Count() > 0)
            {
                if (Me.HealthPercent < 50 && !Me.HaveBuff("Drink") && !Me.HaveBuff("Food") && Me.IsAlive && Cannibalize.KnownSpell && Cannibalize.IsSpellUsable)
                {
                    if (Cast(Cannibalize))
                    {
                        return;
                    }
                }
            }
        }
    }