Beispiel #1
0
// Flee Mode

        private static void Flee()
        {
            if (E.IsReady())
            {
                var cursorPos = Game.CursorPos;
                var castPos   = Player.Instance.Position.Distance(cursorPos) <= E.Range ? cursorPos : Player.Instance.Position.Extend(cursorPos, E.Range).To3D();
                Player.CastSpell(SpellSlot.E, Game.CursorPos);
            }
        }
Beispiel #2
0
 public static float RDamage(Obj_AI_Base target)
 {
     if (R.IsReady())
     {
         return(Player.Instance.CalculateDamageOnUnit(target, DamageType.Magical,
                                                      new[] { 0f, 80f, 145f, 210f }[R.Level] +0.4f * ObjectManager.Player.TotalMagicalDamage));
     }
     return(0f);
 }
Beispiel #3
0
 public static float WDamage(Obj_AI_Base target)
 {
     if (W.IsReady())
     {
         return(Player.Instance.CalculateDamageOnUnit(target, DamageType.Magical,
                                                      new[] { 0f, 65f, 95f, 125f, 155f, 185f }[W.Level] +0.55f * Player.Instance.TotalMagicalDamage));
     }
     return(0f);
 }
Beispiel #4
0
        public static void Flee()
        {
            var fleeW = MiscMenu["FleeW"].Cast <CheckBox>().CurrentValue;

            if (fleeW && W.IsReady())
            {
                W.Cast();
            }
        }
Beispiel #5
0
        public static double CalcDmg(Obj_AI_Base target, bool useR, bool onlyR)
        {
            if (target == null)
            {
                return(0);
            }

            double dmg = 0;

            double[] passivedmg = { 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5 };
            if (UseItem(true, false))
            {
                dmg = dmg + Riven.Player.GetAutoAttackDamage(target) * 0.7;
            }

            if (W.IsReady() && GetOption(Riven.CMenu, "w"))
            {
                dmg = dmg + Riven.Player.GetSpellDamage(target, SpellSlot.W);
            }

            if (Q.IsReady() && GetOption(Riven.CMenu, "q"))
            {
                dmg = dmg + Riven.Player.GetSpellDamage(target, SpellSlot.Q) * 3
                      + Riven.Player.GetAutoAttackDamage(target) * 3 * (1 + passivedmg[Riven.Player.Level / 3]);
            }

            dmg = dmg + Riven.Player.GetAutoAttackDamage(target) * (1 + passivedmg[Riven.Player.Level / 3]) * 2;
            if (R2.IsReady() && useR)
            {
                double health = target.Health;
                if (!onlyR)
                {
                    if (Riven.CanR2())
                    {
                        health = target.Health - (dmg * 1.2);
                    }
                    else if (!Riven.CanR2())
                    {
                        health = target.Health - dmg;
                    }
                }

                var missinghealth = (target.MaxHealth - health) / target.MaxHealth > 0.75
                                        ? 0.75
                                        : (target.MaxHealth - health) / target.MaxHealth;
                var pluspercent = missinghealth * (8.0 / 3.0);

                var rawdmg = new double[] { 80, 120, 160 }[R.Level - 1] +0.6 * Riven.Player.FlatPhysicalDamageMod;
                return(Riven.Player.CalculateDamageOnUnit(
                           target,
                           DamageType.Physical,
                           (float)(rawdmg * (1 + pluspercent))));
            }

            return(dmg);
        }
Beispiel #6
0
        public override void Harass()
        {
            var enemiesBeingE =
                EntityManager.Heroes.Enemies.Where(t => t.IsValidTarget(E.Range) && IsBeingE(t))
                .ToArray();

            if (!Q.IsLearned)
            {
                if (!enemiesBeingE.Any() && WReturn.IsReady() && HarassMenu.CheckBoxValue("usereturn") &&
                    Player.Instance.Spellbook.GetSpell(SpellSlot.W).Name.ToLower() == "leblancslidereturn")
                {
                    WReturn.Cast();
                }

                var wTarget = TargetSelector.GetTarget(W.Range, DamageType.Magical, Player.Instance.Position);

                if (wTarget != null && HarassMenu.CheckBoxValue(SpellSlot.W) && !Q.IsLearned && W.IsReady() &&
                    Player.Instance.Spellbook.GetSpell(SpellSlot.W).Name.ToLower() == "leblancslide")
                {
                    W.Cast(wTarget);
                }

                var eTarget = TargetSelector.GetTarget(E.Range, DamageType.Magical, Player.Instance.Position);

                if (eTarget != null && HarassMenu.CheckBoxValue(SpellSlot.E) && !Q.IsLearned && E.IsReady())
                {
                    E.Cast(eTarget);
                }
            }

            var target = TargetSelector.GetTarget(Q.Range, DamageType.Magical, Player.Instance.Position);

            if (target == null)
            {
                return;
            }

            if (HarassMenu.CheckBoxValue(SpellSlot.Q) && Q.IsReady() && Q.IsInRange(target))
            {
                Q.Cast(target);
            }

            if (HarassMenu.CheckBoxValue(SpellSlot.W) && !Q.IsReady() && W.IsReady() &&
                Player.Instance.Spellbook.GetSpell(SpellSlot.W).Name.ToLower() == "leblancslide" &&
                IsMarked(target))
            {
                W.Cast(target);
            }

            if (HarassMenu.CheckBoxValue(SpellSlot.E) &&
                (Player.Instance.Spellbook.GetSpell(SpellSlot.W).Name.ToLower() == "leblancslidereturn" ||
                 !W.IsReady()) && E.IsReady() && E.IsInRange(target))
            {
                E.Cast(target);
            }
        }
Beispiel #7
0
 public static float EDamage(Obj_AI_Base target)
 {
     if (E.IsReady())
     {
         return(Player.Instance.CalculateDamageOnUnit(target, DamageType.Magical,
                                                      new[] { 0f, 42.5f, 62.5f, 82.5f, 102.5f, 122.5f }[E.Level] +
                                                      0.3f * ObjectManager.Player.TotalMagicalDamage));
     }
     return(0f);
 }
Beispiel #8
0
 private static void Gapcloser_OnGapcloser(AIHeroClient sender, Gapcloser.GapcloserEventArgs e)
 {
     if (MiscMenu["antiG"].Cast <CheckBox>().CurrentValue&& E.IsReady())
     {
         if (e.Sender.IsValidTarget(E.Range))
         {
             E.Cast();
         }
     }
 }
Beispiel #9
0
 static void Orbwalker_OnPostAttack(AttackableUnit target, EventArgs args)
 {
     if (W.IsReady() && UseW && target != null)
     {
         if ((Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo) && target.Distance(ObjectManager.Player.ServerPosition) <= ObjectManager.Player.AttackRange && (target is AIHeroClient)) || (isClear == true && getSliderItem(LaneClearMenu, "mana") <= Player.Instance.ManaPercent) && (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.LaneClear) || Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.JungleClear)))
         {
             W.Cast();
         }
     }
 }
Beispiel #10
0
 private static void Spellbook_OnCastSpell(Spellbook spellbook, SpellbookCastSpellEventArgs args)
 {
     Hero.Buffs.ForEach(x => Console.WriteLine(x.Name));
     if (args.Slot == SpellSlot.Recall && QRecall.CurrentValue && Q.IsReady() && !Hero.HasBuff("globalcamouflage"))
     {
         Q.Cast();
         args.Process = true;
         return;
     }
 }
