Beispiel #1
0
 private void Killsteal()
 {
     if (E.Ready && Menu["killsteal"]["usee"].Enabled)
     {
         var besttarget  = GetBestKillableHero(E, DamageType.Magical, false);
         var EPrediction = E.GetPrediction(besttarget);
         if (besttarget != null && Player.GetSpellDamage(besttarget, SpellSlot.E) >= besttarget.Health && besttarget.IsValidTarget(E.Range))
         {
             if (EPrediction.HitChance >= HitChance.High)
             {
                 E.Cast(EPrediction.CastPosition);
             }
         }
     }
     if (R.Ready && Menu["killsteal"]["user"].Enabled)
     {
         var besttarget = GetBestKillableHero(R, DamageType.Magical, false);
         if (besttarget != null && Player.GetSpellDamage(besttarget, SpellSlot.R) > besttarget.Health && besttarget.IsValidTarget(R.Range))
         {
             R.Cast(besttarget);
         }
     }
     if (Menu["killsteal"]["ignite"].Enabled && Ignite != null)
     {
         var besttarget = GetBestKillableHero(Ignite, DamageType.True, false);
         if (besttarget != null && IgniteDamages - 100 >= besttarget.Health && besttarget.IsValidTarget(Ignite.Range))
         {
             Ignite.CastOnUnit(besttarget);
         }
     }
 }
Beispiel #2
0
 private void Killsteal()
 {
     if (R.Ready && Menu["killsteal"]["user"].Enabled)
     {
         var besttarget = GetBestKillableHero(R, DamageType.Magical, false);
         if (besttarget != null && Player.GetSpellDamage(besttarget, SpellSlot.R) >= besttarget.Health && besttarget.IsValidTarget(R.Range))
         {
             R.Cast(besttarget);
         }
     }
     if (Q.Ready && Menu["killsteal"]["useq"].Enabled)
     {
         var besttarget = GetBestKillableHero(Q, DamageType.Physical, false);
         if (besttarget != null && Player.GetSpellDamage(besttarget, SpellSlot.Q) >= besttarget.Health && besttarget.IsValidTarget(Q2.Range))
         {
             Q2.Cast(besttarget);
         }
     }
     if (E.Ready && Menu["killsteal"]["usee"].Enabled)
     {
         var besttarget = GetBestKillableHero(E, DamageType.Physical, false);
         if (besttarget != null && Player.GetSpellDamage(besttarget, SpellSlot.E) >= besttarget.Health && besttarget.IsValidTarget(E.Range))
         {
             E.Cast(besttarget);
         }
     }
     if (Menu["killsteal"]["ignite"].Enabled && Ignite != null)
     {
         var besttarget = GetBestKillableHero(Ignite, DamageType.True, false);
         if (besttarget != null && IgniteDamages - 100 >= besttarget.Health && besttarget.IsValidTarget(Ignite.Range))
         {
             Ignite.CastOnUnit(besttarget);
         }
     }
 }
