示例#1
0
        public static void Combo()
        {
            UseQSS();
            UseBOTRK();
            var TeamfightRange      = 800;
            var TeamfightingEnemies = HeroManager.Enemies.FindAll(e => e.Distance(Player) < TeamfightRange);

            if (Player.HealthPercent < 80 && Items.HasItem((int)ItemId.Blade_of_the_Ruined_King) && Items.CanUseItem((int)ItemId.Blade_of_the_Ruined_King))
            {
                var KSableEnemy =
                    HeroManager.Enemies.FirstOrDefault(e => e.Health < (e.MaxHealth * 0.1) - (e.MaxHealth * 0.1) * ((e.Armor / 10) * 7) / 100);
                if (KSableEnemy.IsValidTarget())
                {
                    UseBOTRK(KSableEnemy);
                }
                if (Player.CountEnemiesInRange(TeamfightRange) >= Player.CountAlliesInRange(TeamfightRange))
                {
                    return;
                }
                var escaping = HeroManager.Enemies.FirstOrDefault(e => e.HealthPercent < 40);
                if (!escaping.IsFacing(Player) && escaping.Distance(Game.CursorPos) < 250)
                {
                    UseBOTRK(escaping.IsValidTarget(500) ? escaping : null);
                }
            }
            if (Items.HasItem((int)ItemId.Youmuus_Ghostblade) &&
                Player.CountEnemiesInRange(TeamfightRange) <= Player.CountAlliesInRange(TeamfightRange) &&
                HeroManager.Allies.Any(a => a.Distance(TeamfightingEnemies.FirstOrDefault()) < 600))
            {
                UseItem(ItemId.Youmuus_Ghostblade);
            }
        }
 public static void HikiRanduin(Obj_AI_Hero target)
 {
     if (!Randuin.IsOwned() && !Randuin.IsReady() &&
         LeeSin.Distance(target.Position) > Randuin.Range && !Program.Config.Item("use.randuin").GetValue <bool>() &&
         LeeSin.CountAlliesInRange(Randuin.Range) < SliderCheck("randuin.min.enemy.count"))
     {
         return;
     }
     if (Randuin.IsReady() && Randuin.IsOwned() && LeeSin.Distance(target.Position) < Randuin.Range &&
         Program.Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo && target.IsValid && Program.Config.Item("use.randuin").GetValue <bool>() &&
         LeeSin.CountAlliesInRange(Randuin.Range) >= SliderCheck("randuin.min.enemy.count"))
     {
         Randuin.Cast();
     }
 }
示例#3
0
 private void OnInterruptableTarget(Obj_AI_Hero target, Interrupter2.InterruptableTargetEventArgs args)
 {
     if (E.CanCast(target) && config.Item("useEint", true).GetValue <bool>())
     {
         if (E.CastIfHitchanceEquals(target, HitChance.High, config.Item("packets").GetValue <bool>()))
         {
             return;
         }
     }
     if (R.CanCast(target) && config.Item("useRint", true).GetValue <bool>())
     {
         if (savedQ != null && !SimpleQ && !target.IsMoving && target.Distance(qPos) > QExplosionRange &&
             target.Distance(player) < R.Range - 100 &&
             target.Position.Distance(savedQ.position) < 550 + QExplosionRange / 2 &&
             !target.HasBuffOfType(BuffType.Knockback))
         {
             var cast = Prediction.GetPrediction(target, 1000f).UnitPosition.Extend(savedQ.position, -100);
             R.Cast(cast);
         }
         else if (target.Distance(player) < R.Range - 100)
         {
             if (player.CountEnemiesInRange(2000) <= player.CountAlliesInRange(2000))
             {
                 var cast = target.Position.Extend(player.Position, -100);
                 R.Cast(cast);
             }
             else
             {
                 var cast = target.Position.Extend(player.Position, 100);
                 R.Cast(cast);
             }
         }
     }
 }
示例#4
0
        public virtual void Game_OnUpdate(EventArgs args)
        {
            if (!Player.IsDead)
            {
                SetAttack();

                if (config.Item("BuyItems").GetValue <bool>())
                {
                    BuyItems();
                }

                if (config.Item("Following").GetValue <bool>())
                {
                    Following();
                }

                AutoLevel();
                GetBuffs();

                rangeAllyCnt  = Player.CountAlliesInRange(600);
                rangeEnemyCnt = Player.CountEnemiesInRange(600);
            }
            else
            {
                RefreshLastShop();
            }
        }
示例#5
0
        static void GravesOnUpdate(EventArgs args)
        {
            var user = mainMenu.Item("usercombo").GetValue <bool>();

            rtarget = TargetSelector.GetTarget(Chargeshot.Range, TargetSelector.DamageType.Physical);

            if (rtarget.IsValidTarget() && Chargeshot.IsReady())
            {
                if (Kappa(rtarget.ServerPosition, Chargeshot.Width, Chargeshot.Range) >=
                    mainMenu.Item("rmulti").GetValue <Slider>().Value)
                {
                    if (mainMenu.Item("combokey").GetValue <KeyBind>().Active)
                    {
                        if (rtarget.CountAlliesInRange(700) >= 2)
                        {
                            Chargeshot.CastIfHitchanceEquals(rtarget, HitChance.Medium);
                        }
                    }
                }
            }

            if (mainMenu.Item("combokey").GetValue <KeyBind>().Active)
            {
                GravesCombo();
            }

            if (mainMenu.Item("fleekey").GetValue <KeyBind>().Active)
            {
                if (!Me.IsImmovable)
                {
                    Me.IssueOrder(GameObjectOrder.MoveTo, Game.CursorPos);
                }

                if (Smokescreen.IsReady() && rtarget.IsValidTarget(Smokescreen.Range))
                {
                    Smokescreen.CastIfHitchanceEquals(rtarget, HitChance.Medium);
                }

                else if (Quickdraw.IsReady())
                {
                    if (Utils.GameTimeTickCount - LastE > 500)
                    {
                        Quickdraw.Cast(Game.CursorPos);
                    }
                }
            }

            if (GetRDamage(rtarget) >= rtarget.Health && user)
            {
                if (rtarget.Distance(Me.ServerPosition) <= Me.AttackRange &&
                    Me.GetAutoAttackDamage(rtarget, true) * 3 >= rtarget.Health)
                {
                    return;
                }

                Chargeshot.CastIfHitchanceEquals(rtarget, HitChance.High);
            }
        }
示例#6
0
        private void Combo()
        {
            Obj_AI_Hero target = TargetSelector.GetTarget(E.Range, TargetSelector.DamageType.Physical);

            if (target == null)
            {
                return;
            }
            if (config.Item("useItems").GetValue <bool>())
            {
                ItemHandler.UseItems(target, config, ComboDamage(target));
            }
            var dist = player.Distance(target);

            if (config.Item("useq").GetValue <bool>() && player.CountEnemiesInRange(Q.Range) > 0)
            {
                Q.Cast();
            }
            if (config.Item("usew").GetValue <bool>() || player.Distance(target) < 600)
            {
                W.Cast();
            }
            var  ignitedmg = (float)player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite);
            bool hasIgnite = player.Spellbook.CanUseSpell(player.GetSpellSlot("SummonerDot")) == SpellState.Ready;

            if (config.Item("useIgnite").GetValue <bool>() && ignitedmg > target.Health && hasIgnite &&
                !E.CanCast(target) &&
                (target.Distance(player) >= Q.Range || (target.Distance(player) <= Q.Range && player.HealthPercent < 30)))
            {
                player.Spellbook.CastSpell(player.GetSpellSlot("SummonerDot"), target);
            }
            if (SkarnerR)
            {
                return;
            }
            if (config.Item("usee").GetValue <bool>() && E.CanCast(target) &&
                ((dist < config.Item("useeMaxRange").GetValue <Slider>().Value&&
                  dist > config.Item("useeMinRange").GetValue <Slider>().Value) || target.Health < ComboDamage(target)))
            {
                if (Program.IsSPrediction)
                {
                    E.SPredictionCast(target, HitChance.High);
                }
                else
                {
                    E.Cast(target);
                }
            }
            if (config.Item("user").GetValue <bool>() && R.CanCast(target) &&
                (!config.Item("ult" + target.SkinName).GetValue <bool>() || player.CountEnemiesInRange(1500) == 1) &&
                !target.HasBuffOfType(BuffType.Stun) && !target.HasBuffOfType(BuffType.Snare) && !E.IsReady() &&
                ((player.HealthPercent < 50 && target.HealthPercent < 50) || player.CountAlliesInRange(1000) > 1))
            {
                R.Cast(target);
            }
        }