Beispiel #11
0
 public static void OnBasicAttack(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
 {
     if (!sender.IsMe || !(args.Target is AIHeroClient) || !Q.IsReady() || !Player.CanAttack || !GetOption(OMenu, "C"))
     {
         return;
     }
     Q.Cast();
     Orbwalker.ResetAutoAttack();
     EloBuddy.Player.IssueOrder(GameObjectOrder.AttackTo, args.Target);
 }
Beispiel #12
0
 public static void OnAfterAttack(AttackableUnit target, EventArgs args)
 {
     if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo) && target.IsValid)
     {
         if (W.IsReady() && IreliaTheTrollMenu.ComboW())
         {
             W.Cast();
         }
     }
 }
Beispiel #13
0
 private static void Event_OnPostAttack(AttackableUnit target, EventArgs args)
 {
     if (QInCombo && Orbwalker.ActiveModesFlags == Orbwalker.ActiveModes.Combo && ArgsQ.IsReady() &&
         target.Type == GameObjectType.AIHeroClient && CountEnemiesInRange(ScanRange) >= MinEnemiesForQ)
     {
         ArgsQ.Cast();
     }
     _aacancelpossible = true;
     Core.DelayAction(() => _aacancelpossible = false, 100);
 }
Beispiel #14
0
 private static void auto_baseQ(Spellbook sender, SpellbookCastSpellEventArgs eventArgs)
 {
     if (eventArgs.Slot != SpellSlot.Recall || !_q.IsReady() || !_misc["autob2"].Cast <CheckBox>().CurrentValue || !_misc["autob"].Cast <KeyBind>().CurrentValue)
     {
         return;
     }
     _q.Cast();
     Core.DelayAction(() => ObjectManager.Player.Spellbook.CastSpell(SpellSlot.Recall), _q.CastDelay + 300);
     eventArgs.Process = false;
 }
Beispiel #15
0
        public static void Item()
        {
            var item   = Misc["BOTRK"].Cast <CheckBox>().CurrentValue;
            var Minhp  = Misc["ihp"].Cast <Slider>().CurrentValue;
            var Minhpp = Misc["ihpp"].Cast <Slider>().CurrentValue;
            var useR   = Autos["AutoR"].Cast <CheckBox>().CurrentValue;
            var MinR   = Autos["mauR"].Cast <Slider>().CurrentValue;
            var useE   = Autos["AutoE"].Cast <CheckBox>().CurrentValue;
            var MinE   = Autos["minE"].Cast <Slider>().CurrentValue;

            foreach (var targeti in EntityManager.Heroes.Enemies.Where(e => e.IsValidTarget(475) && !e.IsDead))
            {
                if (item && Bil.IsReady() && Bil.IsOwned() && Bil.IsInRange(targeti))
                {
                    Bil.Cast(targeti);
                }

                if ((item && Botrk.IsReady() && Botrk.IsOwned() && targeti.IsValidTarget(475)) && (Player.Instance.HealthPercent <= Minhp || targeti.HealthPercent < Minhpp))
                {
                    Botrk.Cast(targeti);
                }
            }

            if (useR && R.IsReady() && _Player.Position.CountEnemyChampionsInRange(Q.Range) >= 1 && Player.Instance.HealthPercent <= MinR)
            {
                R.Cast();
            }

            if (useE && E.IsReady() && _Player.Position.CountEnemyChampionsInRange(E.Range) >= MinE)
            {
                E.Cast();
            }
        }
Beispiel #16
0
        public static void Obj_AI_Turret_OnBasicAttack(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
        {
            if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.LastHit) && sender is Obj_AI_Turret && sender.Distance(Player.Instance) < 1000 && sender.IsAlly)
            {
                if (!(args.Target is AIHeroClient))
                {
                    var Minions = EntityManager.MinionsAndMonsters.GetLaneMinions(EntityManager.UnitTeam.Enemy, Player.Instance.Position, Q.Range + 1000);
                    foreach (var Minion in Minions)
                    {
                        if (Minion.IsValidTarget(175) && !Minion.IsDead && Minion == args.Target)
                        {
                            if (Q.IsReady())
                            {
                                if (Minion.Health > Player.Instance.TotalAttackDamage && Minion.Health - sender.TotalAttackDamage <= 0)
                                {
                                    Player.IssueOrder(GameObjectOrder.AttackUnit, Minion);
                                    Core.DelayAction(() => Player.CastSpell(SpellSlot.Q), 291);
                                    Chat.Print("Last Hitting With AA-Q");
                                }
                            }

                            else if (W.IsReady())
                            {
                                if (Minion.Health > Player.Instance.TotalAttackDamage && Minion.Health - sender.TotalAttackDamage <= 0)
                                {
                                    Player.IssueOrder(GameObjectOrder.AttackUnit, Minion);
                                    Core.DelayAction(() => Player.CastSpell(SpellSlot.W), 291);
                                    Chat.Print("Last Hitting With AA-W");
                                }
                            }
                            else if (E.IsReady())
                            {
                                if (Minion.Health > Player.Instance.TotalAttackDamage && Minion.Health - sender.TotalAttackDamage <= 0)
                                {
                                    E.Cast(Player.Instance.Position.Extend(Minion.ServerPosition, 200).To3D());
                                    Player.IssueOrder(GameObjectOrder.AttackUnit, Minion);
                                    Core.DelayAction(() => Player.CastSpell(SpellSlot.Q), 291);
                                    Chat.Print("Last Hitting With AA-E-Q");
                                }
                            }
                        }
                        else if (Minion.IsValidTarget(400) && !Minion.IsDead && Minion == args.Target)
                        {
                            if (Minion.Health > Player.Instance.TotalAttackDamage && Minion.Health - sender.TotalAttackDamage <= 0)
                            {
                                E.Cast(Player.Instance.Position.Extend(Minion.ServerPosition, 200).To3D());
                                Player.IssueOrder(GameObjectOrder.AttackUnit, Minion);
                                Core.DelayAction(() => Player.CastSpell(SpellSlot.Q), 291);
                                Chat.Print("Last Hitting With AA-E-Q");
                            }
                        }
                    }
                }
            }
        }
Beispiel #17
0
        public static void Combo()
        {
            var useQ  = ComboMenu["ComboQ"].Cast <CheckBox>().CurrentValue;
            var useW  = ComboMenu["ComboW"].Cast <CheckBox>().CurrentValue;
            var useE  = ComboMenu["ComboE"].Cast <CheckBox>().CurrentValue;
            var useR  = ComboMenu["ComboR"].Cast <CheckBox>().CurrentValue;
            var useR2 = ComboMenu["ComboR2"].Cast <CheckBox>().CurrentValue;
            var MinR  = ComboMenu["MinR"].Cast <Slider>().CurrentValue;

            foreach (var target in EntityManager.Heroes.Enemies.Where(e => e.IsValidTarget(R.Range) && !e.IsDead))
            {
                if (useR2 && R.IsReady() && target.IsValidTarget(R.Range))
                {
                    var pred = R.GetPrediction(target);
                    if (pred.CastPosition.CountEnemyChampionsInRange(350) >= MinR && pred.HitChance >= HitChance.High)
                    {
                        R.Cast(pred.CastPosition);
                    }
                }

                if (useQ && Q.IsReady() && target.IsValidTarget(Q.Range) && !EActive)
                {
                    Q.Cast(target);
                }

                if (useW && W.IsReady() && target.IsValidTarget(E.Range))
                {
                    if (EActive && _Player.Distance(target) <= 375)
                    {
                        W.Cast();
                    }
                    else if (target.IsValidTarget(325))
                    {
                        W.Cast();
                    }
                }

                if (useE && E.IsReady() && target.IsValidTarget(E.Range) && !EActive)
                {
                    E.Cast();
                }

                if (useR && R.IsReady() && target.IsValidTarget(R.Range))
                {
                    if (QDamage(target) * 2 + RDamage(target) + EDamage(target) >= target.Health)
                    {
                        var pred1 = R.GetPrediction(target);
                        if (pred1.HitChance >= HitChance.Medium)
                        {
                            R.Cast(pred1.CastPosition);
                        }
                    }
                }
            }
        }
