public static void SetTarget(AIHeroClient hero)
 {
     if (!isEBActive)
     {
         LSTargetSelector.SetTarget(hero);
     }
 }

        public float GetComboDamage(AIHeroClient t)
        {
            var fComboDamage = 0f;

            if (Spells.Q.IsReady() && Menu.getCheckBoxItem(Menu.MenuDrawings, "Draw.Calc.Q"))
            {
                fComboDamage += QDamage*(100/(100 + t.Armor));
            }

            if (Spells.W.IsReady() && Menu.getCheckBoxItem(Menu.MenuDrawings, "Draw.Calc.W"))
            {
                fComboDamage += WDamage*(100/(100 + t.SpellBlock));
            }

            if (Spells.E.IsReady() && Menu.getCheckBoxItem(Menu.MenuDrawings, "Draw.Calc.E"))
            {
                fComboDamage += WDamage*(100/(100 + t.Armor));
            }

            if (Spells.R.IsReady() && Menu.getCheckBoxItem(Menu.MenuDrawings, "Draw.Calc.R"))
            {
                fComboDamage += ObjectManager.Player.GetSpellDamage(t, SpellSlot.R)*(100/(100 + t.SpellBlock));
            }

            if (PlayerSpells.IgniteSlot != SpellSlot.Unknown && Menu.getCheckBoxItem(Menu.MenuDrawings, "Draw.Calc.I")
                && Utils.Player.Self.Spellbook.CanUseSpell(PlayerSpells.IgniteSlot) == SpellState.Ready)
            {
                fComboDamage += (float) Utils.Player.Self.GetSummonerSpellDamage(t, Damage.SummonerSpell.Ignite);
            }

            return fComboDamage;
        }

 public override void LaneClear(ComboProvider combo, AIHeroClient target)
 {
     var locationM =
         GetCircularFarmLocation(MinionManager.GetMinions(900 + 120, MinionTypes.All, MinionTeam.NotAlly));
     if (locationM.MinionsHit >= Program.getLaneMenuSL("MinWtargets"))
         Cast(locationM.Position);
 }

 public static float GetTotalDmg(AIHeroClient target)
 {
     var damage = Player.Instance.GetAutoAttackDamage(target);
     if (Q.IsReady())
         damage += _Player.GetSpellDamage(target, SpellSlot.Q);
     return damage;
 }

        private static void Combo1(AIHeroClient t)
        {
            if (SpellManager.E.IsReady() && t.IsInRange(Player.Instance.Position, SpellManager.E.Range) && ConfigList.Combo.ComboE)
            {
                var d = Dagger.GetClosestDagger();
                if (t.Position.IsInRange(d, SpellManager.W.Range)) SpellManager.E.CastE(Damage.GetBestDaggerPoint(d, t));
                else
                    if (Player.Instance.Distance(t) >= SpellManager.W.Range)
                    SpellManager.E.CastE(t.Position);
            }

            if (SpellManager.W.IsLearned && !SpellManager.W.IsOnCooldown && ConfigList.Combo.ComboW)
            {
                if (t.IsInRange(Player.Instance.Position, SpellManager.W.Range))
                    SpellManager.W.Cast();
            }

            if (SpellManager.Q.CanCast(t) && ConfigList.Combo.ComboQ)
            {
                SpellManager.Q.Cast(t);
            }

            if (SpellManager.R.IsLearned && !SpellManager.R.IsOnCooldown && ConfigList.Combo.ComboR)
            {
                if (Player.Instance.CountEnemyChampionsInRange(ConfigList.Combo.MaxRCastRange) < ConfigList.Combo.MinToUseR) return;
                if (Damage.GetQDamage(t) + Damage.GetPDamage(t) + Damage.GetEDamage(t) + Player.Instance.GetAutoAttackDamage(t, true) >= t.TotalShieldHealth()) return;
                if (Orbwalker.IsAutoAttacking && !Orbwalker.DisableAttacking)
                {
                    Orbwalker.DisableAttacking = true;
                    Orbwalker.ResetAutoAttack();
                }
                SpellManager.R.Cast();
                Damage.FreezePlayer();
            }
        }

 public override void Execute(AIHeroClient target)
 {
     if (!Provider.ShouldBeDead(target))
     {
         Cast(target, aoe: Program.getMiscMenuCB("aoeW"));
     }
 }

        private static void ECast(AIHeroClient enemy)
        {
            var range = Orbwalking.GetRealAutoAttackRange(enemy);
            var path = Geometry.CircleCircleIntersection(ObjectManager.Player.ServerPosition.LSTo2D(),
                Prediction.GetPrediction(enemy, 0.25f).UnitPosition.LSTo2D(), LucianSpells.E.Range, range);

            if (path.Count() > 0)
            {
                var epos = path.MinOrDefault(x => x.LSDistance(Game.CursorPos));
                if (epos.To3D().UnderTurret(true) || epos.To3D().LSIsWall())
                {
                    return;
                }

                if (epos.To3D().CountEnemiesInRange(LucianSpells.E.Range - 100) > 0)
                {
                    return;
                }
                LucianSpells.E.Cast(epos);
            }
            if (path.Count() == 0)
            {
                var epos = ObjectManager.Player.ServerPosition.LSExtend(enemy.ServerPosition, -LucianSpells.E.Range);
                if (epos.UnderTurret(true) || epos.LSIsWall())
                {
                    return;
                }

                // no intersection or target to close
                LucianSpells.E.Cast(ObjectManager.Player.ServerPosition.LSExtend(enemy.ServerPosition,
                    -LucianSpells.E.Range));
            }
        }

        public FioraPassive(Obj_GeneralParticleEmitter emitter, AIHeroClient enemy)
            : base(emitter.Index, (uint)emitter.NetworkId, emitter as GameObject)
        {
            Target = enemy;

            if (emitter.Name.Contains("Base_R"))
            {
                Passive = PassiveType.UltPassive;
                Color = Color.White;
            }
            else if (emitter.Name.Contains("Warning"))
            {
                Passive = PassiveType.Prepassive;
                Color = Color.Blue;
            }
            else if (emitter.Name.Contains("Timeout"))
            {
                Passive = PassiveType.PassiveTimeout;
                Color = Color.Red;
            }
            else
            {
                Passive = PassiveType.Passive;
                Color = Color.Green;
            }
            PassiveDistance = Passive == PassiveType.UltPassive ? 400 : 200;
        }

 private static void OnGapcloser(AIHeroClient sender, Gapcloser.GapcloserEventArgs e)
 {
     if (sender.IsEnemy && sender.IsValidTarget(SpellManager.E.Range) && SpellManager.E.IsInRange(sender) && SpellManager.E.IsReady() && Config.Modes.Misc.UseEGC)
     {
         SpellManager.E.Cast(sender);
     }
 }

        /// <summary>
        /// Uses MEC to get the perfect position on Circle Skillshots
        /// </summary>
        /// <param name="spell">Give it a spell and it will do the rest of the logic for you</param>
        /// <param name="targetHero">If you give it a target it will look around that target for other targets but will always focus that target</param>
        /// <returns></returns>
        internal static OptimizedLocation? GetOptimizedCircleLocation(Spell.Skillshot spell,
            AIHeroClient targetHero = null)
        {
            if (targetHero != null)
            {
                if (!targetHero.IsValidTarget(spell.Range + spell.Radius))
                    return null;

                var champs =
                    EntityManager.Heroes.Enemies.Where(e => e.Distance(targetHero) < spell.Radius)
                        .Select(
                            champ =>
                                Prediction.Position.PredictUnitPosition(champ,
                                    ((int)Player.Instance.Distance(champ) / spell.Speed) + spell.CastDelay))
                        .ToList();
                return GetOptimizedCircleLocation(champs, spell.Width, spell.Range);
            }
            if (EntityManager.Heroes.Enemies.Any(e => e.Distance(Player.Instance) < spell.Radius + spell.Range))
            {
                var champs =
                    EntityManager.Heroes.Enemies.Where(e => e.Distance(Player.Instance) < spell.Radius + spell.Range)
                        .Select(
                            champ =>
                                Prediction.Position.PredictUnitPosition(champ,
                                    ((int)Player.Instance.Distance(champ) / spell.Speed) + spell.CastDelay)).ToList();

                return GetOptimizedCircleLocation(champs, spell.Width, spell.Range);
            }
            return null;
        }

        public static float GetTotalDamage(AIHeroClient target)
        {
            // Auto attack
            var damage = Player.Instance.GetAutoAttackDamage(target);

            // Q
            if (SpellManager.Q.IsReady())
            {
                damage += SpellManager.Q.GetRealDamage(target);
            }

            // W
            if (SpellManager.W.IsReady())
            {
                damage += SpellManager.W.GetRealDamage(target);
            }

            // E
            if (SpellManager.E.IsReady())
            {
                damage += SpellManager.E.GetRealDamage(target);
            }

            // R
            if (SpellManager.R.IsReady() || SpellManager.IsCastingUlt)
            {
                damage += SpellManager.R.GetRealDamage(target) * (SpellManager.IsCastingUlt ? SpellManager.ChargesRemaining : SpellManager.MaxCharges);
            }

            return damage;
        }

 public static void CastOffensiveItems(AIHeroClient target)
 {
     foreach (var item in OffensiveItems.Where(i => i.IsReady() && target.IsValidTarget(i.Range)))
     {
         item.Cast(target);
     }
 }

 /// <summary>
 ///     Gets Prediction result
 /// </summary>
 /// <param name="target">Target for spell</param>
 /// <param name="radius">Spell radius</param>
 /// <param name="ringRadius">Ring radius</param>
 /// <param name="delay">Spell delay</param>
 /// <param name="missileSpeed">Spell missile speed</param>
 /// <param name="range">Spell range</param>
 /// <param name="collisionable">Spell collisionable</param>
 /// <returns>Prediction result as <see cref="Prediction.Result" /></returns>
 public static Prediction.Result GetPrediction(AIHeroClient target, float radius, float ringRadius, float delay,
     float missileSpeed, float range, bool collisionable)
 {
     return GetPrediction(target, radius, ringRadius, delay, missileSpeed, range, collisionable,
         target.GetWaypoints(), target.AvgMovChangeTime(), target.LastMovChangeTime(), target.AvgPathLenght(),
         ObjectManager.Player.ServerPosition.LSTo2D(), ObjectManager.Player.ServerPosition.LSTo2D());
 }

 public SummonerItems(AIHeroClient myHero)
 {
     player = myHero;
     sumBook = player.Spellbook;
     ignite = player.GetSpellSlot("summonerdot");
     smite = player.GetSpellSlot("SummonerSmite");
 }

        private static void OnGapcloser(AIHeroClient sender, Gapcloser.GapcloserEventArgs e)
        {
            if (!sender.IsEnemy) return;

            if (Return.UseRGapclose && Spells.R.IsReady() && sender.IsValidTarget(Spells.R.Range))
                Spells.R.Cast(sender);
        }

 private static bool dangerousSpell(SpellData spellData, AIHeroClient sender)
 {
     var slot = sender.GetSpellSlotFromName(spellData.Name);
     var enemies = EntityManager.Heroes.Enemies;
     int j2 = 0;
     for (int j = 0; j < enemies.Count(); j++)
     {
         if (sender.NetworkId == enemies[j].NetworkId)
         {
             j2 = j;
             break;
         }
     }
     int i = 0;
     switch (slot)
     {
         case SpellSlot.Q:
             i = 0;
             break;
         case SpellSlot.W:
             i = 1;
             break;
         case SpellSlot.E:
             i = 2;
             break;
         case SpellSlot.R:
             i = 3;
             break;
     }
     if (Settings._skills[j2 * 4 + i].CurrentValue)
         return true;
     return false;
 }

        public static float GetTotalDamage(AIHeroClient target)
        {
            // Auto attack
            var damage = Program.Player.GetAutoAttackDamage(target);

            // Q
            if (Program.Q.IsReady())
            {
                damage += Program.Q.GetRealDamage(target);
            }

            // W
            if (Program.W.IsReady())
            {
                damage += Program.W.GetRealDamage(target);
            }

            // E
            if (Program.E.IsReady())
            {
                damage += Program.E.GetRealDamage(target);
            }

            // R
            if (Program.R.IsReady())
            {
                damage += Program.R.GetRealDamage(target);
            }

            return damage;
        }

 private static void Gapcloser_OnGapcloser(AIHeroClient sender, Gapcloser.GapcloserEventArgs e)
 {
     if (sender.IsEnemy && sender.IsValidTarget(E.Range) && sender != null && e != null)
     {
         E.Cast(sender);
     }
 }

        public static bool HasSpellShield(AIHeroClient unit)
        {
            if (ObjectManager.Player.HasBuffOfType(BuffType.SpellShield))
            {
                return true;
            }

            if (ObjectManager.Player.HasBuffOfType(BuffType.SpellImmunity))
            {
                return true;
            }

            //TODO:
            ////Sivir E
            //if (unit.LastCastedSpellName() == "SivirE" && (EvadeUtils.TickCount - Evade.lastSpellCastTime) < 300)
            //{
            //    return true;
            //}

            ////Morganas E
            //if (unit.LastCastedSpellName() == "BlackShield" && (EvadeUtils.TickCount - Evade.lastSpellCastTime) < 300)
            //{
            //    return true;
            //}

            ////Nocturnes E
            //if (unit.LastCastedSpellName() == "NocturneShit" && (EvadeUtils.TickCount - Evade.lastSpellCastTime) < 300)
            //{
            //    return true;
            //}
            return false;
        }

 public override float GetDamage(AIHeroClient enemy)
 {
     var baseDamage = base.GetDamage(enemy);
     return enemy.HasBuff("brandablaze") || _brandE.CanBeCast() && enemy.LSDistance(ObjectManager.Player) < 650
         ? baseDamage*1.25f
         : baseDamage;
 }