示例#7
0
 public static float GetRealDmg(Spell QWER, Obj_AI_Hero target)
 {
     if (Orbwalking.InAutoAttackRange(target) || target.CountAlliesInRange(300) > 0)
     {
         return(QWER.GetDamage(target) + (float)ObjectManager.Player.GetAutoAttackDamage(target) * 2);
     }
     else
     {
         return(QWER.GetDamage(target));
     }
 }
示例#8
0
        private static void Game_OnUpdate(EventArgs args)
        {
            if (Player.IsRecalling())
            {
                return;
            }
            if (Player.CountEnemiesInRange(725) > 0 && _w.IsReady())
            {
                _w.CastOnUnit(Player.GetEnemiesInRange(725).OrderByDescending(target => target.Health).Last());
            }

            if (Player.CountAlliesInRange(725) > 0 && _w.IsReady())
            {
                _w.CastOnUnit(Player.GetAlliesInRange(725).OrderByDescending(target => target.Health).Last());
            }

            if (Player.CountAlliesInRange(800) > 0 && _e.IsReady())
            {
                _e.CastOnUnit(Player.GetAlliesInRange(800).OrderByDescending(target => target.GoldEarned).First());
            }
        }
 // Combo시 사용되는 R Logic: 발동조건 강화
 private static void ComboLogicR()
 {
     // 1250f 범위내 적군이 2명 이상이고, 1000f 범위내 아군이 3명 이상이고,
     if ((player.CountEnemiesInRange(Q.Range) > 1) && (player.CountAlliesInRange(R.Range) > 2))
     {
         var t = TargetSelector.GetTarget(Q.Range, TargetSelector.DamageType.Physical);
         // 타겟이 터렛 아래 있지 않을때...
         if (R.IsReady() && t.IsValidTarget() && !t.UnderTurret())
         {
             R.Cast();
         }
     }
 }
示例#10
0
 private static void Orbwalking_BeforeAttack(Orbwalking.BeforeAttackEventArgs args)
 {
     if (args.Target.Type == GameObjectType.obj_AI_Minion)
     {
         if (_menu.Item("support").GetValue <bool>())
         {
             if (Me.CountAlliesInRange(1200) > 1)
             {
                 args.Process = false;
             }
         }
     }
 }
示例#11
0
        private void Combo()
        {
            Obj_AI_Hero target = TargetSelector.GetTarget(900, TargetSelector.DamageType.Magical, true);

            if (target == null || target.IsInvulnerable || target.MagicImmune)
            {
                return;
            }
            if (config.Item("useItems").GetValue <bool>())
            {
                ItemHandler.UseItems(target, config, ComboDamage(target));
            }
            var  ignitedmg = (float)player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite);
            bool hasIgnite = player.Spellbook.CanUseSpell(player.GetSpellSlot("SummonerDot")) == SpellState.Ready;

            if (config.Item("useIgnite", true).GetValue <bool>() &&
                ignitedmg > HealthPrediction.GetHealthPrediction(target, 700) && hasIgnite &&
                !CombatHelper.CheckCriticalBuffs(target))
            {
                player.Spellbook.CastSpell(player.GetSpellSlot("SummonerDot"), target);
            }
            if (Q.CanCast(target) && config.Item("useq", true).GetValue <bool>() && !justWOut)
            {
                handeQ(target, HitChance.High);
            }
            if (W.IsReady() && !SomebodyInYou && config.Item("usew", true).GetValue <bool>() && !blockW)
            {
                if (!config.Item("dontusewks", true).GetValue <bool>() ||
                    ((getWDamage(target) < HealthPrediction.GetHealthPrediction(target, 600) &&
                      player.CountAlliesInRange(1200) > 0) || player.CountAlliesInRange(1200) == 0))
                {
                    handleWEnemyHero(target);
                }
            }
            if (config.Item("usewmini", true).GetValue <bool>())
            {
                HandleWHarass(target);
            }
        }
示例#12
0
        /// <summary>
        ///  inject flashr logic
        /// </summary>
        private static void FlashRLogic()
        {
            Me.IssueOrder(GameObjectOrder.MoveTo, Game.CursorPos);

            foreach (var e in HeroManager.Enemies.Where(em => em.IsValidTarget(R.Range + 425) && !em.IsZombie))
            {
                if (e != null)
                {
                    Game.PrintChat(e.ChampionName);
                    if (BuffCounts == 3 && E.IsReady() && !HaveStun)
                    {
                        E.Cast();
                    }

                    var RPred     = R.GetPrediction(e, true);
                    var RHitCount = R.GetPrediction(e, true).AoeTargetsHitCount;
                    if (RPred.Hitchance >= HitChance.High && HaveStun)
                    {
                        if (Me.CountAlliesInRange(1000) >= Menu.GetSlider("FlashRCountsAlliesinRange") && Me.CountEnemiesInRange(R.Range + 425) >= Menu.GetSlider("FlashRCountsEnemiesinRange") && RHitCount >= Menu.GetSlider("FlashRCountsEnemiesinRange"))
                        {
                            Me.Spellbook.CastSpell(Flash, R.GetPrediction(e, true).CastPosition);
                            if (!Flash.IsReady())
                            {
                                R.Cast(R.GetPrediction(e, true).CastPosition, true);
                            }
                        }
                        else if (Menu.GetBool("FlashRCanKillEnemy") && Me.CountEnemiesInRange(R.Range + 425) == 1 && Q.IsReady() && Ignite.IsReady() && e.Health < GetDamage(e, true, false, true, true))
                        {
                            Me.Spellbook.CastSpell(Flash, R.GetPrediction(e, true).CastPosition);
                            if (!Flash.IsReady())
                            {
                                R.Cast(R.GetPrediction(e, true).CastPosition, true); Me.Spellbook.CastSpell(Ignite, e); Q.Cast(e, true);
                            }
                        }
                        else if (Menu.GetBool("FlashRCanKillEnemy") && Me.CountEnemiesInRange(R.Range + 425) == 1 && Q.IsReady() && e.Health < GetDamage(e, true, false, true))
                        {
                            Me.Spellbook.CastSpell(Flash, R.GetPrediction(e, true).CastPosition);
                            if (!Flash.IsReady())
                            {
                                R.Cast(R.GetPrediction(e, true).CastPosition, true);
                                Q.Cast(e, true);
                            }
                        }
                    }
                }
            }
        }
示例#13
0
        private void BeforeAttack(Orbwalking.BeforeAttackEventArgs Args)
        {
            if (Me.ManaPercent >= Menu.Item("LaneClearMana", true).GetValue <Slider>().Value)
            {
                if (Menu.Item("LaneClearW", true).GetValue <bool>() && W.IsReady() && Me.CountEnemiesInRange(850) == 0)
                {
                    var turret = Args.Target as Obj_AI_Turret;

                    if (turret != null)
                    {
                        if (W.IsReady() && Me.CountAlliesInRange(W.Range) >= 1)
                        {
                            W.Cast(HeroManager.Allies.Find(x => x.DistanceToPlayer() <= W.Range));
                        }
                    }
                }
            }
        }
示例#14
0
        private static void Game_OnUpdate(EventArgs args)
        {
            if (Player.IsRecalling())
            {
                return;
            }
            if (Player.CountAlliesInRange(1000) > 0)
            {
                _w.Cast();
            }

            if (Player.CountEnemiesInRange(850) > 0)
            {
                _q.Cast();
            }

            _e.Cast();
        }
示例#15
0
 private static void Interrupter2_OnInterruptableTarget(Obj_AI_Hero sender, Interrupter2.InterruptableTargetEventArgs args)
 {
     if (E.CanCast(sender))
     {
         if (Player.CountAlliesInRange(E.Range + 50) < sender.CountAlliesInRange(E.Range + 50))
         {
             E.Cast(sender);
         }
         else
         {
             E.CastToReverse(sender);
         }
     }
     if (Q.CanCast(sender) && SpellQ.GetState() == QState.ThreshQ)
     {
         Q.Cast(sender);
     }
 }
示例#16
0
        public virtual void Game_OnUpdate(EventArgs args)
        {
            if (!Player.IsDead)
            {
                SetAttack();
                BuyItems();
                Following();
                AutoLevel();
                GetBuffs();

                rangeAllyCnt  = Player.CountAlliesInRange(600);
                rangeEnemyCnt = Player.CountEnemiesInRange(600);
            }
            else
            {
                RefreshLastShop();
            }
        }