Beispiel #3
0
        private void Killsteal()
        {
            if (Q.Ready && Menu["killsteal"]["useq"].Enabled && Player.SpellBook.GetSpell(SpellSlot.Q).Name == "YasuoQW")
            {
                var besttarget = GetBestKillableHero(Q, DamageType.Physical, false);
                if (besttarget != null && Player.GetSpellDamage(besttarget, SpellSlot.Q) >= besttarget.Health && !Player.IsDashing() && besttarget.IsValidTarget(Q.Range))
                {
                    Q.Cast(besttarget);
                }
            }

            if (Q.Ready && Menu["killsteal"]["useq"].Enabled && Player.SpellBook.GetSpell(SpellSlot.Q).Name == "YasuoQ2W")
            {
                var besttarget = GetBestKillableHero(Q, DamageType.Physical, false);
                if (besttarget != null && Player.GetSpellDamage(besttarget, SpellSlot.Q) >= besttarget.Health && !Player.IsDashing() && besttarget.IsValidTarget(Q.Range))
                {
                    Q2.Cast(besttarget);
                }
            }

            if (Q.Ready && Menu["killsteal"]["useq2"].Enabled && Player.SpellBook.GetSpell(SpellSlot.Q).Name == "YasuoQ3W")
            {
                var besttarget = GetBestKillableHero(Q, DamageType.Physical, false);
                if (besttarget != null && Player.GetSpellDamage(besttarget, SpellSlot.Q) >= besttarget.Health && !Player.IsDashing() && besttarget.IsValidTarget(Q3.Range))
                {
                    {
                        Q3.Cast(besttarget);
                    }
                }
            }

            if (E.Ready && Menu["killsteal"]["usee"].Enabled)
            {
                var besttarget = GetBestKillableHero(E, DamageType.Mixed, false);
                if (besttarget != null && Player.GetSpellDamage(besttarget, SpellSlot.E) >= besttarget.Health && besttarget.IsValidTarget(E.Range))
                {
                    E.Cast(besttarget);
                }
            }

            if (R.Ready && Menu["killsteal"]["user"].Enabled)
            {
                var besttarget = GetBestKillableHero(R, DamageType.Physical, false);
                if (besttarget != null && Player.GetSpellDamage(besttarget, SpellSlot.R) >= besttarget.Health && besttarget.IsValidTarget(R.Range) && (besttarget.HasBuffOfType(BuffType.Knockup) || besttarget.HasBuffOfType(BuffType.Knockback)))
                {
                    R.Cast();
                }
            }

            if (Menu["killsteal"]["ignite"].Enabled && Ignite != null)
            {
                var besttarget = GetBestKillableHero(Ignite, DamageType.True, false);
                if (besttarget != null && IgniteDamages - 100 >= besttarget.Health && besttarget.IsValidTarget(Ignite.Range))
                {
                    Ignite.CastOnUnit(besttarget);
                }
            }
        }
Beispiel #4
0
        public void DoKillSteal()
        {
            if (!RootM["killsteal"]["ks"].As <MenuBool>().Enabled)
            {
                return;
            }

            foreach (var hptarget in GameObjects.EnemyHeroes.Where(a => a.IsValidTarget(1200) && !a.IsDead))
            {
                if (!hptarget.IsValid || hptarget.IsDead || hptarget == null)
                {
                    return;
                }

                var Health = hptarget.Health;
                var dmgE   = MyHero.GetSpellDamage(hptarget, SpellSlot.E);
                if (MyHero.Distance(hptarget) < E.Range && Health < dmgE &&
                    RootM["killsteal"]["useE"].As <MenuBool>().Enabled)
                {
                    E.Cast(hptarget);
                }

                var dmgQ = MyHero.GetSpellDamage(hptarget, SpellSlot.Q);
                if (MyHero.Distance(hptarget) < Q.Range && Health < dmgQ &&
                    RootM["killsteal"]["useQ"].As <MenuBool>().Enabled)
                {
                    Q.Cast(hptarget);
                }

                var dmgW = MyHero.GetSpellDamage(hptarget, SpellSlot.W);
                if (MyHero.Distance(hptarget) < W.Range && Health < dmgW &&
                    RootM["killsteal"]["useW"].As <MenuBool>().Enabled)
                {
                    W.Cast(hptarget);
                }

                var dmgR = MyHero.GetSpellDamage(hptarget, SpellSlot.Q);
                if (MyHero.Distance(hptarget) < Q.Range && Health < dmgR &&
                    RootM["killsteal"]["useR"].As <MenuBool>().Enabled)
                {
                    CastR("RQ", hptarget);
                }

                if (!IsIgnite)
                {
                    continue;
                }
                var dmgI = (50 + ((MyHero.Level) * 20));
                if (MyHero.Distance(hptarget) < Q.Range && Health < dmgI &&
                    RootM["killsteal"]["useI"].As <MenuBool>().Enabled)
                {
                    Ignite.CastOnUnit(hptarget);
                }

                // this.DoOneShotCombo(hptarget);
            }
        }
Beispiel #5
0
 private void Killsteal()
 {
     if (Menu["killsteal"]["ignite"].Enabled && Ignite != null)
     {
         var besttarget = GetBestKillableHero(Ignite, DamageType.True, false);
         if (besttarget != null && IgniteDamages - 100 >= besttarget.Health && besttarget.IsValidTarget(Ignite.Range))
         {
             Ignite.CastOnUnit(besttarget);
         }
     }
 }