Beispiel #18
0
 public override void LaneClear()
 {
     foreach (var target in EntityManager.MinionsAndMonsters.EnemyMinions.Where(m => m != null && m.IsKillable()))
     {
         if (Q.IsReady() && LaneClearMenu.CheckBoxValue("r" + SpellSlot.Q) && Player.Instance.Spellbook.GetSpell(SpellSlot.R).Name.ToLower() == "leblancchaosorbm")
         {
             QUltimate.Cast(target);
         }
     }
     foreach (var target in EntityManager.MinionsAndMonsters.EnemyMinions.Where(m => m != null && m.IsKillable()))
     {
         if (Q.IsReady() && LaneClearMenu.CheckBoxValue(SpellSlot.Q))
         {
             Q.Cast(target);
         }
     }
     foreach (
         var circFarmLoc in
         EntityManager.MinionsAndMonsters.EnemyMinions.Where(m => m != null && m.IsKillable(1000)).Select(
             target =>
             EntityManager.MinionsAndMonsters.GetCircularFarmLocation(
                 EntityManager.MinionsAndMonsters.EnemyMinions.Where(m => m.IsKillable(W.Range)),
                 W.SetSkillshot().Width, (int)W.Range))
         .Where(
             circFarmLoc =>
             W.IsReady() && circFarmLoc.HitNumber > 1 && LaneClearMenu.CheckBoxValue(SpellSlot.W) &&
             LaneClearMenu.CompareSlider(W.Slot + "mana", user.ManaPercent) && Player.Instance.Spellbook.GetSpell(SpellSlot.W).Name.ToLower() == "leblancslide"))
     {
         W.Cast(circFarmLoc.CastPosition);
     }
     if (LaneClearMenu.CheckBoxValue(SpellSlot.W) && WReturn.IsReady() &&
         Player.Instance.Spellbook.GetSpell(SpellSlot.W).Name.ToLower() == "leblancslidereturn")
     {
         WReturn.Cast();
     }
     foreach (
         var circFarmLoc in
         EntityManager.MinionsAndMonsters.EnemyMinions.Where(m => m != null && m.IsKillable(1000)).Select(
             target =>
             EntityManager.MinionsAndMonsters.GetCircularFarmLocation(
                 EntityManager.MinionsAndMonsters.EnemyMinions.Where(m => m.IsKillable(WUltimate.Range)),
                 WUltimate.SetSkillshot().Width, (int)WUltimate.Range))
         .Where(
             circFarmLoc =>
             WUltimate.IsReady() && circFarmLoc.HitNumber > 1 && LaneClearMenu.CheckBoxValue("r" + SpellSlot.W) &&
             Player.Instance.Spellbook.GetSpell(SpellSlot.R).Name.ToLower() == "leblancslide"))
     {
         WUltimate.Cast(circFarmLoc.CastPosition);
     }
     if (LaneClearMenu.CheckBoxValue("r" + SpellSlot.W) && RReturn.IsReady() &&
         Player.Instance.Spellbook.GetSpell(SpellSlot.R).Name.ToLower() == "leblancslidereturn")
     {
         RReturn.Cast();
     }
 }
Beispiel #19
0
        public void OnLaneClear()
        {
            if (Player.Instance.ManaPercent < Misc.GetSliderValue(LaneClearMenu, "minManaPercent"))
            {
                return;
            }

            if (Misc.IsChecked(LaneClearMenu, "lcQ") && Q.IsReady())
            {
            }
        }
Beispiel #20
0
        public static float FullDamage(Obj_AI_Base target)
        {
            float damage = 0;

            damage += Q.IsReady() ? QDamage(target) : 0;
            damage += R.IsReady() ? RDamage(target) : 0;
            damage += Orbwalker.CanAutoAttack ? _player.GetAutoAttackDamage(target)
                      * MenuManager.Rendering.GetSliderValue("aa_dmg") : 0;

            return(damage);
        }
Beispiel #21
0
 static void BeforeAttack(AttackableUnit target, Orbwalker.PreAttackArgs args)
 {
     if (args.Target.Type == GameObjectType.obj_AI_Minion && (_MiscAA.CurrentValue && AlliesInRange(1500) > 0 || _MiscMinionAA.CurrentValue && Player.HasBuff("sonapassiveattack")))
     {
         args.Process = false;
     }
     if (Player.HasBuff("sonapassiveattack") && (Q.IsReady(1500) || LastCastSpell != "SonaQ"))
     {
         args.Process = false;
     }
 }
Beispiel #22
0
        private static void AAResetCombo()
        {
            var target = TargetSelector.GetTarget(E.Range, DamageType.Magical);

            // Q Combo
            if (ComboMenu["Q"].Cast <CheckBox>().CurrentValue&& Q.IsReady() && target.IsValidTarget() && target.IsInRange(target, Q.Range))
            {
                Q.Cast(target);
                Orbwalker.ResetAutoAttack();
            }
        }
Beispiel #23
0
 protected override void Volatile_AntiGapcloser(AIHeroClient sender, Gapcloser.GapcloserEventArgs e)
 {
     if (SpellMenu["wtosafe"].Cast <CheckBox>().CurrentValue&& W.IsReady() && sender.IsEnemy &&
         Player.Position.Extend(Game.CursorPos, Q.Range).CountEnemiesInRange(400) < 3)
     {
         if (sender.IsValidTarget(E.Range))
         {
             W.Cast();
         }
     }
 }
Beispiel #24
0
        static void Obj_AI_Base_OnSpellCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
        {
            if (!sender.IsMe)
            {
                return;
            }
            //Utils.Debug(args.SData.Name);
            if (args.SData.Name == R1)
            {
                forceR1 = false;
            }
            if (args.Slot == SpellSlot.R && args.SData.Name != R1)
            {
                forceR2 = false;
            }

            if (!Q.IsReady())
            {
                return;
            }
            if (args.Slot == SpellSlot.W)
            {
                forceW = false;
                if (Orbwalker.LastTarget != null && Orbwalker.LastTarget.IsValidTarget())
                {
                    if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo))
                    {
                        Core.DelayAction(() => Player.CastSpell(SpellSlot.Q, Orbwalker.LastTarget.Position), 1);
                    }
                    if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.JungleClear))
                    {
                        Core.DelayAction(() => Player.CastSpell(SpellSlot.Q, Orbwalker.LastTarget.Position), 1);
                    }
                }
                return;
            }
            if (args.SData.Name == "ItemTiamatCleave")
            {
                if (Orbwalker.LastTarget != null && Orbwalker.LastTarget.IsValidTarget())
                {
                    if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo))
                    {
                        //Utils.Debug("CAST Q");
                        Core.DelayAction(() => Player.CastSpell(SpellSlot.Q, Orbwalker.LastTarget.Position), 1);
                    }
                    if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.JungleClear))
                    {
                        //Utils.Debug("CAST Q");
                        Core.DelayAction(() => Player.CastSpell(SpellSlot.Q, Orbwalker.LastTarget.Position), 1);
                    }
                }
                return;
            }
        }