示例#17
0
        private static void Combo()
        {
            var nearbyEnemies =
                HeroManager.Enemies.Where(h => h.IsValidTarget() && h.Distance(_player) < 1000)
                .OrderBy(h => h.Distance(_player));
            var QTarget = TargetSelector.GetTarget(_q.Range, TargetSelector.DamageType.Physical);
            var RTarget = TargetSelector.GetTarget(_r.Range, TargetSelector.DamageType.Magical);

            if (!nearbyEnemies.Any())
            {
                return;
            }
            if (_config.Item("comboQ").GetValue <bool>() && _q.IsReady() && QTarget.IsValidTarget())
            {
                _q.Cast();
            }
            if (_config.Item("comboE").GetValue <bool>() && _e.IsReady())
            {
                _e.Cast();
            }
            if (_config.Item("comboW").GetValue <bool>() && _w.IsReady())
            {
                if (_player.CountEnemiesInRange(700) >= _config.Item("countW").GetValue <Slider>().Value ||
                    _player.HealthPercentage() <= _config.Item("healthPercentWCombo").GetValue <Slider>().Value)
                {
                    _w.Cast();
                }
            }
            if (_config.Item("comboR").GetValue <bool>() && _r.IsReady())
            {
                if (_player.CountAlliesInRange(1000) <= 2)
                {
                    if (nearbyEnemies.FirstOrDefault().Distance(_player) < _q.Range)
                    {
                        return;
                    }
                    _r.CastIfWillHit(RTarget, _config.Item("countRGanks").GetValue <Slider>().Value);
                }
                else
                {
                    _r.CastIfWillHit(RTarget, _config.Item("countR").GetValue <Slider>().Value);
                }
            }
        }
示例#18
0
        private static void Combo()
        {
            Obj_AI_Base target = TargetSelector.GetTarget(E.Range, TargetSelector.DamageType.Physical);

            if (target == null)
            {
                return;
            }
            if (SkarnerR)
            {
                return;
            }
            if (config.Item("cuseQ").GetValue <bool>() && Q.CanCast(target))
            {
                Q.Cast(target);
            }
            if (config.Item("cuseW").GetValue <bool>() || player.Distance(target) <= 600)
            {
                W.Cast();
            }
            if (config.Item("cuseE").GetValue <bool>() && E.CanCast(target))
            {
                if (config.Item("useCPred").GetValue <bool>())
                {
                    tryE(target);
                }
                else
                {
                    E.Cast(target);
                }
            }
            if (config.Item("cuseR").GetValue <bool>() && R.CanCast(target))
            {
                if ((player.CountEnemiesInRange(1500) == 1) && !target.HasBuffOfType(BuffType.Stun) && !target.HasBuffOfType(BuffType.Snare) && player.CountAlliesInRange(1000) > 1)
                {
                    R.Cast(target);
                }
                if (player.CountEnemiesInRange(1500) <= player.CountAlliesInRange(1000) && player.HealthPercent > 40)
                {
                    R.Cast(target);
                }
            }
        }
示例#19
0
        static void GravesOnUpdate(EventArgs args)
        {
            gtarg = TargetSelector.GetTarget(Chargeshot.Range, TargetSelector.DamageType.Physical);

            if (gtarg.IsValidTarget() && Chargeshot.IsReady())
            {
                if (Kappa(gtarg.ServerPosition, Chargeshot.Width, Chargeshot.Range) >=
                    mainMenu.Item("rmulti2").GetValue <Slider>().Value)
                {
                    if (gtarg.CountAlliesInRange(700) >= 2)
                    {
                        Chargeshot.CastIfHitchanceEquals(gtarg, HitChance.Medium);
                    }
                }
            }

            if (mainMenu.Item("combokey").GetValue <KeyBind>().Active)
            {
                GravesCombo();
            }

            if (mainMenu.Item("fleekey").GetValue <KeyBind>().Active)
            {
                if (Me.CanMove)
                {
                    Me.IssueOrder(GameObjectOrder.MoveTo, Game.CursorPos);
                }

                if (Smokescreen.IsReady() && gtarg.IsValidTarget(Smokescreen.Range))
                {
                    Smokescreen.CastIfHitchanceEquals(gtarg, HitChance.Medium);
                }

                else if (Quickdraw.IsReady())
                {
                    if (Utils.GameTimeTickCount - LastE > 500)
                    {
                        Quickdraw.Cast(Game.CursorPos);
                    }
                }
            }
        }
示例#20
0
        internal static bool CanR(Obj_AI_Hero unit)
        {
            if (Me.HealthPercent <= 35 && unit.Distance(Me.ServerPosition) <= Me.AttackRange + 65)
            {
                return true;
            }

            if (unit.IsZombie || TargetSelector.IsInvulnerable(unit, TargetSelector.DamageType.Physical))
            {
                return false;
            }

            if (unit.CountAlliesInRange(400) >= 2 &&
                Me.GetAutoAttackDamage(unit, true) * 6 >= unit.Health)
            {
                return false;
            }

            if (Orbwalking.InAutoAttackRange(unit) &&
                Me.GetAutoAttackDamage(unit, true) * 3 >= unit.Health)
            {
                return false;
            }

            if (Buckshot.IsReady() && unit.Distance(Me.ServerPosition) <= Buckshot.Range &&
                Buckshot.GetDamage(unit) >= unit.Health)
            {
                return false;
            }

            if (Quickdraw.IsReady() && unit.Distance(Me.ServerPosition) <= Quickdraw.Range + 25 &&
                Me.GetAutoAttackDamage(unit, true) * 3 >= unit.Health)
            {
                return false;
            }

            return true;
        }
示例#21
0
        internal static bool CanR(Obj_AI_Hero unit)
        {
            if (Me.HealthPercent <= 35 && unit.Distance(Me.ServerPosition) <= Me.AttackRange + 65)
            {
                return(true);
            }

            if (unit.IsZombie || TargetSelector.IsInvulnerable(unit, TargetSelector.DamageType.Physical))
            {
                return(false);
            }

            if (unit.CountAlliesInRange(400) >= 2 &&
                Me.GetAutoAttackDamage(unit, true) * 6 >= unit.Health)
            {
                return(false);
            }

            if (Orbwalking.InAutoAttackRange(unit) &&
                Me.GetAutoAttackDamage(unit, true) * 3 >= unit.Health)
            {
                return(false);
            }

            if (Buckshot.IsReady() && unit.Distance(Me.ServerPosition) <= Buckshot.Range &&
                Buckshot.GetDamage(unit) >= unit.Health)
            {
                return(false);
            }

            if (Quickdraw.IsReady() && unit.Distance(Me.ServerPosition) <= Quickdraw.Range + 25 &&
                Me.GetAutoAttackDamage(unit, true) * 3 >= unit.Health)
            {
                return(false);
            }

            return(true);
        }
示例#22
0
        /**
         * TODO: Things to add:
         *  - Ensure that each player's position remains in order!!!
         *  - Exclude positon when players are backing
         */

        private static HeroInfo CopyHero(Obj_AI_Hero hero)
        {
            HeroInfo retHero = new HeroInfo();

            retHero.Position            = hero.ServerPosition;
            retHero.HealthPercent       = hero.HealthPercent;
            retHero.Direction           = hero.Direction;
            retHero.Distance            = hero.Distance(HeroManager.Player);
            retHero.CountAlliesInRange  = hero.CountAlliesInRange(2000);
            retHero.CountEnemiesInRange = hero.CountEnemiesInRange(2000);
            retHero.Level           = hero.Level;
            retHero.Experience      = hero.Experience;
            retHero.CanMove         = Convert.ToInt32(hero.CanMove);
            retHero.CanAttack       = Convert.ToInt32(hero.CanAttack);
            retHero.UnderAllyTurret = Convert.ToInt32(hero.UnderAllyTurret());
            retHero.ManaPercent     = hero.ManaPercent;
            retHero.MoveSpeed       = hero.MoveSpeed;
            retHero.allHeroesPos    = new List <Vector3>();
            foreach (var champ in HeroManager.AllHeroes)
            {
                retHero.allHeroesPos.Add(champ.ServerPosition);
            }
            return(retHero);
        }