Beispiel #6
0
 private void Killsteal()
 {
     if (Q.Ready &&
         Menu["killsteal"]["ksq"].Enabled)
     {
         var bestTarget = GetBestKillableHero(Q, DamageType.Magical, false);
         if (bestTarget != null &&
             Player.GetSpellDamage(bestTarget, SpellSlot.Q) >= bestTarget.Health &&
             bestTarget.IsValidTarget(Q.Range))
         {
             if (Q.GetPrediction(bestTarget).CastPosition.Distance(Player) < Q.Range - 40)
             {
                 Q.Cast(bestTarget);
             }
         }
     }
     if (
         Menu["killsteal"]["ignite"].Enabled && Ignite != null)
     {
         var bestTarget = GetBestKillableHero(Ignite, DamageType.True, false);
         if (bestTarget != null &&
             IgniteDamages - 100 >= bestTarget.Health &&
             bestTarget.IsValidTarget(Ignite.Range))
         {
             Ignite.CastOnUnit(bestTarget);
         }
     }
     if (W.Ready &&
         Menu["killsteal"]["ksw"].Enabled)
     {
         var bestTarget = GetBestKillableHero(W, DamageType.Magical, false);
         if (bestTarget != null &&
             Player.GetSpellDamage(bestTarget, SpellSlot.W) >= bestTarget.Health &&
             bestTarget.IsValidTarget(W.Range))
         {
             W.Cast();
         }
     }
     if (E.Ready &&
         Menu["killsteal"]["kse"].Enabled)
     {
         var bestTarget = GetBestKillableHero(E, DamageType.Magical, false);
         if (bestTarget != null &&
             Player.GetSpellDamage(bestTarget, SpellSlot.E) >= bestTarget.Health &&
             bestTarget.IsValidTarget(E.Range))
         {
             if (E.GetPrediction(bestTarget).CastPosition.Distance(Player) < E.Range - 100)
             {
                 E.Cast(bestTarget);
             }
         }
     }
 }
Beispiel #7
0
 private void Killsteal()
 {
     if (W.Ready && Menu["killsteal"]["usew"].Enabled)
     {
         var besttarget = GetBestKillableHero(W, DamageType.Physical, false);
         var WPredition = W.GetPrediction(besttarget);
         if (besttarget != null && Player.GetSpellDamage(besttarget, SpellSlot.W) >= besttarget.Health && besttarget.IsValidTarget(W.Range))
         {
             if (WPredition.HitChance >= HitChance.High)
             {
                 W.Cast(WPredition.CastPosition);
             }
         }
     }
     if (Menu["killsteal"]["ignite"].Enabled && Ignite != null)
     {
         var besttarget = GetBestKillableHero(Ignite, DamageType.True, false);
         if (besttarget != null && IgniteDamages - 100 >= besttarget.Health && besttarget.IsValidTarget(Ignite.Range))
         {
             Ignite.CastOnUnit(besttarget);
         }
     }
 }