Beispiel #25
0
 private static void OnFlee()
 {
     if (W.IsReady() && Player.ManaPercent >= MissInopportuneMenu.FleeM())
     {
         W.Cast();
     }
     if (E.IsReady() && Player.HealthPercent <= MissInopportuneMenu.FleeHP())
     {
         E.Cast(Target.ServerPosition);
     }
 }
Beispiel #26
0
        /// <summary>
        ///     Determines whether the skills is enabled and ready.
        /// </summary>
        /// <param name="Spell">The spell.</param>
        /// <param name="checkMana">if set to <c>true</c> also checks for the mana condition.</param>
        /// <returns></returns>
        public static bool IsEnabledAndReady(this Spell.Active Spell, bool checkMana = true)
        {
            if (!Spell.IsReady())
            {
                return(false);
            }

            var readyCondition = Spell.IsReady();

            return(readyCondition);
        }
Beispiel #27
0
        public static void Ecast()
        {
            var MinE   = ComboMenu["minE"].Cast <Slider>().CurrentValue;
            var ComboE = ComboMenu["ComboE"].Cast <CheckBox>().CurrentValue;



            if (ComboE && E.IsReady() && _Player.Position.CountEnemyChampionsInRange(E.Range) >= MinE)
            {
                E.Cast();
            }
        }
Beispiel #28
0
        private static void Combo()
        {
            var useQ  = ComboMenu["useQ"].Cast <CheckBox>().CurrentValue;
            var useW  = ComboMenu["useW"].Cast <CheckBox>().CurrentValue;
            var useR  = ComboMenu["useR"].Cast <CheckBox>().CurrentValue;
            var waitP = ComboMenu["countP"].Cast <CheckBox>().CurrentValue;
            var minHp = ComboMenu["hpPercent"].Cast <Slider>().CurrentValue;

            if (Q.IsReady() && useQ)
            {
                var targetq = TargetSelector.GetTarget(600, DamageType.Physical);

                if (targetq.IsValidTarget(600))
                {
                    if (Me.GetBuffCount("asheqcastready") >= 4)
                    {
                        Q.Cast();
                    }
                }
            }

            if (W.IsReady() && useW)
            {
                var targetw = TargetSelector.GetTarget(W.Range, DamageType.Physical);
                var predW   = W.GetPrediction(targetw);

                if (targetw.IsValidTarget(W.Range))
                {
                    if (predW.HitChance >= HitChance.Medium)
                    {
                        W.Cast(predW.CastPosition);
                    }
                }
            }

            if (R.IsReady() && useR)
            {
                var targetr = TargetSelector.GetTarget(R.Range, DamageType.Magical);
                var predR   = R.GetPrediction(targetr);
                {
                    if (targetr.IsValidTarget(R.Range))
                    {
                        if (targetr.HealthPercent <= minHp)
                        {
                            if (predR.HitChance >= HitChance.Medium)
                            {
                                R.Cast(predR.CastPosition);
                            }
                        }
                    }
                }
            }
        }
Beispiel #29
0
        private static void OnLaneClear()
        {
            var count =
                EntityManager.MinionsAndMonsters.GetLaneMinions(EntityManager.UnitTeam.Enemy, Player.ServerPosition,
                                                                Player.AttackRange, false).Count();
            var tawah  = EntityManager.Turrets.Enemies.FirstOrDefault(t => !t.IsDead && t.IsInRange(Player, 800));
            var source =
                EntityManager.MinionsAndMonsters.GetLaneMinions(EntityManager.UnitTeam.Enemy, Player.ServerPosition,
                                                                Player.AttackRange).OrderByDescending(a => a.MaxHealth).FirstOrDefault();
            var sourceE =
                EntityManager.MinionsAndMonsters.GetLaneMinions()
                .FirstOrDefault(m => m.IsValidTarget(Player.AttackRange) && m.GetBuffCount("tristanaecharge") > 0);

            if (count == 0)
            {
                return;
            }
            if (E.IsReady() && TristanaMenu.LcE() && source.IsValidTarget(E.Range) &&
                Player.ManaPercent >= TristanaMenu.LcM())
            {
                E.Cast(source);
                Orbwalker.ForcedTarget = sourceE;
            }
            if (Q.IsReady() && TristanaMenu.LcQ() && source.IsValidTarget(Q.Range) &&
                Player.ManaPercent >= TristanaMenu.LcM())
            {
                Q.Cast();
            }
            if (W.IsReady() && TristanaMenu.LcW() && TristanaMenu.LcW1() <= count &&
                Player.ManaPercent >= TristanaMenu.LcM())
            {
                if (source != null)
                {
                    W.Cast(source.Position);
                }
            }
            if (tawah == null)
            {
                return;
            }
            if (TristanaMenu.LcE1() && tawah.IsInRange(Player, E.Range) && E.IsReady() &&
                Player.ManaPercent >= TristanaMenu.LcM())
            {
                E.Cast(tawah);
                Q.Cast();
            }

            if (TristanaMenu.LcQ() && tawah.IsInRange(Player, Q.Range) && Q.IsReady() &&
                Player.ManaPercent >= TristanaMenu.LcM())
            {
                Q.Cast();
            }
        }
Beispiel #30
0
 private static void OnPostAttack(AttackableUnit Target, EventArgs args)
 {
     if (W.IsReady() && _Player.Distance(Target) <= W.Range)
     {
         if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo))
         {
             W.Cast();
             Orbwalker.ResetAutoAttack();
             Player.IssueOrder(GameObjectOrder.AttackTo, Target);
         }
     }
 }