示例#23
0
 public static float GetRealDmg(Spell QWER, Obj_AI_Hero target)
 {
     if (Orbwalking.InAutoAttackRange(target) || target.CountAlliesInRange(300) > 0)
         return QWER.GetDamage(target) + (float)ObjectManager.Player.GetAutoAttackDamage(target) * 2;
     else
         return QWER.GetDamage(target);
 }
示例#24
0
        internal static void GravesOnUpdate(EventArgs args)
        {
            Target = TargetSelector.GetTarget(Chargeshot.Range, TargetSelector.DamageType.Physical);

            if (Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo)
            {
                GravesCombo();
            }

            if (MainMenu.Item("autosmoke").GetValue <bool>() && Smokescreen.IsReady())
            {
                foreach (var hero in HeroManager.Enemies.Where(x => x.IsValidTarget(Smokescreen.Range)))
                {
                    if (!Me.IsWindingUp && Utils.GameTimeTickCount - LE > 1100)
                    {
                        Smokescreen.CastIfHitchanceEquals(hero, HitChance.Immobile);
                    }
                }
            }

            if (MainMenu.Item("fleekey").GetValue <KeyBind>().Active)
            {
                if (Utils.GameTimeTickCount - LM >= 100)
                {
                    Me.IssueOrder(GameObjectOrder.MoveTo, Game.CursorPos);
                    LM = Utils.GameTimeTickCount;
                }

                if (Smokescreen.IsReady() && Target.IsValidTarget(Smokescreen.Range))
                {
                    Smokescreen.CastIfHitchanceEquals(Target, HitChance.Medium);
                }

                else if (Quickdraw.IsReady())
                {
                    if (Utils.GameTimeTickCount - LE > 500)
                    {
                        Quickdraw.Cast(Game.CursorPos);
                    }
                }
            }

            if (MainMenu.Item("allin").GetValue <KeyBind>().Active)
            {
                if (!Me.Spellbook.IsCastingSpell)
                {
                    Orbwalking.Orbwalk(Target, Game.CursorPos);
                }

                if (Target.IsValidTarget(Chargeshot.Range))
                {
                    var rpred = Prediction.GetPrediction(Target, 0.25f).UnitPosition;
                    if (rpred.Distance(Me.ServerPosition) <= Quickdraw.Range + 200)
                    {
                        if (Chargeshot.IsReady() && Quickdraw.IsReady() && Buckshot.IsReady())
                        {
                            Chargeshot.CastIfHitchanceEquals(Target, HitChance.High);
                        }
                    }
                }
            }

            if (Target.IsValidTarget() && Chargeshot.IsReady())
            {
                if (MainMenu.Item("shootr").GetValue <KeyBind>().Active)
                {
                    Chargeshot.CastIfHitchanceEquals(Target, HitChance.VeryHigh);
                }

                if (MainMenu.Item("usercombo").GetValue <bool>())
                {
                    if (Proj1(Target.ServerPosition, Chargeshot.Width, Chargeshot.Range) >=
                        MainMenu.Item("rmulti").GetValue <Slider>().Value)
                    {
                        if (Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo)
                        {
                            if (Target.CountAlliesInRange(750) >= 2)
                            {
                                Chargeshot.CastIfHitchanceEquals(Target, HitChance.High);
                            }
                        }
                    }
                }
            }

            if (Chargeshot.IsReady())
            {
                foreach (var hero in HeroManager.Enemies.Where(x => x.IsValidTarget(Chargeshot.Range)))
                {
                    if (CanR(hero) && GetRDamage(hero) >= hero.Health && MainMenu.Item("secure").GetValue <bool>())
                    {
                        Chargeshot.CastIfHitchanceEquals(hero, HitChance.High);
                    }
                }
            }
        }
示例#25
0
        internal static void GravesOnUpdate(EventArgs args)
        {
            Target = TargetSelector.GetTarget(Chargeshot.Range, TargetSelector.DamageType.Physical);

            if (Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo)
                GravesCombo();

            if (MainMenu.Item("autosmoke").GetValue<bool>() && Smokescreen.IsReady())
            {
                foreach (var hero in HeroManager.Enemies.Where(x => x.IsValidTarget(Smokescreen.Range)))
                {
                    if (!Me.IsWindingUp && Utils.GameTimeTickCount - LE > 1100)
                        Smokescreen.CastIfHitchanceEquals(hero, HitChance.Immobile);
                }
            }

            if (MainMenu.Item("fleekey").GetValue<KeyBind>().Active)
            {
                if (Utils.GameTimeTickCount - LM >= 100)
                {
                    Me.IssueOrder(GameObjectOrder.MoveTo, Game.CursorPos);
                    LM = Utils.GameTimeTickCount;
                }

                if (Smokescreen.IsReady() && Target.IsValidTarget(Smokescreen.Range))
                    Smokescreen.CastIfHitchanceEquals(Target, HitChance.Medium);

                else if (Quickdraw.IsReady())
                {
                    if (Utils.GameTimeTickCount - LE > 500)
                        Quickdraw.Cast(Game.CursorPos);
                }
            }

            if (MainMenu.Item("allin").GetValue<KeyBind>().Active)
            {
                if (!Me.Spellbook.IsCastingSpell)
                     Orbwalking.Orbwalk(Target, Game.CursorPos);

                if (Target.IsValidTarget(Chargeshot.Range))
                {
                    var rpred = Prediction.GetPrediction(Target, 0.25f).UnitPosition;
                    if (rpred.Distance(Me.ServerPosition) <= Quickdraw.Range + 200)
                    {
                        if (Chargeshot.IsReady() && Quickdraw.IsReady() && Buckshot.IsReady())
                        {
                            Chargeshot.CastIfHitchanceEquals(Target, HitChance.High);
                        }
                    }
                }
            }

            if (Target.IsValidTarget() && Chargeshot.IsReady())
            {
                if (MainMenu.Item("shootr").GetValue<KeyBind>().Active)
                    Chargeshot.CastIfHitchanceEquals(Target, HitChance.VeryHigh);

                if (MainMenu.Item("usercombo").GetValue<bool>())
                {
                    if (Proj1(Target.ServerPosition, Chargeshot.Width, Chargeshot.Range) >=
                        MainMenu.Item("rmulti").GetValue<Slider>().Value)
                    {
                        if (Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo)
                        {
                            if (Target.CountAlliesInRange(750) >= 2)
                                Chargeshot.CastIfHitchanceEquals(Target, HitChance.High);
                        }
                    }
                }
            }

            if (Chargeshot.IsReady())
            {
                foreach (var hero in HeroManager.Enemies.Where(x => x.IsValidTarget(Chargeshot.Range)))
                {
                    if (CanR(hero) && GetRDamage(hero) >= hero.Health && MainMenu.Item("secure").GetValue<bool>())
                    {
                        Chargeshot.CastIfHitchanceEquals(hero, HitChance.High);
                    }
                }
            }
        }
示例#26
0
        private static void TeamFightUlt()
        {
            var CanCastR = false;

            if (Menu.Item("TeamFightR", true).GetValue <bool>() && R.IsReady())
            {
                foreach (var target in HeroManager.Enemies)
                {
                    if (!target.IsValidTarget())
                    {
                        continue;
                    }

                    if (target.IsDead)
                    {
                        continue;
                    }

                    if (target.IsZombie)
                    {
                        continue;
                    }

                    if (target.HasBuff("KindredRNoDeathBuff"))
                    {
                        continue;
                    }

                    if (target.HasBuff("UndyingRage") && target.GetBuff("UndyingRage").EndTime - Game.Time > 0.3)
                    {
                        continue;
                    }

                    if (target.HasBuff("JudicatorIntervention"))
                    {
                        continue;
                    }

                    if (target.HasBuff("ChronoShift") && target.GetBuff("ChronoShift").EndTime - Game.Time > 0.3)
                    {
                        continue;
                    }

                    if (target.HasBuff("FioraW"))
                    {
                        continue;
                    }

                    if (target.CountAlliesInRange(850) > 1 && target.CountEnemiesInRange(850) <= 2 &&
                        target.Health + target.MagicalShield < GetRDamage(target) * 2 && Me.IsZombie)
                    {
                        CanCastR = true;
                    }

                    //if (Me.CountEnemiesInRange(850) > 0 && target.Health < GetRDamage(target) + GetQDamage(target) * 3)
                    //{
                    //    CanCastR = true;
                    //}

                    if (Me.CountEnemiesInRange(1000) >= 3 && Me.CountAlliesInRange(850) <= 3)
                    {
                        CanCastR = true;
                    }
                }

                if (Me.IsZombie)
                {
                    var passivetime = Me.GetBuff("KarthusDeathDefiedBuff").EndTime;

                    if (passivetime > 3 && passivetime < 4)
                    {
                        if (CanCastR)
                        {
                            R.Cast();
                        }
                    }
                }
                else if (!Me.IsZombie)
                {
                    if (CanCastR && Me.CountEnemiesInRange(800) == 0)
                    {
                        R.Cast();
                    }
                }
            }
            else
            {
                CanCastR = false;
            }
        }