Beispiel #8
0
        private static void ComboEvent()
        {
            try
            {
                var target = TargetSelector.GetTarget(1200);

                if (target != null && target.IsValidTarget(1200))
                {
                    if (ComboMenu["FlowersYasuo.ComboMenu.Ignite"].GetValue <MenuBool>().Enabled&& IgniteSlot != SpellSlot.Unknown &&
                        Ignite.IsReady() && target.IsValidTarget(600) &&
                        (target.HealthPercent <= 25 || target.Health <= Me.GetIgniteDamage(target)))
                    {
                        Ignite.CastOnUnit(target);
                    }

                    if (ComboMenu["FlowersYasuo.ComboMenu.EQFlash"].GetValue <MenuKeyBind>().Active)
                    {
                        ComboEQFlashEvent(target);
                    }

                    if (ComboMenu["FlowersYasuo.ComboMenu.R"].GetValue <MenuKeyBind>().Active&& R.IsReady())
                    {
                        foreach (var rTarget in GameObjects.EnemyHeroes.Where(x => x.IsValidTarget(1200) && MyExtraManager.CanCastR(x)))
                        {
                            if (ComboMenu["FlowersYasuo.ComboMenu.RHitCount"].GetValue <MenuSliderButton>().Enabled)
                            {
                                if (rTarget.IsValidTarget(1200))
                                {
                                    var enemiesKnockedUp =
                                        GameObjects.EnemyHeroes
                                        .Where(x => x.IsValidTarget(R.Range))
                                        .Where(MyExtraManager.CanCastR);

                                    var enemiesKnocked = enemiesKnockedUp as IList <AIHeroClient> ?? enemiesKnockedUp.ToList();

                                    if (enemiesKnocked.Count >= ComboMenu["FlowersYasuo.ComboMenu.RHitCount"].GetValue <MenuSliderButton>().Value)
                                    {
                                        R.Cast(rTarget.Position);
                                    }
                                }
                            }

                            if (ComboMenu["FlowersYasuo.ComboMenu.RTargetHP"].GetValue <MenuSliderButton>().Enabled)
                            {
                                if (rTarget.IsValidTarget(R.Range))
                                {
                                    if (ComboMenu["FlowersYasuo.ComboMenu.RTargetFor" + rTarget.CharacterName].GetValue <MenuBool>().Enabled&&
                                        MyExtraManager.CanCastR(rTarget) &&
                                        rTarget.HealthPercent <=
                                        ComboMenu["FlowersYasuo.ComboMenu.RTargetHP"].GetValue <MenuSliderButton>().Value)
                                    {
                                        R.Cast(rTarget.Position);
                                    }
                                }
                            }
                        }
                    }

                    if (E.IsReady())
                    {
                        if (ComboMenu["FlowersYasuo.ComboMenu.E"].GetValue <MenuBool>().Enabled&& target.IsValidTarget(E.Range))
                        {
                            var dmg = Me.GetSpellDamage(target, SpellSlot.Q) * 2 + Me.GetSpellDamage(target, SpellSlot.E) +
                                      Me.GetAutoAttackDamage(target) * 2 +
                                      (R.IsReady()
                                          ? Me.GetSpellDamage(target, SpellSlot.R)
                                          : Me.GetSpellDamage(target, SpellSlot.Q));

                            if (target.DistanceToPlayer() >= Me.BoundingRadius + Me.AttackRange + 65 &&
                                (dmg >= target.Health || HaveQ3 && Q.IsReady()) && MyExtraManager.CanCastE(target) &&
                                (ComboMenu["FlowersYasuo.ComboMenu.ETurret"].GetValue <MenuBool>().Enabled) ||
                                !MyExtraManager.UnderTower(MyExtraManager.PosAfterE(target)))
                            {
                                E.CastOnUnit(target);
                            }
                        }

                        if (ComboMenu["FlowersYasuo.ComboMenu.EGapcloser"].GetValue <MenuBool>().Enabled)
                        {
                            if (!target.InAutoAttackRange())
                            {
                                if (ComboMenu["FlowersYasuo.ComboMenu.EGapcloserMode"].GetValue <MenuList>().Index == 0)
                                {
                                    MyExtraManager.EGapTarget(target,
                                                              ComboMenu["FlowersYasuo.ComboMenu.ETurret"].GetValue <MenuBool>().Enabled,
                                                              Me.BoundingRadius + Me.AttackRange + target.BoundingRadius - 50, HaveQ3);
                                }
                                else
                                {
                                    MyExtraManager.EGapMouse(target,
                                                             ComboMenu["FlowersYasuo.ComboMenu.ETurret"].GetValue <MenuBool>().Enabled,
                                                             Me.BoundingRadius + Me.AttackRange + target.BoundingRadius - 50, HaveQ3);
                                }
                            }
                        }
                    }

                    if (Q.IsReady())
                    {
                        if (IsMyDashing)
                        {
                            if (ComboMenu["FlowersYasuo.ComboMenu.EQ"].GetValue <MenuBool>().Enabled&& !HaveQ3)
                            {
                                if (GameObjects.Enemy.Any(x => x.IsValidTarget(220f, true, YasuolastEPos)) && Me.Distance(YasuolastEPos) <= 250)
                                {
                                    Q.Cast(Me.PreviousPosition);
                                }
                            }

                            if (ComboMenu["FlowersYasuo.ComboMenu.EQ3"].GetValue <MenuBool>().Enabled&& HaveQ3)
                            {
                                if (YasuolastEPos.CountEnemyHeroesInRange(220) > 0 && Me.Distance(YasuolastEPos) <= 250)
                                {
                                    Q.Cast(Me.PreviousPosition);
                                }
                            }
                        }
                        else
                        {
                            if (ComboMenu["FlowersYasuo.ComboMenu.Q"].GetValue <MenuBool>().Enabled&& !HaveQ3 &&
                                target.IsValidTarget(Q.Range))
                            {
                                CastQ(target);
                            }

                            if (ComboMenu["FlowersYasuo.ComboMenu.Q3"].GetValue <MenuBool>().Enabled&& HaveQ3 &&
                                target.IsValidTarget(Q3.Range))
                            {
                                CastQ3();
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("Error in MyEventManager.ComboEvent." + ex);
            }
        }
Beispiel #9
0
        private static void ComboEvent()
        {
            try
            {
                var target = TargetSelector.GetOrderedTargets(R.Range).FirstOrDefault();

                if (target != null && target.IsValidTarget() && !isEActive)
                {
                    if (ComboMenu["FlowersVladimir.ComboMenu.Ignite"].Enabled && IgniteSlot != SpellSlot.Unknown &&
                        Ignite.Ready && target.IsValidTarget(600) &&
                        (target.Health < MyExtraManager.GetComboDamage(target) && target.IsValidTarget(400) ||
                         target.Health < Me.GetIgniteDamage(target)))
                    {
                        Ignite.CastOnUnit(target);
                    }

                    if (ComboMenu["FlowersVladimir.ComboMenu.R"].As <MenuKeyBind>().Enabled&& R.Ready && target.IsValidTarget(R.Range))
                    {
                        if (ComboMenu["FlowersVladimir.ComboMenu.RAlways"].Enabled)
                        {
                            var rPred = R.GetPrediction(target);

                            if (rPred.HitChance >= HitChance.High)
                            {
                                R.Cast(rPred.CastPosition);
                                return;
                            }
                        }

                        if (ComboMenu["FlowersVladimir.ComboMenu.RKillAble"].Enabled && target.Health < R.GetDamage(target))
                        {
                            var rPred = R.GetPrediction(target);

                            if (rPred.HitChance >= HitChance.High)
                            {
                                R.Cast(rPred.CastPosition);
                                return;
                            }
                        }

                        if (ComboMenu["FlowersVladimir.ComboMenu.RCountHit"].As <MenuSliderBool>().Enabled)
                        {
                            if (R.CastIfWillHit(target,
                                                ComboMenu["FlowersVladimir.ComboMenu.RCountHit"].As <MenuSliderBool>().Value))
                            {
                                return;
                            }
                        }

                        if (ComboMenu["FlowersVladimir.ComboMenu.RBurstCombo"].Enabled &&
                            Me.CountEnemyHeroesInRange(600) == 1 && target.IsValidTarget(R.Range))
                        {
                            if (target.Health <
                                R.GetDamage(target) + E.GetDamage(target) + W.GetDamage(target) * 2 +
                                Q.GetDamage(target) * 2)
                            {
                                var rPred = R.GetPrediction(target);

                                if (rPred.HitChance >= HitChance.High)
                                {
                                    R.Cast(rPred.CastPosition);
                                    return;
                                }
                            }
                        }
                    }

                    if (ComboMenu["FlowersVladimir.ComboMenu.E"].Enabled && E.Ready && target.IsValidTarget(E.Range))
                    {
                        if (GameObjects.EnemyHeroes.Any(x => x.IsValidTarget(E.Range) && WillbeHit(x)))
                        {
                            if (isEActive)
                            {
                                if (Game.TickCount - lastETime > 1050 + Game.Ping && !isWActive)
                                {
                                    E.Cast();
                                }
                            }
                            else
                            {
                                Me.SpellBook.CastSpell(SpellSlot.E);
                            }
                        }
                    }

                    if (ComboMenu["FlowersVladimir.ComboMenu.W"].Enabled && W.Ready && target.IsValidTarget(450f))
                    {
                        if (ComboMenu["FlowersVladimir.ComboMenu.WECharge"].Enabled)
                        {
                            if (isEActive && target.IsValidTarget(450f))
                            {
                                W.Cast();
                            }
                        }
                        else
                        {
                            if (!isQActive && target.IsValidTarget(W.Range) && Me.HealthPercent() > 40 &&
                                Me.GetSpell(SpellSlot.E).CooldownEnd - Game.ClockTime > 2.3 + Game.Ping / 100)
                            {
                                W.Cast();
                            }
                        }
                    }

                    if (isEActive || isWActive)
                    {
                        return;
                    }

                    if (ComboMenu["FlowersVladimir.ComboMenu.Q"].Enabled && Q.Ready && target.IsValidTarget(Q.Range))
                    {
                        Q.CastOnUnit(target);
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("Error in MyEventManager.ComboEvent." + ex);
            }
        }
Beispiel #10
0
        private static void ComboEvent()
        {
            try
            {
                var target = TargetSelector.GetTarget(800f);

                if (target != null && target.IsValidTarget(800f))
                {
                    if (ComboMenu["FlowersFiora.ComboMenu.Item"].Enabled)
                    {
                        if ((target.Health * 1.12 >= target.MaxHealth ? target.MaxHealth : target.Health * 1.12) <
                            MyExtraManager.GetComboDamage(target) && target.DistanceToPlayer() > 400)
                        {
                            ItemsUse(true, false, false);
                        }

                        if (target.IsValidTarget(400) && (!target.IsValidAutoRange() || !Orbwalker.CanAttack()))
                        {
                            ItemsUse(false, true, false);
                        }
                    }

                    if (ComboMenu["FlowersFiora.ComboMenu.Ignite"].Enabled && IgniteSlot != SpellSlot.Unknown &&
                        Ignite.Ready)
                    {
                        if (target.Health < MyExtraManager.GetComboDamage(target) * 0.6 ||
                            target.Health < Me.GetIgniteDamage(target))
                        {
                            Ignite.CastOnUnit(target);
                        }
                    }

                    if (ComboMenu["FlowersFiora.ComboMenu.Force"].Enabled && target.IsValidTarget(500))
                    {
                        ForcusAttack(target);
                    }

                    if (ComboMenu["FlowersFiora.ComboMenu.Q"].Enabled && Q.Ready && target.IsValidTarget(Q.Range))
                    {
                        CastQ(target);
                    }

                    if (ComboMenu["FlowersFiora.ComboMenu.R"].As <MenuKeyBind>().Enabled&& R.Ready)
                    {
                        if (ComboMenu["FlowersFiora.ComboMenu.RSolo"].Enabled &&
                            ComboMenu["FlowersFiora.ComboMenu.RTargetFor" + target.ChampionName].Enabled &&
                            target.IsValidTarget(R.Range))
                        {
                            if (Me.CountAllyHeroesInRange(1000) < 2 && Me.CountEnemyHeroesInRange(1000) <= 2)
                            {
                                if (target.Health < MyExtraManager.GetComboDamage(target) - Me.GetAutoAttackDamage(target))
                                {
                                    if (!target.IsUnKillable() && target.Health > Me.GetAutoAttackDamage(target) * 3)
                                    {
                                        R.CastOnUnit(target);
                                    }
                                }
                            }
                        }

                        if (ComboMenu["FlowersFiora.ComboMenu.RTeam"].Enabled)
                        {
                            if (Me.CountEnemyHeroesInRange(1000) > 2 && Me.CountAllyHeroesInRange(1000) > 1)
                            {
                                foreach (
                                    var x in
                                    GameObjects.EnemyHeroes.Where(
                                        x =>
                                        x.IsValidTarget(R.Range) &&
                                        x.Health <=
                                        MyExtraManager.GetComboDamage(target) + Me.GetAutoAttackDamage(x) * 3))
                                {
                                    if (!x.IsUnKillable() && x.IsValidTarget(R.Range))
                                    {
                                        R.CastOnUnit(x);
                                    }
                                }
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("Error in MyEventManager.ComboEvent." + ex);
            }
        }