Beispiel #31
0
        public override void Init()
        {
            try
            {
                try
                {
                    #region Spells
                    // Defining Spells
                    _q = new Spell.Targeted(SpellSlot.Q, 675);
                    _w = new Spell.Active(SpellSlot.W, 375);
                    _e = new Spell.Targeted(SpellSlot.E, 700);
                    _r = new Spell.Active(SpellSlot.R, 550);
                    #endregion
                }
                catch (Exception e)
                {
                    Console.WriteLine(e);
                    Chat.Print("<font color='#23ADDB'>Marksman AIO:</font><font color='#E81A0C'> an error ocurred. (Code SPELL)</font>");
                }

                try
                {
                    #region Menu
                    var combo = MainMenu._combo;
                    string[] s = { "QEWR", "EQWR" };

                    combo.AddStringList("combo.mode", "Mode: ", s, 1);
                    MainMenu.ComboKeys(true, true, true, true);
                    MainMenu.HarassKeys(true, true, true, true);
                    MainMenu._harass.Add("harass.autow", new CheckBox("Use Auto W"));
                    MainMenu._harass.Add("harass.donteunderturret", new CheckBox("Dont E Under Turret"));

                    MainMenu.FleeKeys(false, false, true, false);
                    MainMenu._flee.Add("flee.ward", new CheckBox("Use Wardjump"));

                    MainMenu.LaneKeys(true, true, true, false);
                    MainMenu._lane.Add("lane.donteunderturret", new CheckBox("Dont E Under Turret"));

                    MainMenu.LastHitKeys(true, true, true, false);
                    MainMenu._lasthit.Add("lasthit.donteunderturret", new CheckBox("Dont E Under Turret"));

                    MainMenu.KsKeys(true, true, true, true);
                    MainMenu._ks.Add("killsteal.ignite", new CheckBox("Use Ignite"));
                    MainMenu._ks.Add("killsteal.donteunderturret", new CheckBox("Dont E Under Turret"));

                    MainMenu.DamageIndicator();
                    MainMenu.DrawKeys(true, true, true, true);
                    MainMenu._draw.AddSeparator();

                    MainMenu._draw.AddGroupLabel("Flash Settings");
                    MainMenu._draw.Add("draw.flash", new CheckBox("Draw flash"));
                    MainMenu._draw.AddColorItem("color.flash");
                    MainMenu._draw.AddWidthItem("width.flash");
                    MainMenu._draw.AddSeparator();

                    MainMenu._draw.AddGroupLabel("Ignite Settings");
                    MainMenu._draw.Add("draw.ignite", new CheckBox("Draw ignite"));
                    MainMenu._draw.AddColorItem("color.ignite");
                    MainMenu._draw.AddWidthItem("width.ignite");

                    _humanizerMenu = MainMenu._menu.AddSubMenu("Humanizer Menu");
                    _humanizerMenu.AddGroupLabel("Q Settings");
                    _humanizerMenu.Add("min.q", new Slider("Min Q Delay", 0, 0, 50));
                    _humanizerMenu.Add("max.q", new Slider("Max Q Delay", 0, 0, 50));
                    _humanizerMenu.AddSeparator(10);

                    _humanizerMenu.AddGroupLabel("W Settings");
                    _humanizerMenu.Add("min.w", new Slider("Min W Delay", 0, 0, 50));
                    _humanizerMenu.Add("max.w", new Slider("Max W Delay", 0, 0, 50));
                    _humanizerMenu.AddSeparator(10);

                    _humanizerMenu.AddGroupLabel("E Settings");
                    _humanizerMenu.Add("min.e", new Slider("Min E Delay", 0, 0, 50));
                    _humanizerMenu.Add("max.e", new Slider("Max E Delay", 0, 0, 50));
                    _humanizerMenu.AddSeparator(10);

                    _humanizerMenu.AddGroupLabel("R Settings");
                    _humanizerMenu.Add("min.r", new Slider("Min R Delay", 4, 0, 50));
                    _humanizerMenu.Add("max.r", new Slider("Max R Delay", 4, 0, 50));
                    _humanizerMenu.AddSeparator(10);

                    #endregion
                }

                catch (Exception e)
                {
                    Console.WriteLine(e);
                    Chat.Print("<font color='#23ADDB'>Marksman AIO:</font><font color='#E81A0C'> an error ocurred. (Code MENU)</font>");
                }

                #region UtilityInit
                DamageIndicator.DamageToUnit = GetActualRawComboDamage;
                Value.Init();
                Value.MenuList.Add(_humanizerMenu);
                Drawing.OnDraw += DrawRanges;

                #region MenuValueChange
                _humanizerMenu["min.q"].Cast<Slider>().OnValueChange += delegate
                {
                    if (_humanizerMenu["min.q"].Cast<Slider>().CurrentValue > _humanizerMenu["max.q"].Cast<Slider>().CurrentValue)
                        _humanizerMenu["min.q"].Cast<Slider>().CurrentValue = _humanizerMenu["max.q"].Cast<Slider>().CurrentValue;
                };
                _humanizerMenu["max.q"].Cast<Slider>().OnValueChange += delegate
                {
                    if (_humanizerMenu["max.q"].Cast<Slider>().CurrentValue < _humanizerMenu["min.q"].Cast<Slider>().CurrentValue)
                        _humanizerMenu["max.q"].Cast<Slider>().CurrentValue = _humanizerMenu["min.q"].Cast<Slider>().CurrentValue;
                };
                _humanizerMenu["min.w"].Cast<Slider>().OnValueChange += delegate
                {
                    if (_humanizerMenu["min.w"].Cast<Slider>().CurrentValue > _humanizerMenu["max.w"].Cast<Slider>().CurrentValue)
                        _humanizerMenu["min.w"].Cast<Slider>().CurrentValue = _humanizerMenu["max.w"].Cast<Slider>().CurrentValue;
                };
                _humanizerMenu["max.w"].Cast<Slider>().OnValueChange += delegate
                {
                    if (_humanizerMenu["max.w"].Cast<Slider>().CurrentValue < _humanizerMenu["min.w"].Cast<Slider>().CurrentValue)
                        _humanizerMenu["max.w"].Cast<Slider>().CurrentValue = _humanizerMenu["min.w"].Cast<Slider>().CurrentValue;
                };
                _humanizerMenu["min.e"].Cast<Slider>().OnValueChange += delegate
                {
                    if (_humanizerMenu["min.e"].Cast<Slider>().CurrentValue > _humanizerMenu["max.e"].Cast<Slider>().CurrentValue)
                        _humanizerMenu["min.e"].Cast<Slider>().CurrentValue = _humanizerMenu["max.e"].Cast<Slider>().CurrentValue;
                };
                _humanizerMenu["max.e"].Cast<Slider>().OnValueChange += delegate
                {
                    if (_humanizerMenu["max.e"].Cast<Slider>().CurrentValue < _humanizerMenu["min.e"].Cast<Slider>().CurrentValue)
                        _humanizerMenu["max.e"].Cast<Slider>().CurrentValue = _humanizerMenu["min.e"].Cast<Slider>().CurrentValue;
                };
                _humanizerMenu["min.r"].Cast<Slider>().OnValueChange += delegate
                {
                    if (_humanizerMenu["min.r"].Cast<Slider>().CurrentValue > _humanizerMenu["max.r"].Cast<Slider>().CurrentValue)
                        _humanizerMenu["min.r"].Cast<Slider>().CurrentValue = _humanizerMenu["max.r"].Cast<Slider>().CurrentValue;
                };
                _humanizerMenu["max.r"].Cast<Slider>().OnValueChange += delegate
                {
                    if (_humanizerMenu["max.r"].Cast<Slider>().CurrentValue < _humanizerMenu["min.r"].Cast<Slider>().CurrentValue)
                        _humanizerMenu["max.r"].Cast<Slider>().CurrentValue = _humanizerMenu["min.r"].Cast<Slider>().CurrentValue;
                };
                #endregion
                #endregion
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                Chat.Print("<font color='#23ADDB'>Marksman AIO:</font><font color='#E81A0C'> an error ocurred. (Code 503)</font>");
            }

            Game.OnUpdate += delegate
            {
                try
                {
                    #region AutoW
                    if (MainMenu._harass["harass.autow"].Cast<CheckBox>().CurrentValue)
                    {
                        var e = EntityManager.Heroes.Enemies.Where(ee => !ee.IsDead && ee.IsValid);
                        foreach (var enemy in e)
                        {
                            if (_w.IsInRange(enemy) && _w.IsReady() && !_isUlting)
                            {
                                _w.Cast();
                            }
                        }
                    }
                    #endregion

                    KillSteal();
                }
                catch (Exception e)
                {
                    Console.WriteLine(e);
                    Chat.Print("<font color='#23ADDB'>Marksman AIO:</font><font color='#E81A0C'> san error ocurred. (Code 5)</font>");
                }
                //KillSteal();
            };
        }