示例#27
0
        private static void Combo()
        {
            Obj_AI_Hero target = TargetSelector.GetTarget(1000, TargetSelector.DamageType.Magical);

            if (target == null)
            {
                return;
            }
            var cmbdmg = ComboDamage(target);

            if (config.Item("useItems").GetValue <bool>())
            {
                ItemHandler.UseItems(target, config, ComboDamage(target));
            }
            bool hasFlash = player.Spellbook.CanUseSpell(player.GetSpellSlot("SummonerFlash")) == SpellState.Ready;

            if (config.Item("usee", true).GetValue <bool>() && E.IsReady())
            {
                if (config.Item("useewall", true).GetValue <bool>())
                {
                    var   bestpos = CombatHelper.bestVectorToPoppyFlash2(target);
                    float damage  =
                        (float)
                        (ComboDamage(target) +
                         Damage.CalcDamage(
                             player, target, Damage.DamageType.Magical,
                             (eSecond[E.Level - 1] + 0.8f * player.FlatMagicDamageMod)) +
                         (player.GetAutoAttackDamage(target) * 4));
                    float damageno = (float)(ComboDamage(target) + (player.GetAutoAttackDamage(target) * 4));
                    if (config.Item("useeflash", true).GetValue <bool>() && hasFlash && !CheckWalls(player, target) &&
                        damage > target.Health && target.Health > damageno &&
                        CombatHelper.bestVectorToPoppyFlash(target).IsValid())
                    {
                        player.Spellbook.CastSpell(player.GetSpellSlot("SummonerFlash"), bestpos);
                        Utility.DelayAction.Add(
                            100, () => E.CastOnUnit(target));
                    }
                    if (E.CanCast(target) &&
                        (CheckWalls(player, target) ||
                         target.Health < E.GetDamage(target) + player.GetAutoAttackDamage(target, true)))
                    {
                        E.CastOnUnit(target);
                    }
                    if (E.CanCast(target) && Q.IsReady() && Q.Instance.ManaCost + E.Instance.ManaCost > player.Mana &&
                        target.Health <
                        E.GetDamage(target) + Q.GetDamage(target) + player.GetAutoAttackDamage(target, true))
                    {
                        E.CastOnUnit(target);
                    }
                }
                else
                {
                    if (E.CanCast(target))
                    {
                        E.CastOnUnit(target);
                    }
                }
            }
            if (config.Item("useq", true).GetValue <bool>() && Q.IsReady() && Q.CanCast(target) &&
                Orbwalking.CanMove(100) && target.Distance(player) < Q.Range &&
                (player.Distance(target) > Orbwalking.GetRealAutoAttackRange(target) || !Orbwalking.CanAttack()))
            {
                Q.CastIfHitchanceEquals(target, HitChance.High);
            }

            bool hasIgnite = player.Spellbook.CanUseSpell(player.GetSpellSlot("SummonerDot")) == SpellState.Ready &&
                             config.Item("useIgnite").GetValue <bool>();
            var ignitedmg = hasIgnite ? (float)player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite) : 0f;

            if (ignitedmg > target.Health && hasIgnite && !E.CanCast(target) && !Q.CanCast(target) &&
                (player.Distance(target) > Q.Range || player.HealthPercent < 30))
            {
                player.Spellbook.CastSpell(player.GetSpellSlot("SummonerDot"), target);
            }
            if (config.Item("userindanger", true).GetValue <bool>() && R.IsReady() &&
                ((player.CountEnemiesInRange(800) >= 2 &&
                  player.CountEnemiesInRange(800) > player.CountAlliesInRange(1500) + 1 && player.HealthPercent < 60) ||
                 (player.Health < target.Health && player.HealthPercent < 40 &&
                  player.CountAlliesInRange(1000) + 1 < player.CountEnemiesInRange(1000))))
            {
                var targ =
                    HeroManager.Enemies.Where(
                        e =>
                        e.IsValidTarget() && R.CanCast(e) &&
                        (player.HealthPercent < 60 || e.CountEnemiesInRange(300) > 2) &&
                        HeroManager.Enemies.Count(h => h.Distance(e) < 400 && e.HealthPercent < 35) == 0 &&
                        R.GetPrediction(e).CastPosition.Distance(player.Position) < R.ChargedMaxRange)
                    .OrderByDescending(e => R.GetPrediction(e).CastPosition.CountEnemiesInRange(400))
                    .ThenByDescending(e => e.Distance(target))
                    .FirstOrDefault();
                if (R.Range > 1300 && targ == null)
                {
                    targ =
                        HeroManager.Enemies.Where(
                            e =>
                            e.IsValidTarget() && R.CanCast(e) &&
                            R.GetPrediction(e).CastPosition.Distance(player.Position) < R.ChargedMaxRange)
                        .OrderByDescending(e => R.GetPrediction(e).CastPosition.CountEnemiesInRange(400))
                        .ThenByDescending(e => e.Distance(target))
                        .FirstOrDefault();
                }
                if (!R.IsCharging && targ != null)
                {
                    R.StartCharging();
                }
                if (R.IsCharging && targ != null && R.CanCast(targ) && R.Range > 1000 && R.Range > targ.Distance(player))
                {
                    R.CastIfHitchanceEquals(targ, HitChance.Medium);
                }
                if (R.IsCharging && targ != null && R.Range < 1000)
                {
                    return;
                }
            }
            if (config.Item("user", true).GetValue <bool>() && R.IsReady() && player.Distance(target) < 1400 &&
                !target.UnderTurret(true))
            {
                var cond = ((Rdmg(target) < target.Health && ignitedmg + Rdmg(target) > target.Health &&
                             player.Distance(target) < 600) ||
                            (target.Distance(player) > E.Range && Rdmg(target) > target.Health &&
                             target.Distance(player) < 1100));
                if (!R.IsCharging && cond && !Q.IsReady() && player.HealthPercent < 40)
                {
                    R.StartCharging();
                    if (hasIgnite && cmbdmg > target.Health && cmbdmg - Rdmg(target) < target.Health)
                    {
                        if (!target.HasBuff("summonerdot"))
                        {
                            player.Spellbook.CastSpell(player.GetSpellSlot("SummonerDot"), target);
                        }
                    }
                }
                if (R.IsCharging && R.CanCast(target) && R.Range > target.Distance(player) && cond)
                {
                    R.CastIfHitchanceEquals(target, HitChance.High);
                }
            }
        }
示例#28
0
        private void Combo()
        {
            Obj_AI_Hero target = DrawHelper.GetBetterTarget(W.Range, TargetSelector.DamageType.Magical);

            if (target == null)
            {
                return;
            }

            if (config.Item("useItems").GetValue <bool>())
            {
                ItemHandler.UseItems(target, config);
            }
            if (config.Item("RunFOTT", true).GetValue <bool>() &&
                (!config.Item("RunFOTTHP", true).GetValue <bool>() ||
                 (config.Item("RunFOTTHP", true).GetValue <bool>() && player.Health > target.Health)))
            {
                Vector3 pos;
                if (target.IsMoving)
                {
                    var rand = new Random();
                    if (ChaseFix)
                    {
                        pos = target.Position.Extend(
                            Prediction.GetPrediction(target, 0.6f).UnitPosition, rand.Next(480, 550));
                    }
                    else
                    {
                        var positions = CombatHelper.PointsAroundTheTargetOuterRing(target.ServerPosition, 130, 16);
                        pos = positions[rand.Next(positions.Count)];
                    }
                    if (player.Distance(pos) < 90)
                    {
                        if (!ChaseFix)
                        {
                            ChaseFix = true;
                        }
                        else
                        {
                            ChaseFix = false;
                        }
                    }
                }
                else
                {
                    pos = Vector3.Zero;
                }
                if (Orbwalking.CanMove(100))
                {
                    if (player.Distance(pos) > 40 && pos.IsValid())
                    {
                        Orbwalking.Move   = false;
                        Orbwalking.Attack = false;
                        player.IssueOrder(GameObjectOrder.MoveTo, pos);
                    }
                }
            }
            var qTarget =
                HeroManager.Enemies.FirstOrDefault(
                    enemy =>
                    enemy.IsValidTarget() && enemy.Distance(player) < 200 &&
                    CombatHelper.IsFacing(enemy, player.Position, 90f) &&
                    !CombatHelper.IsFacing(player, enemy.Position, 90f) && player.IsMoving && enemy.IsMoving);

            if (config.Item("useq", true).GetValue <bool>() &&
                (qTarget != null || target.HasBuff("poisontrailtarget") || player.Distance(target) <= 500))
            {
                CastQ();
            }
            if (config.Item("usew", true).GetValue <bool>() && !config.Item("WwithE", true).GetValue <bool>() &&
                W.IsReady() && W.CanCast(target))
            {
                var tarPered = W.GetPrediction(target);
                if (W.Range - 80 > tarPered.CastPosition.Distance(player.Position) &&
                    tarPered.Hitchance >= HitChance.VeryHigh)
                {
                    W.Cast(tarPered.CastPosition);
                }
            }
            if (R.IsReady() && config.Item("user", true).GetValue <bool>() &&
                (((config.Item("rUnderHealt", true).GetValue <Slider>().Value > player.HealthPercent &&
                   0 < player.CountEnemiesInRange(750)) ||
                  config.Item("rMinEnemy", true).GetValue <Slider>().Value <= player.CountEnemiesInRange(750)) &&
                 (!config.Item("rkeepManaE", true).GetValue <bool>() ||
                  (config.Item("rkeepManaE", true).GetValue <bool>() &&
                   player.Mana - R.Instance.ManaCost > E.Instance.ManaCost))))
            {
                R.Cast();
            }
            var  ignitedmg = (float)player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite);
            bool hasIgnite = player.Spellbook.CanUseSpell(player.GetSpellSlot("SummonerDot")) == SpellState.Ready;

            if (config.Item("useIgnite", true).GetValue <bool>() && ignitedmg > target.Health && hasIgnite)
            {
                player.Spellbook.CastSpell(player.GetSpellSlot("SummonerDot"), target);
            }
            var blockOrb = false;
            var throwPos = target.Position.Extend(player.Position, 500);

            if (config.Item("usee", true).GetValue <bool>() && E.IsReady() &&
                ((throwPos.CountAlliesInRange(700) > target.CountAlliesInRange(700) &&
                  HeroManager.Allies.FirstOrDefault(a => a.Distance(throwPos) < 700 && a.HealthPercent < 25) == null) ||
                 W.GetDamage(target) > target.Health || !target.HasBuff("poisontrailtarget") ||
                 config.Item("WwithE", true).GetValue <bool>()))
            {
                var pos = Prediction.GetPrediction(target, W.Delay / 2)
                          .UnitPosition.Extend(player.Position, 515 + player.Distance(target.Position));
                if (config.Item("WwithE", true).GetValue <bool>() && E.CanCast(target) && W.IsReady() &&
                    player.Mana > E.Instance.ManaCost + W.Instance.ManaCost + 15 && !pos.IsWall() &&
                    target.Health > E.GetDamage(target) + Q.GetDamage(target))
                {
                    W.Cast(pos);
                    return;
                }
                if (E.CanCast(target))
                {
                    E.CastOnUnit(target);
                }
                else if (target.Distance(player) < E.Range + 100)
                {
                    blockOrb = true;
                }
            }
            if (blockOrb)
            {
                Orbwalking.Attack = false;
            }
        }
示例#29
0
        internal static void GravesCombo()
        {
            if (Target.IsValidTarget(Chargeshot.Range))
            {
                var rpred = Prediction.GetPrediction(Target, 0.25f).UnitPosition;
                if (rpred.Distance(Me.ServerPosition) <= Quickdraw.Range * 2)
                {
                    if (Target.CountAlliesInRange(400) >= 2)
                    {
                        if (CanR(Target) && GetComboDamage(Target) >= Target.Health)
                        {
                            Chargeshot.CastIfHitchanceEquals(Target, HitChance.High);
                        }
                    }
                }
            }

            var qtarget = TargetSelector.GetTarget(Buckshot.Range, TargetSelector.DamageType.Physical);

            if (qtarget.IsValidTarget())
            {
                var predpros = Prediction.GetPrediction(qtarget, 0.25f).UnitPosition;
                if (predpros.Distance(Me.ServerPosition) > 535)
                {
                    if (qtarget.Distance(Me.ServerPosition) <= 675)
                    {
                        if (Utils.GameTimeTickCount - LR < 1500)
                        {
                            Buckshot.CastIfHitchanceEquals(qtarget, HitChance.High);
                        }
                    }
                }
            }

            var wtarget = TargetSelector.GetTarget(Smokescreen.Range, TargetSelector.DamageType.Magical);

            if (wtarget.IsValidTarget() && wtarget.Distance(Me.ServerPosition) <= Smokescreen.Range)
            {
                if (MainMenu.Item("usew").GetValue <bool>())
                {
                    if (Smokescreen.IsReady() && Utils.GameTimeTickCount - LR >= 1200)
                    {
                        if (Me.GetAutoAttackDamage(qtarget) * 3 < qtarget.Health)
                        {
                            if (!Quickdraw.IsReady() && !Buckshot.IsReady() && !Me.IsWindingUp)
                            {
                                if (Utils.GameTimeTickCount - LE >= 1100)
                                {
                                    Smokescreen.CastIfHitchanceEquals(wtarget, HitChance.High);
                                }
                            }
                        }
                    }
                }
            }

            if (qtarget.IsValidTarget() && qtarget.Distance(Me.ServerPosition) > 535)
            {
                if (qtarget.Distance(Me.ServerPosition) <= 535 + Quickdraw.Range)
                {
                    if (Quickdraw.IsReady() && Utils.GameTimeTickCount - LR >= 1200)
                    {
                        if (Me.GetAutoAttackDamage(qtarget) * 3 >= qtarget.Health)
                        {
                            CastE(qtarget);
                        }
                    }
                }
            }
        }