Beispiel #32
0
        private static void Game_OnUpdate(EventArgs args)
        {
            if (MobsToSmite["killsmite"].Cast<CheckBox>().CurrentValue)
            {
                var KillEnemy =
                    EntityManager.Heroes.Enemies.FirstOrDefault(hero => hero.IsValidTarget(500f)
                        && SmiteChampDamage() >= hero.Health);
                if (KillEnemy != null)
                    Player.CastSpell(Smite.Slot, KillEnemy);
            }
                if (SmiteGHMenu["active"].Cast<CheckBox>().CurrentValue || SmiteGHMenu["activekey"].Cast<KeyBind>().CurrentValue)
                {
                    double SpellDamage = 0;
                    Monster = GetNearest(ObjectManager.Player.ServerPosition);
                        if (Monster != null && MobsToSmite[Monster.BaseSkinName].Cast<CheckBox>().CurrentValue)
                        {
                            if (SupportedChampions.Contains(ObjectManager.Player.ChampionName))
                            {
                                if (SmiteGHMenu["disable"].Cast<CheckBox>().CurrentValue)
                                {
                                    switch (ObjectManager.Player.ChampionName)
                                    {
                                        #region Diana
                                        case "Diana":
                                            {
                                                Spell.Skillshot Q = new Spell.Skillshot(SpellSlot.Q, (uint)895, SkillShotType.Circular);
                                                Spell.Targeted R = new Spell.Targeted(SpellSlot.R, (uint)825);

                                                //Smite and Spell  ==> OKAY
                                                if (Smite.IsReady() && Q.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Q.Range
                                                    && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    SpellDamage = GetDamages.DianaQ(Q.Level) + GetDamages.DianaR(R.Level);
                                                    TotalDamage = SpellDamage + GetSmiteDamage();
                                                    if (Monster.Health <= TotalDamage)
                                                    {
                                                        Q.Cast(Monster.ServerPosition);
                                                        //Smite.Cast(Monster);
                                                    }
                                                }
                                                else if (Smite.IsReady() && R.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < R.Range
                                                && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range && GetDamages.HasBuffs(Monster, "dianamoonlight"))
                                                {
                                                    SpellDamage = GetDamages.DianaR(R.Level);
                                                    TotalDamage = SpellDamage + GetSmiteDamage();
                                                    if (Monster.Health <= TotalDamage)
                                                    {
                                                        R.Cast(Monster);
                                                        //Smite.Cast(Monster);
                                                    }
                                                }
                                                //If Spell is busy, Go Smite only! ^_^
                                                else if (Smite.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    if (Monster.Health <= GetSmiteDamage())
                                                    {
                                                        Smite.Cast(Monster);
                                                    }
                                                    TotalDamage = 0;
                                                }
                                                break;
                                            }
                                        #endregion
                                        #region Evelynn
                                        case "Evelynn":
                                            {
                                                Spell.Targeted E = new Spell.Targeted(SpellSlot.E, (uint)(225f + 2 * 65f));
                                                //Smite and Spell  ==> OKAY
                                                if (Smite.IsReady() && E.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < E.Range
                                                    && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    SpellDamage = GetDamages.Evelynn(E.Level);
                                                    TotalDamage = SpellDamage + GetSmiteDamage();
                                                    if (Monster.Health <= TotalDamage)
                                                    {
                                                        E.Cast(Monster);
                                                        //Smite.Cast(Monster);
                                                    }
                                                }
                                                //If Spell is busy, Go Smite only! ^_^
                                                else if (Smite.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    if (Monster.Health <= GetSmiteDamage())
                                                    {
                                                        Smite.Cast(Monster);
                                                    }
                                                    TotalDamage = 0;
                                                }
                                                break;
                                            }
                                        #endregion
                                        #region Irelia
                                        case "Irelia":
                                            {
                                                Spell.Targeted Q = new Spell.Targeted(SpellSlot.Q, (uint)650f + 20);
                                                //Smite and Spell  ==> OKAY
                                                if (Smite.IsReady() && Q.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Q.Range
                                                    && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    SpellDamage = GetDamages.Irelia(Q.Level);
                                                    TotalDamage = SpellDamage + GetSmiteDamage();
                                                    if (Monster.Health <= TotalDamage)
                                                    {
                                                        Q.Cast(Monster);
                                                        //Smite.Cast(Monster);
                                                    }
                                                }
                                                //If Spell is busy, Go Smite only! ^_^
                                                else if (Smite.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    if (Monster.Health <= GetSmiteDamage())
                                                    {
                                                        Smite.Cast(Monster);
                                                    }
                                                    TotalDamage = 0;
                                                }
                                                break;
                                            }
                                        #endregion
                                        #region Amumu
                                        case "Amumu":
                                            {
                                                Spell.Skillshot Q = new Spell.Skillshot(SpellSlot.Q, (uint)1100f + 20, SkillShotType.Linear);
                                                //Smite and Spell  ==> OKAY
                                                if (Smite.IsReady() && Q.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Q.Range
                                                    && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    SpellDamage = GetDamages.Amumu(Q.Level);
                                                    TotalDamage = SpellDamage + GetSmiteDamage();
                                                    if (Monster.Health <= TotalDamage)
                                                    {
                                                        Q.Cast(Monster);
                                                        //Smite.Cast(Monster);
                                                    }
                                                }
                                                //If Spell is busy, Go Smite only! ^_^
                                                else if (Smite.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    if (Monster.Health <= GetSmiteDamage())
                                                    {
                                                        Smite.Cast(Monster);
                                                    }
                                                    TotalDamage = 0;
                                                }
                                                break;
                                            }
                                        #endregion
                                        #region Hecarim
                                        case "Hecarim":
                                            {
                                                Spell.Active Q = new Spell.Active(SpellSlot.Q, (uint)350f + 20);
                                                //Smite and Spell  ==> OKAY
                                                if (Smite.IsReady() && Q.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Q.Range
                                                    && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    SpellDamage = GetDamages.Hecarim(Q.Level);
                                                    TotalDamage = SpellDamage + GetSmiteDamage();
                                                    if (Monster.Health <= TotalDamage)
                                                    {
                                                        Q.Cast();
                                                        //Smite.Cast(Monster);
                                                    }
                                                }
                                                //If Spell is busy, Go Smite only! ^_^
                                                else if (Smite.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    if (Monster.Health <= GetSmiteDamage())
                                                    {
                                                        Smite.Cast(Monster);
                                                    }
                                                    TotalDamage = 0;
                                                }
                                                break;
                                            }
                                        #endregion
                                        #region MonkeyKing
                                        case "MonkeyKing":
                                            {
                                                Spell.Active Q = new Spell.Active(SpellSlot.Q, (uint)100f + 20);
                                                //Smite and Spell  ==> OKAY
                                                if (Smite.IsReady() && Q.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Q.Range
                                                    && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    SpellDamage = GetDamages.MonkeyKing(Q.Level);
                                                    TotalDamage = SpellDamage + GetSmiteDamage();
                                                    if (Monster.Health <= TotalDamage)
                                                    {
                                                        Q.Cast();
                                                        //Smite.Cast(Monster);
                                                    }
                                                }
                                                //If Spell is busy, Go Smite only! ^_^
                                                else if (Smite.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    if (Monster.Health <= GetSmiteDamage())
                                                    {
                                                        Smite.Cast(Monster);
                                                    }
                                                    TotalDamage = 0;
                                                }
                                                break;
                                            }
                                        #endregion
                                        #region Pantheon
                                        case "Pantheon":
                                            {
                                                Spell.Targeted Q = new Spell.Targeted(SpellSlot.Q, (uint)600f + 20);
                                                //Smite and Spell  ==> OKAY
                                                if (Smite.IsReady() && Q.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Q.Range
                                                    && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    SpellDamage = GetDamages.Pantheon(Q.Level, Monster);
                                                    TotalDamage = SpellDamage + GetSmiteDamage();
                                                    if (Monster.Health <= TotalDamage)
                                                    {
                                                        Q.Cast(Monster);
                                                        //Smite.Cast(Monster);
                                                    }
                                                }
                                                //If Spell is busy, Go Smite only! ^_^
                                                else if (Smite.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    if (Monster.Health <= GetSmiteDamage())
                                                    {
                                                        Smite.Cast(Monster);
                                                    }
                                                    TotalDamage = 0;
                                                }
                                                break;
                                            }
                                        #endregion
                                        #region Olaf
                                        case "Olaf":
                                            {
                                                Spell.Targeted E = new Spell.Targeted(SpellSlot.E, (uint)325f + 20);
                                                //Smite and Spell  ==> OKAY
                                                if (Smite.IsReady() && E.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < E.Range
                                                    && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    SpellDamage = GetDamages.Olaf(E.Level);
                                                    TotalDamage = SpellDamage + GetSmiteDamage();
                                                    if (Monster.Health <= TotalDamage)
                                                    {
                                                        E.Cast(Monster);
                                                        //Smite.Cast(Monster);
                                                    }
                                                }
                                                //If Spell is busy, Go Smite only! ^_^
                                                else if (Smite.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    if (Monster.Health <= GetSmiteDamage())
                                                    {
                                                        Smite.Cast(Monster);
                                                    }
                                                    TotalDamage = 0;
                                                }
                                                break;
                                            }
                                        #endregion
                                        #region Volibear
                                        case "Volibear":
                                            {
                                                Spell.Targeted W = new Spell.Targeted(SpellSlot.W, (uint)400f + 20);
                                                //Smite and Spell  ==> OKAY
                                                if (Smite.IsReady() && W.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < W.Range
                                                    && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    SpellDamage = GetDamages.Volibear(W.Level, Monster);
                                                    TotalDamage = SpellDamage + GetSmiteDamage();
                                                    if (Monster.Health <= TotalDamage)
                                                    {
                                                        W.Cast(Monster);
                                                        //Smite.Cast(Monster);
                                                    }
                                                }
                                                //If Spell is busy, Go Smite only! ^_^
                                                else if (Smite.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    if (Monster.Health <= GetSmiteDamage())
                                                    {
                                                        Smite.Cast(Monster);
                                                    }
                                                    TotalDamage = 0;
                                                }
                                                break;
                                            }
                                        #endregion
                                        #region WarWick
                                        case "Warwick":
                                            {
                                                Spell.Targeted Q = new Spell.Targeted(SpellSlot.Q, (uint)400f + 20);
                                                //Smite and Spell  ==> OKAY
                                                if (Smite.IsReady() && Q.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Q.Range
                                                    && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    SpellDamage = GetDamages.Warwick(Q.Level, Monster);
                                                    TotalDamage = SpellDamage + GetSmiteDamage();
                                                    if (Monster.Health <= TotalDamage)
                                                    {
                                                        Player.CastSpell(Q.Slot, Monster);
                                                        //Smite.Cast(Monster);
                                                    }
                                                }
                                                //If Spell is busy, Go Smite only! ^_^
                                                else if (Smite.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    if (Monster.Health <= GetSmiteDamage())
                                                    {
                                                        Smite.Cast(Monster);
                                                    }
                                                    TotalDamage = 0;
                                                }
                                                break;
                                            }
                                        #endregion
                                        //Will add Spell's E too soon! ^-^
                                        #region LeeSin
                                        case "LeeSin":
                                            {
                                                Spell.Skillshot Q = new Spell.Skillshot(SpellSlot.Q, (uint)1300f, SkillShotType.Linear);
                                                Spell.Active Q2 = new Spell.Active(SpellSlot.Q, (uint)1500f);
                                                //Smite and Spell  ==> OKAY
                                                if (Smite.IsReady() && Q.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Q.Range
                                                    && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    if (GetDamages.BuffedEnemy != null)
                                                        SpellDamage = GetDamages.Q2Damage(Monster, Q2.Level);
                                                    else
                                                        SpellDamage = GetDamages.QDamage(Monster, Q.Level - 1) + GetDamages.Q2Damage(Monster, Q2.Level - 1);
                                                    TotalDamage = SpellDamage + GetSmiteDamage();
                                                    if (Monster.Health <= TotalDamage)
                                                    {
                                                        if (GetDamages.BuffedEnemy != null)
                                                            Q2.Cast(Monster);
                                                        else
                                                            Q.Cast(Monster);
                                                        //Smite.Cast(Monster);
                                                    }
                                                }
                                                //If Spell is busy, Go Smite only! ^_^
                                                else if (Smite.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    if (Monster.Health <= GetSmiteDamage())
                                                    {
                                                        Smite.Cast(Monster);
                                                    }
                                                    TotalDamage = 0;
                                                }
                                                break;
                                            }
                                        #endregion
                                        #region Nunu
                                        case "Nunu":
                                            {
                                                Spell.Targeted Q = new Spell.Targeted(SpellSlot.Q, (uint)200f);
                                                //Smite and Spell  ==> OKAY
                                                if (Smite.IsReady() && Q.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Q.Range
                                                    && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    SpellDamage = GetDamages.Nunu(Q.Level);
                                                    TotalDamage = SpellDamage + GetSmiteDamage();
                                                    if (Monster.Health <= TotalDamage)
                                                    {
                                                        Player.CastSpell(Q.Slot, Monster);
                                                        //Smite.Cast(Monster);
                                                    }
                                                }
                                                //If Spell is busy, Go Smite only! ^_^
                                                else if (Smite.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    if (Monster.Health <= GetSmiteDamage())
                                                    {
                                                        Smite.Cast(Monster);
                                                    }
                                                    TotalDamage = 0;
                                                }
                                                break;
                                            }
                                        #endregion
                                        #region ChoGath
                                        case "Chogath":
                                            {
                                                Spell.Targeted R = new Spell.Targeted(SpellSlot.R, (uint)175f);
                                                //Smite and Spell  ==> OKAY
                                                if (Smite.IsReady() && R.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < R.Range
                                                    && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    SpellDamage = GetDamages.ChoGath();
                                                    TotalDamage = SpellDamage + GetSmiteDamage();
                                                    if (Monster.Health <= TotalDamage)
                                                    {
                                                        Player.CastSpell(R.Slot, Monster);
                                                        // Smite.Cast(Monster);
                                                    }
                                                }
                                                //If Spell is busy, Go Smite only! ^_^
                                                else if (Smite.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    if (Monster.Health <= GetSmiteDamage())
                                                    {
                                                        Smite.Cast(Monster);
                                                    }
                                                    TotalDamage = 0;
                                                }
                                                break;
                                            }
                                        #endregion
                                        #region Shaco
                                        case "Shaco":
                                            {
                                                Spell.Targeted E = new Spell.Targeted(SpellSlot.E, (uint)625f);
                                                //Smite and Spell  ==> OKAY
                                                if (Smite.IsReady() && E.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < E.Range
                                                    && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    SpellDamage = GetDamages.Shaco(E.Level);
                                                    TotalDamage = SpellDamage + GetSmiteDamage();
                                                    if (Monster.Health <= TotalDamage)
                                                    {
                                                        Player.CastSpell(E.Slot, Monster);
                                                        //  Smite.Cast(Monster);
                                                    }
                                                }
                                                //If Spell is busy, Go Smite only! ^_^
                                                else if (Smite.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    if (Monster.Health <= GetSmiteDamage())
                                                    {
                                                        Smite.Cast(Monster);
                                                    }
                                                    TotalDamage = 0;
                                                }
                                                break;
                                            }
                                        #endregion
                                        #region Vi
                                        case "Vi":
                                            {
                                                Spell.Active E = new Spell.Active(SpellSlot.E, (uint)600f);
                                                //Smite and Spell  ==> OKAY
                                                if (Smite.IsReady() && E.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < E.Range
                                                    && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    SpellDamage = GetDamages.Vi(E.Level);
                                                    TotalDamage = SpellDamage + GetSmiteDamage();
                                                    if (Monster.Health <= TotalDamage)
                                                    {
                                                        Player.CastSpell(E.Slot, Monster);
                                                        //  Smite.Cast(Monster);
                                                    }
                                                }
                                                //If Spell is busy, Go Smite only! ^_^
                                                else if (Smite.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    if (Monster.Health <= GetSmiteDamage())
                                                    {
                                                        Smite.Cast(Monster);
                                                    }
                                                    TotalDamage = 0;
                                                }
                                                break;
                                            }
                                        #endregion
                                        #region MasterYi
                                        case "MasterYi":
                                            {
                                                Spell.Targeted Q = new Spell.Targeted(SpellSlot.Q, (uint)600f);
                                                //Smite and Spell  ==> OKAY
                                                if (Smite.IsReady() && Q.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Q.Range
                                                    && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    SpellDamage = GetDamages.Master(Q.Level);
                                                    TotalDamage = SpellDamage + GetSmiteDamage();
                                                    if (Monster.Health <= TotalDamage)
                                                    {
                                                        Player.CastSpell(Q.Slot, Monster);
                                                        //Smite.Cast(Monster);
                                                    }
                                                }
                                                //If Spell is busy, Go Smite only! ^_^
                                                else if (Smite.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    if (Monster.Health <= GetSmiteDamage())
                                                    {
                                                        Smite.Cast(Monster);
                                                    }
                                                    TotalDamage = 0;
                                                }
                                                break;
                                            }
                                        #endregion
                                        #region Rengar
                                        case "Rengar":
                                            {
                                                Spell.Active Q = new Spell.Active(SpellSlot.Q, (uint)ObjectManager.Player.AttackRange);
                                                //Smite and Spell  ==> OKAY
                                                if (Smite.IsReady() && Q.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Q.Range
                                                    && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    SpellDamage = GetDamages.Rengar(Q.Level);
                                                    TotalDamage = SpellDamage + GetSmiteDamage();
                                                    if (Monster.Health <= TotalDamage)
                                                    {
                                                        Player.CastSpell(Q.Slot, Monster);
                                                        //Smite.Cast(Monster);
                                                    }
                                                }
                                                //If Spell is busy, Go Smite only! ^_^
                                                else if (Smite.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    if (Monster.Health <= GetSmiteDamage())
                                                    {
                                                        Smite.Cast(Monster);
                                                    }
                                                    TotalDamage = 0;
                                                }
                                                break;
                                            }
                                        #endregion
                                        #region Nasus
                                        case "Nasus":
                                            {
                                                Spell.Active Q = new Spell.Active(SpellSlot.Q, (uint)ObjectManager.Player.AttackRange);
                                                //Smite and Spell  ==> OKAY
                                                if (Smite.IsReady() && Q.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Q.Range
                                                    && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    SpellDamage = GetDamages.Nasus(Q.Level);
                                                    TotalDamage = SpellDamage + GetSmiteDamage();
                                                    if (Monster.Health <= TotalDamage)
                                                    {
                                                        Player.CastSpell(Q.Slot, Monster);
                                                        //Smite.Cast(Monster);
                                                    }
                                                }
                                                //If Spell is busy, Go Smite only! ^_^
                                                else if (Smite.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    if (Monster.Health <= GetSmiteDamage())
                                                    {
                                                        Smite.Cast(Monster);
                                                    }
                                                    TotalDamage = 0;
                                                }
                                                break;
                                            }
                                        #endregion
                                        #region KhaZix
                                        case "Khazix":
                                            {
                                                Spell.Targeted Q = new Spell.Targeted(SpellSlot.Q, (uint)325f);
                                                //Smite and Spell  ==> OKAY
                                                if (Smite.IsReady() && Q.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Q.Range
                                                    && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    SpellDamage = GetDamages.Khazix(Q.Level);
                                                    TotalDamage = SpellDamage + GetSmiteDamage();
                                                    if (Monster.Health <= TotalDamage)
                                                    {
                                                        Player.CastSpell(Q.Slot, Monster);
                                                        // Smite.Cast(Monster);
                                                    }
                                                }
                                                //If Spell is busy, Go Smite only! ^_^
                                                else if (Smite.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    if (Monster.Health <= GetSmiteDamage())
                                                    {
                                                        Smite.Cast(Monster);
                                                    }
                                                    TotalDamage = 0;
                                                }
                                                break;
                                            }
                                        #endregion
                                        #region Fizz
                                        case "Fizz":
                                            {
                                                Spell.Targeted Q = new Spell.Targeted(SpellSlot.Q, (uint)550f);
                                                //Smite and Spell  ==> OKAY
                                                if (Smite.IsReady() && Q.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Q.Range
                                                    && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    SpellDamage = GetDamages.Fizz(Q.Level);
                                                    TotalDamage = SpellDamage + GetSmiteDamage();
                                                    if (Monster.Health <= TotalDamage)
                                                    {
                                                        Player.CastSpell(Q.Slot, Monster);
                                                        //    Smite.Cast(Monster);
                                                    }
                                                }
                                                //If Spell is busy, Go Smite only! ^_^
                                                else if (Smite.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    if (Monster.Health <= GetSmiteDamage())
                                                    {
                                                        Smite.Cast(Monster);
                                                    }
                                                    TotalDamage = 0;
                                                }
                                                break;
                                            }
                                        #endregion
                                        #region Elise
                                        case "Elise":
                                            {
                                                Spell.Targeted Q = new Spell.Targeted(SpellSlot.Q, (uint)475f);
                                                //Smite and Spell  ==> OKAY
                                                if (Smite.IsReady() && Q.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Q.Range
                                                    && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    SpellDamage = GetDamages.Elise(Q.Level, Monster);
                                                    TotalDamage = SpellDamage + GetSmiteDamage();
                                                    if (Monster.Health <= TotalDamage)
                                                    {
                                                        Player.CastSpell(Q.Slot, Monster);
                                                        // Smite.Cast(Monster);
                                                    }
                                                }
                                                //If Spell is busy, Go Smite only! ^_^
                                                else if (Smite.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    if (Monster.Health <= GetSmiteDamage())
                                                    {
                                                        Smite.Cast(Monster);
                                                    }
                                                    TotalDamage = 0;
                                                }
                                                break;
                                            }
                                        #endregion

                                        default:
                                            {
                                                if (Smite.IsReady() && Monster.Health <= GetSmiteDamage() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                    Smite.Cast(Monster);
                                                TotalDamage = 0;
                                            }
                                            break;
                                    }
                                }
                            }

                            if (Smite.IsReady() && Monster.Health <= GetSmiteDamage() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                            {
                                Smite.Cast(Monster);
                                TotalDamage = 0;
                            }
                        }
                }
        }