示例#30
0
        private void Combo(float combodmg)
        {
            Obj_AI_Hero target = TargetSelector.GetTarget(1100, TargetSelector.DamageType.Magical, true);

            if (target == null || target.IsInvulnerable || target.MagicImmune)
            {
                return;
            }
            if (config.Item("useItems").GetValue <bool>())
            {
                ItemHandler.UseItems(target, config, ComboDamage(target));
            }
            var  ignitedmg = (float)player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite);
            bool hasIgnite = player.Spellbook.CanUseSpell(player.GetSpellSlot("SummonerDot")) == SpellState.Ready;

            if (config.Item("useIgnite", true).GetValue <bool>() &&
                ignitedmg > HealthPrediction.GetHealthPrediction(target, 700) && hasIgnite &&
                !CombatHelper.CheckCriticalBuffs(target) &&
                ((savedQ == null ||
                  (savedQ != null && target.Distance(savedQ.position) < QExplosionRange &&
                   getQdamage(target) > target.Health)) || useIgnite))
            {
                player.Spellbook.CastSpell(player.GetSpellSlot("SummonerDot"), target);
            }
            var rqCombo = R.GetDamage(target) + getQdamage(target) + (hasIgnite ? ignitedmg : 0);

            if (Q.CanCast(target) && config.Item("useq", true).GetValue <bool>() && savedQ == null && SimpleQ)
            {
                if (Q.CastIfHitchanceEquals(target, HitChance.VeryHigh, config.Item("packets").GetValue <bool>()))
                {
                    return;
                }
            }
            if (Q.IsReady() && config.Item("useq", true).GetValue <bool>() && savedQ != null &&
                target.Distance(savedQ.position) < QExplosionRange)
            {
                DetonateQ();
            }
            if (config.Item("usee", true).GetValue <bool>())
            {
                if (E.CanCast(target))
                {
                    CastE(target, combodmg);
                }
            }
            if (W.IsReady() && (!SimpleQ || !Q.IsReady()) && config.Item("usew", true).GetValue <bool>() &&
                player.Distance(target) < 300 && Orbwalking.CanMove(100) &&
                target.Health > combodmg - getWdamage(target))
            {
                W.Cast(config.Item("packets").GetValue <bool>());
            }
            if (R.IsReady())
            {
                if (R.CastIfWillHit(
                        target, config.Item("Rmin", true).GetValue <Slider>().Value, config.Item("packets").GetValue <bool>()))
                {
                    return;
                }
                var logic = config.Item("user", true).GetValue <bool>();
                if (config.Item("rtoq", true).GetValue <bool>() && savedQ != null && !SimpleQ &&
                    (target.Distance(qPos) > QExplosionRange ||
                     (target.Health < rqCombo && target.Health > getQdamage(target))) &&
                    target.Distance(player) < R.Range - 100 &&
                    (target.Health < rqCombo || CheckRPushForAlly(target, rqCombo)) &&
                    target.Position.Distance(savedQ.position) < 550 + QExplosionRange / 2)
                {
                    var cast = Prediction.GetPrediction(target, 1000f).UnitPosition.Extend(savedQ.position, -200);
                    if (cast.Distance(player.Position) < R.Range)
                    {
                        //Console.WriteLine("R to Q");
                        if (target.Health < rqCombo && target.Health > rqCombo - ignitedmg &&
                            player.Distance(target) < 580)
                        {
                            useIgnite = true;
                        }

                        Utility.DelayAction.Add(400, () => useIgnite = false);
                        HandeR(target, savedQ.position, true);
                        return;
                    }
                }
                if (config.Item("rtoally", true).GetValue <bool>() && logic &&
                    target.Health - rqCombo < target.MaxHealth * 0.5f)
                {
                    var allies =
                        HeroManager.Allies.Where(
                            a =>
                            !a.IsDead && !a.IsMe && a.HealthPercent > 40 && a.Distance(target) < 700 &&
                            a.Distance(target) > 300).OrderByDescending(a => TargetSelector.GetPriority(a));
                    if (allies.Any())
                    {
                        foreach (var ally in allies)
                        {
                            var cast =
                                Prediction.GetPrediction(target, 1000f)
                                .UnitPosition.Extend(Prediction.GetPrediction(ally, 400f).UnitPosition, -200);
                            if (cast.CountEnemiesInRange(1000) <= cast.CountAlliesInRange(1000) &&
                                cast.Distance(player.Position) < R.Range &&
                                cast.Extend(target.Position, 500).Distance(ally.Position) <
                                target.Distance(ally.Position))
                            {
                                //Console.WriteLine("R to Ally: " + ally.Name);
                                HandeR(target, Prediction.GetPrediction(ally, 400f).UnitPosition, false);
                                return;
                            }
                        }
                    }
                    var turret =
                        ObjectManager.Get <Obj_AI_Turret>()
                        .OrderBy(t => t.Distance(target))
                        .FirstOrDefault(t => t.Distance(target) < 2000 && t.IsAlly && !t.IsDead);

                    if (config.Item("rtoturret", true).GetValue <bool>() && turret != null)
                    {
                        var pos = target.Position.Extend(turret.Position, -200);
                        if (target.Distance(turret) > pos.Extend(target.Position, 500).Distance(turret.Position))
                        {
                            //nothing
                        }
                        else if ((pos.CountEnemiesInRange(1000) < pos.CountAlliesInRange(1000) &&
                                  target.Health - rqCombo < target.MaxHealth * 0.4f) ||
                                 (ObjectManager.Get <Obj_AI_Turret>()
                                  .Count(t => t.Distance(pos) < 950 && t.IsAlly && t.IsValid && !t.IsDead) > 0 &&
                                  target.Health - combodmg < target.MaxHealth * 0.5f))
                        {
                            //Console.WriteLine("R to Turret");
                            HandeR(target, turret.Position, false);
                            return;
                        }
                    }
                }
                if (config.Item("rtokill", true).GetValue <bool>() && config.Item("user", true).GetValue <bool>() &&
                    R.GetDamage(target) > target.Health && !justE && !justQ &&
                    (savedQ == null ||
                     (savedQ != null && !qPos.IsValid() && target.Distance(savedQ.position) > QExplosionRange)) &&
                    (target.CountAlliesInRange(700) <= 1 || player.HealthPercent < 35))
                {
                    //Console.WriteLine("R to Kill");
                    var pred = R.GetPrediction(target, true);
                    if (pred.Hitchance >= HitChance.VeryHigh)
                    {
                        R.Cast(pred.CastPosition);
                    }
                    //R.CastIfHitchanceEquals(target, HitChance.VeryHigh, config.Item("packets").GetValue<bool>());
                    return;
                }
            }
        }
示例#31
0
        private static void UseQSS()
        {
            var qss      = LeagueSharp.Common.Data.ItemData.Quicksilver_Sash.GetItem();
            var scimitar = LeagueSharp.Common.Data.ItemData.Mercurial_Scimitar.GetItem();

            if (qss.IsReady())
            {
                if (Player.HasBuffOfType(BuffType.SpellShield) || Player.HasBuffOfType(BuffType.SpellImmunity))
                {
                    return;
                }

                if (Player.HasBuffOfType(BuffType.Suppression) || Player.HasBuffOfType(BuffType.Sleep))
                {
                    qss.Cast();
                    return;
                }
                if (HeroManager.Enemies.Any(e => e.BaseSkinName.ToLower().Contains("yasuo") && Player.HasBuffOfType(BuffType.Knockup) || Player.HasBuffOfType(BuffType.Knockback)))
                {
                    qss.Cast();
                    return;
                }
                if (Player.CountEnemiesInRange(650) >= Player.CountAlliesInRange(650))
                {
                    if (Player.HasBuffOfType(BuffType.Stun) || Player.HasBuffOfType(BuffType.Knockup) ||
                        Player.HasBuffOfType(BuffType.Charm) || Player.HasBuffOfType(BuffType.Flee) ||
                        Player.HasBuffOfType(BuffType.Fear))
                    {
                        qss.Cast();
                        return;
                    }
                }
                var cassiopeia = HeroManager.Enemies.FirstOrDefault(e => e.BaseSkinName == "Cassiopeia");
                if (Player.HasBuffOfType(BuffType.Poison) && cassiopeia != null && cassiopeia.Distance(Player) < 450 &&
                    Player.HealthPercent < 30)
                {
                    qss.Cast();
                    return;
                }
            }

            else if (scimitar.IsReady())
            {
                if (Player.HasBuffOfType(BuffType.SpellShield) || Player.HasBuffOfType(BuffType.SpellImmunity))
                {
                    return;
                }

                if (Player.HasBuffOfType(BuffType.Suppression) || Player.HasBuffOfType(BuffType.Sleep))
                {
                    scimitar.Cast();
                    return;
                }
                if (HeroManager.Enemies.Any(e => e.BaseSkinName.ToLower().Contains("yasuo") && Player.HasBuffOfType(BuffType.Knockup) || Player.HasBuffOfType(BuffType.Knockback)))
                {
                    scimitar.Cast();
                    return;
                }
                if (Player.CountEnemiesInRange(650) >= Player.CountAlliesInRange(650))
                {
                    if (Player.HasBuffOfType(BuffType.Stun) || Player.HasBuffOfType(BuffType.Knockup) ||
                        Player.HasBuffOfType(BuffType.Charm) || Player.HasBuffOfType(BuffType.Flee) ||
                        Player.HasBuffOfType(BuffType.Fear))
                    {
                        scimitar.Cast();
                        return;
                    }
                }
                var cassiopeia = HeroManager.Enemies.FirstOrDefault(e => e.BaseSkinName == "Cassiopeia");
                if (Player.HasBuffOfType(BuffType.Poison) && cassiopeia != null && cassiopeia.Distance(Player) < 450 &&
                    Player.HealthPercent < 30)
                {
                    scimitar.Cast();
                    return;
                }
            }
        }
示例#32
0
 private static void Interrupter2_OnInterruptableTarget(Obj_AI_Hero sender, Interrupter2.InterruptableTargetEventArgs args)
 {
     if (E.CanCast(sender))
     {
         if (Player.CountAlliesInRange(E.Range + 50) < sender.CountAlliesInRange(E.Range + 50))
         {
             E.Cast(sender);
         }
         else
         {
             E.CastToReverse(sender);
         }
     }
     if (Q.CanCast(sender) && SpellQ.GetState()== QState.ThreshQ)
     {
         Q.Cast(sender);
     }
 }
示例#33
0
        static void GravesOnUpdate(EventArgs args)
        {
            var user = mainMenu.Item("usercombo").GetValue<bool>();
            rtarget = TargetSelector.GetTarget(Chargeshot.Range, TargetSelector.DamageType.Physical);

            if (rtarget.IsValidTarget() && Chargeshot.IsReady())
            {
                if (Kappa(rtarget.ServerPosition, Chargeshot.Width, Chargeshot.Range) >=
                    mainMenu.Item("rmulti").GetValue<Slider>().Value)
                {
                    if (mainMenu.Item("combokey").GetValue<KeyBind>().Active)
                    {
                        if (rtarget.CountAlliesInRange(700) >= 2)
                            Chargeshot.CastIfHitchanceEquals(rtarget, HitChance.Medium);
                    }
                }
            }

            if (mainMenu.Item("combokey").GetValue<KeyBind>().Active)
                GravesCombo();

            if (mainMenu.Item("fleekey").GetValue<KeyBind>().Active)
            {
                if (!Me.IsImmovable)
                    Me.IssueOrder(GameObjectOrder.MoveTo, Game.CursorPos);

                if (Smokescreen.IsReady() && rtarget.IsValidTarget(Smokescreen.Range))
                    Smokescreen.CastIfHitchanceEquals(rtarget, HitChance.Medium);

                else if (Quickdraw.IsReady())
                {
                    if (Utils.GameTimeTickCount - LastE > 500)
                        Quickdraw.Cast(Game.CursorPos);
                }
            }

            if (GetRDamage(rtarget) >= rtarget.Health && user)
            {
                if (rtarget.Distance(Me.ServerPosition) <= Me.AttackRange &&
                    Me.GetAutoAttackDamage(rtarget, true) * 3 >= rtarget.Health)
                    return;

                Chargeshot.CastIfHitchanceEquals(rtarget, HitChance.High);
            }
        }
示例#34
0
        private void Combo()
        {
            Obj_AI_Hero target = TargetSelector.GetTarget(1700, TargetSelector.DamageType.Magical, true);

            if (target == null || target.IsInvulnerable || target.MagicImmune)
            {
                return;
            }
            if (config.Item("useItems").GetValue <bool>())
            {
                ItemHandler.UseItems(target, config, ComboDamage(target));
            }
            var  edmg      = getEdamage(target);
            var  qdmg      = getQdamage(target);
            var  ignitedmg = (float)player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite);
            bool hasIgnite = player.Spellbook.CanUseSpell(player.GetSpellSlot("SummonerDot")) == SpellState.Ready;

            if (config.Item("useIgnite", true).GetValue <bool>() &&
                ignitedmg > HealthPrediction.GetHealthPrediction(target, 700) && hasIgnite &&
                !CombatHelper.CheckCriticalBuffs(target) &&
                (!ActiveQ ||
                 (!(CombatHelper.IsFacing(player, target.Position, 30) && target.Distance(player) < Q.Range))))
            {
                player.Spellbook.CastSpell(player.GetSpellSlot("SummonerDot"), target);
            }
            if (Q.CanCast(target) && config.Item("useq", true).GetValue <bool>() && Qhit(target.Position) &&
                (preventSilence(Q) ||
                 (target.Health < PassiveDmg(target) * 2 || qdmg > target.Health) &&
                 target.Distance(player) < Orbwalking.GetRealAutoAttackRange(target)))
            {
                Q.Cast(target.Position);
            }
            if (config.Item("usee", true).GetValue <bool>() && E.CanCast(target) &&
                (((preventSilence(E) ||
                   (target.Health < PassiveDmg(target) * 2 &&
                    target.Distance(player) < Orbwalking.GetRealAutoAttackRange(target))) &&
                  (!ActiveE ||
                   System.Environment.TickCount - lastE > config.Item("eDelay", true).GetValue <Slider>().Value)) ||
                 edmg > target.Health))
            {
                E.CastIfHitchanceEquals(target, HitChance.High);
            }
            if (W.IsReady() && config.Item("wSpeed", true).GetValue <bool>() && ActiveQ && preventSilence(W) &&
                target.Distance(player) < Q.Range &&
                Prediction.GetPrediction(target, 0.2f).UnitPosition.Distance(player.Position) > Q.Range)
            {
                W.Cast();
            }
            var canR = ComboDamage(target) > target.Health && qdmg < target.Health && target.Distance(player) < Q.Range &&
                       !Silenced;

            if (R.IsReady() &&
                (((target.Health <
                   getRdamage(target) * ((target.CountAlliesInRange(600) > 0 && target.HealthPercent > 15) ? 5 : 3) &&
                   target.Distance(player) > Q.Range) ||
                  (target.Distance(player) < Q.Range && target.Health < getRdamage(target) * 3 + edmg &&
                   target.Health > qdmg)) ||
                 player.CountEnemiesInRange(R.Range) >= config.Item("Rmin", true).GetValue <Slider>().Value))
            {
                HandleR(target, canR);
            }
        }
示例#35
0
        public static void Combo()
        {
            var target = TargetSelector.GetTarget(W.Range, TargetSelector.DamageType.Physical);

            if (!FishbonesActive() && target.Distance(Player.Position) > 565f &&
                target.Distance(Player.Position) < CalcTotalRange() && Z.GetValue <bool>("spells.q"))
            {
                Q.Cast();
            }
            else if (FishbonesActive() && Z.GetValue <bool>("spells.q") && target.Distance(Player.Position) < 565f &&
                     target.Health + 10 > Player.GetAutoAttackDamage(target) && target.CountEnemiesInRange(150f) <= 1)
            {
                Q.Cast();
            }
            else if (!FishbonesActive() && Z.GetValue <bool>("spells.q") && target.Distance(Player.Position) < 565f &&
                     target.CountEnemiesInRange(150f) >= 2)
            {
                Q.Cast();
            }

            if (target.IsMoving() && target.IsFacing(Player) &&
                E.IsReady() &&
                E.IsInRange(target) &&
                Z.GetValue <bool>("spells.e") &&
                Z.GetValue <bool>("spells.e.def"))
            {
                if (Z.GetValue <bool>("hc.e"))
                {
                    E.CastIfHitchanceEquals(target, HitChance.High);
                }
                else
                {
                    E.Cast(target);
                }
            }
            else if (Game.Time + E.Delay + 1 / 2 <= target.Buffs
                     .OrderByDescending(x => x.EndTime - Game.Time)
                     .Where(x => x.Type == BuffType.Slow)
                     .Select(x => x.EndTime)
                     .FirstOrDefault() &&
                     Z.GetValue <bool>("spells.e") &&
                     E.IsReady() &&
                     E.IsInRange(target))
            {
                E.Cast(E.PredOut(target).CastPosition);
            }
            else if (E.IsReady() && Z.GetValue <bool>("spells.e") &&
                     (target.HasBuffOfType(BuffType.Stun) ||
                      target.HasBuffOfType(BuffType.Snare) ||
                      target.HasBuffOfType(BuffType.Taunt) ||
                      target.HasBuffOfType(BuffType.Fear) ||
                      target.HasBuffOfType(BuffType.Charm)))
            {
                if (Z.GetValue <bool>("hc.e"))
                {
                    E.CastIfHitchanceEquals(target, HitChance.High);
                }
                else
                {
                    E.Cast(target);
                }
            }

            if (W.IsReady() &&
                W.IsInRange(target) &&
                Z.GetValue <bool>("spells.w"))
            {
                if ((!target.IsFacing(Player) && Player.IsFacing(target)) ||
                    Player.CountEnemiesInRange(565f) == 0 ||
                    (W.GetDamage(target) > target.Health + 10 && Player.GetAutoAttackDamage(target) < target.Health) ||
                    (target.HasBuff("Recall") ||
                     target.HasBuffOfType(BuffType.Stun) ||
                     target.HasBuffOfType(BuffType.Snare) ||
                     target.HasBuffOfType(BuffType.Taunt) ||
                     target.HasBuffOfType(BuffType.Fear) ||
                     target.HasBuffOfType(BuffType.Charm) ||
                     target.HasBuffOfType(BuffType.Suppression)) ||
                    Player.CountAlliesInRange(700f) >= 2)
                {
                    if (Z.GetValue <bool>("hc.w"))
                    {
                        W.CastIfHitchanceEquals(target, HitChance.High);
                    }
                    else
                    {
                        W.Cast(target);
                    }
                }
            }

            if (R.IsReady() &&
                R.IsInRange(target) &&
                Z.GetValue <bool>("spells.r") &&
                R.GetDamage(target) > target.Health + 20 &&
                !W.IsInRange(target))
            {
                if (Z.GetValue <bool>("hc.r"))
                {
                    R.CastIfHitchanceEquals(target, HitChance.High);
                }
                else
                {
                    R.Cast(target);
                }
            }
        }