Beispiel #1
0
        //from mundo TheKushStyle
        private void Combo(Obj_AI_Hero target)
        {
            var ActiveW = false;
            if (Player.HasBuff("BurningAgony"))
            {
                ActiveW = true;
            }
            else
            {
                ActiveW = false;
            }

            if (Q.CastCheck(target, "ComboQ"))
            {
                Q.CastIfHitchanceEquals(Target, HitChance.Low);
            }

            if (target.IsValidTarget() && W.IsReady() && Player.Distance(target) <= W.Range && !ActiveW)
            {
                W.Cast();
            }
            if (target.IsValidTarget() && Player.Distance(target) > 700f && ActiveW)
            {
                W.Cast();
            }

            if (E.IsReady() && Player.Distance(target) <= E.Range)
            {
                E.Cast();
            }
        }
Beispiel #2
0
        static void Interrupter2_OnInterruptableTarget(Obj_AI_Hero sender, Interrupter2.InterruptableTargetEventArgs args)
        {
            if (!Program.Config.Item("EnabledInterrupter").GetValue<bool>() || !sender.IsValidTarget()) return;
            Interrupter2.DangerLevel a;
            switch (Program.Config.Item("minChannel").GetValue<StringList>().SelectedValue)
            {
                case "HIGH":
                    a = Interrupter2.DangerLevel.High;
                    break;
                case "MEDIUM":
                    a = Interrupter2.DangerLevel.Medium;
                    break;
                default:
                    a = Interrupter2.DangerLevel.Low;
                    break;
            }

            if (args.DangerLevel == Interrupter2.DangerLevel.High ||
                args.DangerLevel == Interrupter2.DangerLevel.Medium && a != Interrupter2.DangerLevel.High ||
                args.DangerLevel == Interrupter2.DangerLevel.Medium && a != Interrupter2.DangerLevel.Medium &&
                a != Interrupter2.DangerLevel.High)
            {
                if (Program.spells[Spells.E].IsReady() && sender.IsValidTarget(Program.spells[Spells.E].Range))
                {
                    Program.spells[Spells.E].Cast(sender);
                }
            }
        }
Beispiel #3
0
        //from mundo TheKushStyle
        private void Combo(Obj_AI_Hero target)
        {
            var ActiveW = false;
            if ()
            {
                ActiveW = true;
            }
            else
            {
                ActiveW = false;
            }

            if (Q.CastCheck(target, "ComboQ"))
            {
                Q.CastIfHitchanceEquals(Target, HitChance.High);
            }

            if (target.IsValidTarget() && W.IsReady() && Player.Distance(target) <= 500 && !Player.HasBuff("BurningAgony"))
            {
                W.Cast();
            }
            if (target.IsValidTarget() && Player.Distance(target) > 500 && Player.HasBuff("BurningAgony"))
            {
                W.Cast();
            }

            if (E.IsReady() && Player.Distance(target) <= 700)
            {
                E.Cast();
            }
        }
Beispiel #4
0
        private void Combo(Obj_AI_Hero t)
        {
            if (E.IsReady() && t.IsValidTarget(Q.Range) && Q.IsReady())
            {
                //xsalice Code
                var vec = t.ServerPosition - Player.ServerPosition;
                var castBehind = E.GetPrediction(t).CastPosition + Vector3.Normalize(vec) * 100;
                E.Cast(castBehind);
                Utility.DelayAction.Add(200, () => Q.Cast(castBehind));
            }
            if (W.IsReady())
            {
                if (t.IsValidTarget(W.Range))
                    W.Cast();
            }
            if (Q.IsReady() && !E.IsReady())
            {
                if (t.IsValidTarget(Q.Range))
                    Q.Cast(t, UsePackets, true);
            }
            if (R.IsReady())
            {
                if (R.IsKillable(t))
                {
                    R.Cast(t);
                }
                R.CastIfWillHit(t, 2);

            }
        }
 public static void CastQ(Obj_AI_Hero target)
 {
     if (!target.IsValidTarget()) return;
     if(target.IsValidTarget(Q.Range) && Q.IsReady()&&Q.IsInRange(target.ServerPosition) && !firstQ && isEn("UseQ") && (Game.Time-QCastTime)>=(menu.Item("SecondQDelay").GetValue<Slider>().Value/1000))
     {
         Q.Cast(target, true, false);
         firstQ = true;
         QCastTime = Game.Time;
     }
 }
Beispiel #6
0
 public static bool UseBotrk(Obj_AI_Hero target)
 {
     if (Config.BoolLinks["itemsBotrk"].Value && BOTRK.IsReady() && target.IsValidTarget(BOTRK.Range) &&
         player.Health + player.GetItemDamage(target, Damage.DamageItems.Botrk) < player.MaxHealth)
     {
         return BOTRK.Cast(target);
     }
     else if (Config.BoolLinks["itemsCutlass"].Value && CUTLASS.IsReady() && target.IsValidTarget(CUTLASS.Range))
     {
         return CUTLASS.Cast(target);
     }
     return false;
 }
Beispiel #7
0
 public static bool UseBotrk(Obj_AI_Hero target)
 {
     if (Settings.UseBotrk && BOTRK.IsReady() && target.IsValidTarget(BOTRK.Range) &&
         player.Health + player.GetItemDamage(target, Damage.DamageItems.Botrk) < player.MaxHealth)
     {
         return BOTRK.Cast(target);
     }
     else if (Settings.UseCutlass && CUTLASS.IsReady() && target.IsValidTarget(CUTLASS.Range))
     {
         return CUTLASS.Cast(target);
     }
     return false;
 }
Beispiel #8
0
 public static void OnPossibleToInterrupt(Obj_AI_Hero sender, Interrupter2.InterruptableTargetEventArgs args)
 {
     if (Program.E.IsReady() && args.DangerLevel == Interrupter2.DangerLevel.High && sender.IsValidTarget(700))
     {
         Program.E.Cast(Program.E.GetPrediction(sender).UnitPosition);
     }
 }
Beispiel #9
0
 private static void AutoIgnite(Obj_AI_Hero enemy)
 {
     if (enemy.IsValidTarget(600f) && enemy.Health <= 50 + (20 * _player.Level) && IgniteSlot.IsReady())
     {
         _player.Spellbook.CastSpell(IgniteSlot, enemy);
     }
 }
Beispiel #10
0
 private void Interrupter_OnInterruptable(Obj_AI_Hero sender, Interrupter2.InterruptableTargetEventArgs args)
 {
     if (sender.IsValidTarget() && IsMenuEnabled("Interrupter") && E.IsReady())
     {
         E.CastIfHitchanceEquals(sender, CustomHitChance, Packets());
     }
 }
Beispiel #11
0
 public static void CastSmiteHero(Obj_AI_Hero target)
 {
     if (!target.IsValidTarget())
     {
         return;
     }
     if (Program._GameInfo.CurrentMonster == 13 && !target.Name.Contains("Dragon"))
     {
         return;
     }
     if (smiteSlot != SpellSlot.Unknown)
     {
         bool smiteReady = ObjectManager.Player.Spellbook.CanUseSpell(smiteSlot) == SpellState.Ready;
         if (target != null)
         {
             if (smite.CanCast(target) && smiteReady && player.Distance(target.Position) <= smite.Range &&
                 target.Health > Helpers.GetComboDMG(player, target) * 0.7f &&
                 player.Distance(target) < Orbwalking.GetRealAutoAttackRange(target) &&
                 Program._GameInfo.SmiteableMob == null)
             {
                 smite.Cast(target);
             }
         }
     }
 }
 public static void SetTarget(Obj_AI_Hero hero)
 {
     if (hero.IsValidTarget())
     {
         Selected.Target = hero;
     }
 }
Beispiel #13
0
 public static int EnemyWStackCount(Obj_AI_Hero t)
 {
     return
         t.Buffs.Where(xBuff => xBuff.Name == "varuswdebuff" && t.IsValidTarget(Q.Range))
             .Select(xBuff => xBuff.Count)
             .FirstOrDefault();
 }
Beispiel #14
0
        public static void Combo(Obj_AI_Hero t)
        {
            var useQ = Menu.Item("UseQ").GetValue<bool>();
            var useR = Menu.Item("UseR").GetValue<bool>();
            var alwaysStun = Menu.Item("alwaysStun").GetValue<bool>();
            var numOfEnemies = Menu.Item("MinEnemys").GetValue<Slider>().Value;
            t = TargetSelector.GetTarget(Q.Range, TargetSelector.DamageType.Magical);

            if (useQ && Q.IsReady())
            {
                if (t.IsValidTarget())
                {
                    if (alwaysStun)
                    {
                        castStunQ(t);
                    }
                    else
                    {
                        Q.Cast(t);
                    }
                }
            }
            if (useR && R.IsReady())
            {
                var t2 = TargetSelector.GetTarget(2500, TargetSelector.DamageType.Magical);
                if (GetEnemys(t2) >= numOfEnemies)
                {
                    R.Cast(t2, false, true);
                }

            }
        }
Beispiel #15
0
 public static void CastR(Obj_AI_Hero target)
 {
     if (isCombo() && target.IsValidTarget() && R.IsInRange(target.ServerPosition) && isEn("UseR"))
     {
         R.Cast(target,true);
     }
 }
Beispiel #16
0
 private void Interrupter2_OnInterruptableTarget(Obj_AI_Hero sender, Interrupter2.InterruptableTargetEventArgs args)
 {
     if (E.IsReady() && Config.Item("inter", true).GetValue<bool>() && sender.IsValidTarget(E.Range))
     {
         E.Cast(sender.ServerPosition);
     }
 }
Beispiel #17
0
 private void Interrupter2_OnInterruptableTarget(Obj_AI_Hero unit, Interrupter2.InterruptableTargetEventArgs args)
 {
     if (E.IsReady() && Config.Item("EInterruptable").GetValue<bool>() && unit.IsValidTarget(E.Range))
     {
         E.Cast(unit);
     }
 }
Beispiel #18
0
 private void Interrupter2_OnInterruptableTarget(Obj_AI_Hero sender, Interrupter2.InterruptableTargetEventArgs args)
 {
     if (E.IsReady() && sender.IsValidTarget(E.Range))
     {
         E.Cast(sender);
     }
 }
Beispiel #19
0
 public override void OnPossibleToInterrupt(Obj_AI_Hero unit, Interrupter2.InterruptableTargetEventArgs spell)
 {
     if (E.IsReady() && unit.IsValidTarget(E.Range))
     {
         E.Cast(unit);
     }
 }
Beispiel #20
0
 public static Vector3? GetQPrediction(Obj_AI_Hero unit)
 {
     var normalPrediction = Spells[SpellSlot.Q].GetPrediction(unit);
     if (normalPrediction.Hitchance == HitChance.Collision || normalPrediction.Hitchance == HitChance.OutOfRange)
     {
         //There's collision or is out of range. We use Q shard prediction
         //Get Shard prediction
         var shardPrediction = QShard.GetPrediction(unit);
         if (shardPrediction.Hitchance >= HitChance.High) //TODO Might need to change to >= High in case it doesn't cast too often
         {
             //Make a list of positions including the Cast Position for the Shard Prediction
             var positionsList = new List<Vector2>();
             {
                 positionsList.Add(shardPrediction.CastPosition.To2D());
             }
             //Check the collision Objects between my position and the cast position
             var collisionObjects = QShard.GetCollision(ObjectManager.Player.ServerPosition.To2D(), positionsList);
             //If there's a minion/Any collisionable object in between
             if (collisionObjects.Any())
             {
                 return shardPrediction.CastPosition;
             }
         }
     }
     if (normalPrediction.Hitchance >= HitChance.High && unit.IsValidTarget(Spells[SpellSlot.Q].Range))
     {
         //The Hitchance is not Collision or Out of Range, Normal prediction.
         return normalPrediction.CastPosition;
     }
     return null;
 }
Beispiel #21
0
 private static void CastItems(Obj_AI_Hero currTarget)
 {
     foreach (var item in items)
     {
         if (Items.CanUseItem(item.Id) && currTarget.IsValidTarget(item.Range)) Items.UseItem(item.Id);
     }
 }
Beispiel #22
0
        public static void doCombo(Obj_AI_Hero target)
        {
            igniteIfKIllable(target);
            if (!target.IsValidTarget())
                return;

            if (!W.IsReady() && !E.IsReady() && R.IsReady() && Rdata.Name == "TalonShadowAssault" && (target.Health > getAAdmg(target) || targetInRange(target, 125f))
                && target.Health<(getRdmg(target)*2 + getTargetBleedDmg(target)))
            {
                PredictionOutput po = R.GetPrediction(target);
                if (po.Hitchance >= HitChance.Medium)
                {
                    R.Cast();
                    posRCast = Player.ServerPosition;
                }
            }

            if (Rdata.Name == "TalonShadowAssault")
            {
                if (target.Health<= getRdmg(target) && target.Distance(posRCast) < R.Range)
                    R.Cast();
            }

            if (E.IsReady() && targetInRange(target, E.Range))
            {
                E.Cast(target);
            }
            if (W.IsReady() && !E.IsReady() && targetInRange(target, W.Range) && !targetInRange(target, 100) && !Player.IsChanneling
                && (!targetInRange(target,250) || targetHasCut(target)))
            {

                    W.Cast(target);
            }
            castItemsFull(target);
        }
Beispiel #23
0
 private void OnPossibleToInterrupt(Obj_AI_Hero unit, Interrupter2.InterruptableTargetEventArgs args)
 {
     if (config.Item("useqint", true).GetValue<bool>())
     {
         if (unit.IsValidTarget(Q.Range) && Q.IsReady() && me.Distance(unit) < Q.Range)
         {
             Q.Cast(unit.Position, config.Item("packets").GetValue<bool>());
         }
     }
     if (config.Item("userint", true).GetValue<bool>())
     {
         if (unit.IsValidTarget(R.Range) && R.IsReady() && me.Distance(unit) < R.Range)
         {
             R.Cast(unit.Position, config.Item("packets").GetValue<bool>());
         }
     }
 }
Beispiel #24
0
 public static bool UseRanduin(Obj_AI_Hero target)
 {
     if (Config.BoolLinks["itemsRanduin"].Value && RANDUIN.IsReady() && target.IsValidTarget(RANDUIN.Range))
     {
         return RANDUIN.Cast();
     }
     return false;
 }
Beispiel #25
0
        private void OnInterrupter(Obj_AI_Hero sender, DZInterrupter.InterruptableTargetEventArgs args)
        {
            if (Variables.Spells[SpellSlot.R].IsReady() 
                && sender.IsValidTarget(Variables.Spells[SpellSlot.Q].Range) 
                && args.DangerLevel >= DZInterrupter.DangerLevel.High
                && Variables.AssemblyMenu.GetItemValue<bool>("dzaio.champion.orianna.extra.interrupter"))
            {
                switch (
                    Variables.AssemblyMenu.GetItemValue<StringList>("dzaio.champion.orianna.extra.interrupter.mode")
                        .SelectedIndex)
                {
                    case 0:
                        this.BallManager.ProcessCommand(new Command()
                        {
                            SpellCommand = Commands.Q,
                            Where = sender.ServerPosition
                        });

                        var actionDelay =
                            (int)
                                (BallManager.BallPosition.Distance(sender.ServerPosition) /
                                 Variables.Spells[SpellSlot.Q].Speed * 1000f +
                                 Variables.Spells[SpellSlot.Q].Delay * 1000f + Game.Ping / 2f + 100f);

                        Utility.DelayAction.Add(
                            actionDelay, () =>
                            {
                                var enemiesInRange =
                                    BallManager.BallPosition.GetEnemiesInRange(Variables.Spells[SpellSlot.R].Range);

                                if (enemiesInRange.Count >= 1 &&
                                    enemiesInRange.Any(n => n.NetworkId == sender.NetworkId))
                                {
                                    Variables.Spells[SpellSlot.R].Cast();
                                }
                            });
                
                    break;
                    case 1:
                        var ballPosition = BallManager.BallPosition;
                        if (sender.IsValidTarget(Variables.Spells[SpellSlot.R].Range / 2f, true, ballPosition))
                        {
                            var enemiesInRange =
                                    BallManager.BallPosition.GetEnemiesInRange(Variables.Spells[SpellSlot.R].Range);

                            if (enemiesInRange.Count >= 1 &&
                                enemiesInRange.Any(n => n.NetworkId == sender.NetworkId))
                            {
                                Variables.Spells[SpellSlot.R].Cast();
                            }
                        }
                    break;
                }
                

                
            }
        }
Beispiel #26
0
 // combo from sigma series
 private void Combo(Obj_AI_Hero target)
 {
     if (target != null)
     {
         if (target.IsValidTarget(Q.Range) && Q.IsReady())
         {
             Q.Cast(target);
             return;
         }
         //castItems(target);
         if (target.IsValidTarget(R.Range) && R.IsReady())
         {
             R.Cast(target, true);
         }
         if (target.IsValidTarget(Orbwalking.GetRealAutoAttackRange(Player)) && W.IsReady())
         {
             W.Cast(Player);
             return;
         }
         if (target.IsValidTarget(800) && E.IsReady() && UseEAgain)
         {
             if (target.IsValidTarget(370 + 250) && ESpell.Name == "FizzJump")
             {
                 E.Cast(target, true);
                 UseEAgain = false;
                 Utility.DelayAction.Add(250, () => UseEAgain = true);
             }
             if (target.IsValidTarget(370 + 150) && target.IsValidTarget(330) == false &&
                 ESpell.Name == "fizzjumptwo")
             {
                 E.Cast(target, true);
             }
         }
     }
 }
Beispiel #27
0
 private void Interrupter2_OnInterruptableTarget(
     Obj_AI_Hero unit,
     Interrupter2.InterruptableTargetEventArgs args)
 {
     if (R.IsReady() && Config.Item("RInterruptable" + Id).GetValue<bool>() && unit.IsValidTarget(1500))
     {
         R.Cast(unit);
     }
 }
Beispiel #28
0
 internal static void Interrupter2_OnInterruptableTarget(Obj_AI_Hero sender, Interrupter2.InterruptableTargetEventArgs args)
 {
     if (sender.IsValidTarget(KL.Spellbook["E"].Range) && KL.Spellbook["E"].IsReady())
     {
         if (Config.Item("useeint").GetValue<bool>())
         {
             KL.Spellbook["E"].Cast(sender.ServerPosition);
         }
     }
 }
Beispiel #29
0
 internal static void OnInterrupt(Obj_AI_Hero sender, Interrupter2.InterruptableTargetEventArgs args)
 {
     if (args.DangerLevel >= Interrupter2.DangerLevel.Medium
         && MenuExtensions.GetItemValue<bool>("iseriesr.vayne.misc.general.antigp")
         && Variables.spells[SpellSlot.E].IsReady()
         && sender.IsValidTarget(Variables.spells[SpellSlot.E].Range))
     {
         Variables.spells[SpellSlot.E].Cast(sender);
     }
 }
Beispiel #30
0
 /// <summary>
 /// Called on interruptable spell.
 /// </summary>
 /// <param name="sender">The sender.</param>
 /// <param name="args">The <see cref="Interrupter2.InterruptableTargetEventArgs"/> instance containing the event data.</param>
 public static void OnInterruptableTarget(Obj_AI_Hero sender, Interrupter2.InterruptableTargetEventArgs args)
 {
     if (Variables.E.IsReady() &&
         !Bools.IsSpellShielded(sender) &&
         sender.IsValidTarget(Variables.E.Range) &&
         Variables.Menu.Item($"{Variables.MainMenuName}.espell.ir").IsActive())
     {
         Variables.E.CastOnUnit(sender);
     }
 }
Beispiel #31
0
        public static void UseItems(Obj_AI_Hero target, Menu config, float comboDmg = 0f, bool cleanseSpell = false)
        {
            if (config.Item("hyd").GetValue <bool>() && player.BaseSkinName != "Renekton")
            {
                castHydra(target);
            }
            if (config.Item("hyd").GetValue <bool>())
            {
                hydraTarget = target;
                useHydra    = true;
            }
            else
            {
                useHydra = false;
            }
            if (config.Item("ran").GetValue <bool>() && Items.HasItem(randuins.Id) && Items.CanUseItem(randuins.Id))
            {
                if (target != null && player.Distance(target) < randuins.Range &&
                    player.CountEnemiesInRange(randuins.Range) >= config.Item("ranmin").GetValue <Slider>().Value)
                {
                    Items.UseItem(randuins.Id);
                }
            }
            if (config.Item("odin").GetValue <bool>() && target != null && Items.HasItem(odins.Id) &&
                Items.CanUseItem(odins.Id))
            {
                var odinDmg = Damage.GetItemDamage(player, target, Damage.DamageItems.OdingVeils);
                if (config.Item("odinonlyks").GetValue <bool>())
                {
                    if (odinDmg > target.Health)
                    {
                        odins.Cast(target);
                    }
                }
                else if (player.CountEnemiesInRange(odins.Range) >= config.Item("odinmin").GetValue <Slider>().Value ||
                         (Math.Max(comboDmg, odinDmg) > target.Health && player.HealthPercent < 30 &&
                          player.Distance(target) < odins.Range && !CombatHelper.CheckCriticalBuffs(target)))
                {
                    odins.Cast();
                }
            }
            if (target != null && config.Item("bil").GetValue <bool>() && Items.HasItem(bilgewater.Id) &&
                Items.CanUseItem(bilgewater.Id))
            {
                var bilDmg = Damage.GetItemDamage(player, target, Damage.DamageItems.Bilgewater);
                if (config.Item("bilonlyks").GetValue <bool>())
                {
                    if (bilDmg > target.Health)
                    {
                        bilgewater.Cast(target);
                    }
                }
                else if ((player.Distance(target) > config.Item("bilminr").GetValue <Slider>().Value&&
                          IsHeRunAway(target) && (target.Health / target.MaxHealth * 100f) < 40 &&
                          target.Distance(player) > player.AttackRange) ||
                         (Math.Max(comboDmg, bilDmg) > target.Health && (player.Health / player.MaxHealth * 100f) < 50) ||
                         IsURF)
                {
                    bilgewater.Cast(target);
                }
            }
            if (target != null && config.Item("botr").GetValue <bool>() && Items.HasItem(botrk.Id) &&
                Items.CanUseItem(botrk.Id))
            {
                var botrDmg = Damage.GetItemDamage(player, target, Damage.DamageItems.Botrk);
                if (config.Item("botronlyks").GetValue <bool>())
                {
                    if (botrDmg > target.Health)
                    {
                        botrk.Cast(target);
                    }
                }
                else if ((player.Distance(target) > config.Item("botrminr").GetValue <Slider>().Value&&
                          (player.Health / player.MaxHealth * 100f) <
                          config.Item("botrmyhealth").GetValue <Slider>().Value&&
                          (target.Health / target.MaxHealth * 100f) <
                          config.Item("botrenemyhealth").GetValue <Slider>().Value) ||
                         (IsHeRunAway(target) && (target.Health / target.MaxHealth * 100f) < 40 &&
                          target.Distance(player) > player.AttackRange) ||
                         (Math.Max(comboDmg, botrDmg) > target.Health && (player.Health / player.MaxHealth * 100f) < 50) ||
                         IsURF)
                {
                    botrk.Cast(target);
                }
            }
            if (target != null && config.Item("hex").GetValue <bool>() && Items.HasItem(hexgun.Id) &&
                Items.CanUseItem(hexgun.Id))
            {
                var hexDmg = Damage.GetItemDamage(player, target, Damage.DamageItems.Hexgun);
                if (config.Item("hexonlyks").GetValue <bool>())
                {
                    if (hexDmg > target.Health)
                    {
                        hexgun.Cast(target);
                    }
                }
                else if ((player.Distance(target) > config.Item("hexminr").GetValue <Slider>().Value&&
                          IsHeRunAway(target) && (target.Health / target.MaxHealth * 100f) < 40 &&
                          target.Distance(player) > player.AttackRange) ||
                         (Math.Max(comboDmg, hexDmg) > target.Health && (player.Health / player.MaxHealth * 100f) < 50) ||
                         IsURF)
                {
                    hexgun.Cast(target);
                }
            }

            /*
             * if (config.Item("Muramana").GetValue<bool>() &&
             *  ((!MuramanaEnabled && config.Item("MuramanaMinmana").GetValue<Slider>().Value < player.ManaPercent) ||
             *   (MuramanaEnabled && config.Item("MuramanaMinmana").GetValue<Slider>().Value > player.ManaPercent)))
             * {
             *  if (Muramana.IsOwned() && Muramana.IsReady())
             *  {
             *      Muramana.Cast();
             *  }
             *  if (Muramana2.IsOwned() && Muramana2.IsReady())
             *  {
             *      Muramana2.Cast();
             *  }
             * }
             * MuramanaTime = System.Environment.TickCount;
             */
            if (config.Item("you").GetValue <bool>() && Items.HasItem(youmuu.Id) && Items.CanUseItem(youmuu.Id) &&
                target != null && player.Distance(target) < player.AttackRange + 50 && target.HealthPercent < 65)
            {
                youmuu.Cast();
            }

            if (Items.HasItem(frost.Id) && Items.CanUseItem(frost.Id) && target != null &&
                config.Item("frost").GetValue <bool>())
            {
                if ((config.Item("frostmin").GetValue <Slider>().Value <= player.CountEnemiesInRange(2000) ||
                     target.HealthPercent < 40) &&
                    (target.HealthPercent < 40 && config.Item("frostlow").GetValue <bool>() ||
                     !config.Item("frostlow").GetValue <bool>()))
                {
                    frost.Cast(target);
                }
            }

            if (config.Item("Zhonya").GetValue <bool>())
            {
                if (((config.Item("Zhonyadmg").GetValue <Slider>().Value / 100f * player.Health <=
                      Program.IncDamages.GetAllyData(player.NetworkId).DamageTaken ||
                      Program.IncDamages.GetAllyData(player.NetworkId).DamageTaken > player.Health) ||
                     (Danger() && player.HealthPercent < 30)) && player.IsValidTarget(10, false))
                {
                    if (Items.HasItem(Zhonya.Id) && Items.CanUseItem(Zhonya.Id))
                    {
                        Zhonya.Cast();
                        return;
                    }
                    if (Items.HasItem(Wooglet.Id) && Items.CanUseItem(Wooglet.Id))
                    {
                        Wooglet.Cast();
                        return;
                    }
                }
            }

            if (config.Item("Seraph").GetValue <bool>())
            {
                if (((config.Item("SeraphdmgHP").GetValue <Slider>().Value / 100f * player.Health <=
                      Program.IncDamages.GetAllyData(player.NetworkId).DamageTaken ||
                      Program.IncDamages.GetAllyData(player.NetworkId).DamageTaken > player.Health) ||
                     (config.Item("SeraphdmgSh").GetValue <Slider>().Value / 100f * (150 + player.Mana * 0.2f) <=
                      Program.IncDamages.GetAllyData(player.NetworkId).DamageTaken)) || Danger())
                {
                    if (Items.HasItem(Seraph.Id) && Items.CanUseItem(Seraph.Id))
                    {
                        Seraph.Cast();
                    }
                    if (Items.HasItem(SeraphDom.Id) && Items.CanUseItem(SeraphDom.Id))
                    {
                        SeraphDom.Cast();
                    }
                }
            }
            if (Items.HasItem(solari.Id) && Items.CanUseItem(solari.Id) && config.Item("solari").GetValue <bool>())
            {
                if ((config.Item("solariminally").GetValue <Slider>().Value <= player.CountAlliesInRange(solari.Range) &&
                     config.Item("solariminenemy").GetValue <Slider>().Value <= player.CountEnemiesInRange(solari.Range)) ||
                    ObjectManager.Get <Obj_AI_Hero>()
                    .FirstOrDefault(
                        h => h.IsAlly && !h.IsDead && solari.IsInRange(h) && CombatHelper.CheckCriticalBuffs(h)) !=
                    null ||
                    (Program.IncDamages.IncomingDamagesAlly.Any(
                         a => a.Hero.HealthPercent < 50 && (a.DamageTaken > 150 || a.DamageTaken > a.Hero.Health))))
                {
                    solari.Cast();
                }
            }
            if (Items.HasItem(mountain.Id) && Items.CanUseItem(mountain.Id) && config.Item("mountain").GetValue <bool>())
            {
                if (config.Item("castonme").GetValue <bool>() &&
                    ((player.Health / player.MaxHealth * 100f) < config.Item("mountainmin").GetValue <Slider>().Value ||
                     Program.IncDamages.GetAllyData(player.NetworkId).DamageTaken > player.Health) &&
                    (player.CountEnemiesInRange(700f) > 0 || CombatHelper.CheckCriticalBuffs(player)))
                {
                    mountain.Cast(player);
                    return;
                }
                var targ =
                    ObjectManager.Get <Obj_AI_Hero>()
                    .Where(
                        h =>
                        h.IsAlly && !h.IsMe && !h.IsDead && player.Distance(h) < mountain.Range &&
                        config.Item("mountainpriority" + h.ChampionName).GetValue <Slider>().Value > 0 &&
                        ((h.Health / h.MaxHealth * 100f) < config.Item("mountainmin").GetValue <Slider>().Value ||
                         Program.IncDamages.GetAllyData(h.NetworkId).DamageTaken > h.Health));
                if (targ != null)
                {
                    var finaltarg =
                        targ.OrderByDescending(
                            t => config.Item("mountainpriority" + t.ChampionName).GetValue <Slider>().Value)
                        .ThenBy(t => t.Health)
                        .FirstOrDefault();
                    if (finaltarg != null &&
                        (finaltarg.CountEnemiesInRange(700f) > 0 || finaltarg.UnderTurret(true) ||
                         CombatHelper.CheckCriticalBuffs(finaltarg)))
                    {
                        mountain.Cast(finaltarg);
                    }
                }
            }
            if (config.Item("protoBelt").GetValue <bool>() && target != null && player.Distance(target) < 750)
            {
                if (config.Item("protoBeltEHealth").GetValue <Slider>().Value > target.HealthPercent &&
                    (player.Distance(target) > 150 ||
                     player.Distance(target) > Orbwalking.GetRealAutoAttackRange(target)))
                {
                    if (Items.HasItem(ProtoBelt.Id) && Items.CanUseItem(ProtoBelt.Id))
                    {
                        var pred = Prediction.GetPrediction(
                            target, 0.25f, 100, 2000,
                            new[]
                        {
                            CollisionableObjects.Heroes, CollisionableObjects.Minions, CollisionableObjects.Walls,
                            CollisionableObjects.YasuoWall
                        });
                        if (pred.Hitchance >= HitChance.High)
                        {
                            ProtoBelt.Cast(pred.CastPosition);
                        }
                    }
                }
            }
            if (config.Item("glp").GetValue <bool>() && target != null && player.Distance(target) < 650)
            {
                if (config.Item("glpEHealth").GetValue <Slider>().Value > target.HealthPercent)
                {
                    if (Items.HasItem(GLP.Id) && Items.CanUseItem(GLP.Id))
                    {
                        var pred = Prediction.GetPrediction(
                            target, 0.25f, 100, 1500,
                            new[] { CollisionableObjects.Heroes, CollisionableObjects.YasuoWall });
                        if (pred.Hitchance >= HitChance.High)
                        {
                            GLP.Cast(pred.CastPosition);
                        }
                    }
                }
            }
            if (config.Item("QSSEnabled").GetValue <bool>())
            {
                UseCleanse(config, cleanseSpell);
            }
        }
Beispiel #32
0
        static void Drawing_OnDraw(EventArgs args)
        {
            if (Player.IsDead)
            {
                return;
            }

            var Qcircle = Menu.Item("Qcircle").GetValue <Circle>();

            if (Q.IsReady() && Qcircle.Active)
            {
                Render.Circle.DrawCircle(Player.Position, Menu.Item("qrange").GetValue <Slider>().Value, Qcircle.Color, 5);
            }

            var Rcircle = Menu.Item("Rcircle").GetValue <Circle>();

            if (Rcircle.Active)
            {
                Render.Circle.DrawCircle(Player.Position, 5500, Rcircle.Color, 5);
            }

            if (Menu.Item("AAcircle").GetValue <bool>())
            {
                if (W.IsReady())
                {
                    Color temp  = Color.Gold;
                    var   wName = Player.Spellbook.GetSpell(SpellSlot.W).Name;

                    if (wName == "goldcardlock")
                    {
                        temp = Color.Gold;
                    }
                    else if (wName == "bluecardlock")
                    {
                        temp = Color.Blue;
                    }
                    else if (wName == "redcardlock")
                    {
                        temp = Color.Red;
                    }
                    else if (wName == "PickACard")
                    {
                        temp = Color.LightGreen;
                    }

                    Render.Circle.DrawCircle(Player.Position, Orbwalking.GetRealAutoAttackRange(Player), temp, 5);
                }
                else
                {
                    Color temp = Color.Gold;

                    if (Player.HasBuff("goldcardpreattack", true))
                    {
                        temp = Color.Gold;
                    }
                    else if (Player.HasBuff("bluecardpreattack", true))
                    {
                        temp = Color.Blue;
                    }
                    else if (Player.HasBuff("redcardpreattack", true))
                    {
                        temp = Color.Red;
                    }
                    else
                    {
                        temp = Color.Gray;
                    }

                    Render.Circle.DrawCircle(Player.Position, Orbwalking.GetRealAutoAttackRange(Player), temp, 5);
                }
            }

            if (Menu.Item("FAAcircle").GetValue <bool>())
            {
                Obj_AI_Hero target = TargetSelector.GetTarget(Orbwalking.GetRealAutoAttackRange(Player) + 400, TargetSelector.DamageType.Magical, false);

                if (target != null && SFlash != SpellSlot.Unknown && Player.Spellbook.CanUseSpell(SFlash) == SpellState.Ready)
                {
                    Render.Circle.DrawCircle(Player.Position, Orbwalking.GetRealAutoAttackRange(Player) + 400, Color.Gold, 5);//AA+Flash Range

                    if (!target.IsValidTarget(Orbwalking.GetRealAutoAttackRange(Player)))
                    {
                        Render.Circle.DrawCircle(target.Position, target.BoundingRadius, Color.Gold);

                        var targetpos = Drawing.WorldToScreen(target.Position);

                        Drawing.DrawText(targetpos[0] - 70, targetpos[1] + 20, Color.Gold, "Flash+AA possible");
                    }
                }
                else
                {
                    Render.Circle.DrawCircle(Player.Position, Orbwalking.GetRealAutoAttackRange(Player) + 400, Color.Gray, 5);//AA+Flash Range
                }
            }

            var drawMinionLastHit  = Menu.Item("drawMinionLastHit").GetValue <Circle>();
            var drawMinionNearKill = Menu.Item("drawMinionNearKill").GetValue <Circle>();

            if (drawMinionLastHit.Active || drawMinionNearKill.Active)
            {
                var xMinions =
                    MinionManager.GetMinions(Player.Position, Player.AttackRange + Player.BoundingRadius + 300, MinionTypes.All, MinionTeam.Enemy, MinionOrderTypes.MaxHealth);

                foreach (var xMinion in xMinions)
                {
                    if (drawMinionLastHit.Active && Player.GetAutoAttackDamage(xMinion, true) >= xMinion.Health)
                    {
                        Render.Circle.DrawCircle(xMinion.Position, xMinion.BoundingRadius, drawMinionLastHit.Color, 5);
                    }
                    else if (drawMinionNearKill.Active && Player.GetAutoAttackDamage(xMinion, true) * 2 >= xMinion.Health)
                    {
                        Render.Circle.DrawCircle(xMinion.Position, xMinion.BoundingRadius, drawMinionNearKill.Color, 5);
                    }
                }
            }

            if (Game.MapId == (GameMapId)11 && Menu.Item("jgpos").GetValue <bool>())
            {
                const float circleRange = 100f;

                Render.Circle.DrawCircle(new Vector3(7461.018f, 3253.575f, 52.57141f), circleRange, Color.Blue, 5);   // blue team :red
                Render.Circle.DrawCircle(new Vector3(3511.601f, 8745.617f, 52.57141f), circleRange, Color.Blue, 5);   // blue team :blue
                Render.Circle.DrawCircle(new Vector3(7462.053f, 2489.813f, 52.57141f), circleRange, Color.Blue, 5);   // blue team :golems
                Render.Circle.DrawCircle(new Vector3(3144.897f, 7106.449f, 51.89026f), circleRange, Color.Blue, 5);   // blue team :wolfs
                Render.Circle.DrawCircle(new Vector3(7770.341f, 5061.238f, 49.26587f), circleRange, Color.Blue, 5);   // blue team :wariaths

                Render.Circle.DrawCircle(new Vector3(10930.93f, 5405.83f, -68.72192f), circleRange, Color.Yellow, 5); // Dragon

                Render.Circle.DrawCircle(new Vector3(7326.056f, 11643.01f, 50.21985f), circleRange, Color.Red, 5);    // red team :red
                Render.Circle.DrawCircle(new Vector3(11417.6f, 6216.028f, 51.00244f), circleRange, Color.Red, 5);     // red team :blue
                Render.Circle.DrawCircle(new Vector3(7368.408f, 12488.37f, 56.47668f), circleRange, Color.Red, 5);    // red team :golems
                Render.Circle.DrawCircle(new Vector3(10342.77f, 8896.083f, 51.72742f), circleRange, Color.Red, 5);    // red team :wolfs
                Render.Circle.DrawCircle(new Vector3(7001.741f, 9915.717f, 54.02466f), circleRange, Color.Red, 5);    // red team :wariaths
            }

            if (Menu.Item("manaper").GetValue <bool>())
            {
                var targetpos = Drawing.WorldToScreen(Player.Position);
                var color     = Color.Green;
                var manaper   = (int)Utility.ManaPercentage(Player);

                if (manaper > 75)
                {
                    color = Color.LightGreen;
                }
                else if (manaper > 45)
                {
                    color = Color.Yellow;
                }
                else if (manaper > 25)
                {
                    color = Color.OrangeRed;
                }
                else if (manaper > -1)
                {
                    color = Color.Red;
                }

                Drawing.DrawText(targetpos[0] - 40, targetpos[1] + 20, color, "Mana:" + manaper + "%");
            }

            if (Menu.Item("kill").GetValue <bool>())
            {
                foreach (Obj_AI_Hero target in ObjectManager.Get <Obj_AI_Hero>().Where(x => x != null && x.IsValid && !x.IsDead && x.IsEnemy && x.Health <= GetComboDamage(x) && x.IsVisible))
                {
                    var targetpos = Drawing.WorldToScreen(target.Position);
                    Render.Circle.DrawCircle(target.Position, target.BoundingRadius, Color.Tomato);
                    Drawing.DrawText(targetpos[0] - 30, targetpos[1] + 40, Color.Tomato, "Killable");
                }
            }
        }
Beispiel #33
0
        private void Combo(Obj_AI_Hero target, float cmbDmg, bool canKill, bool bush)
        {
            if (target == null || !target.IsValidTarget())
            {
                return;
            }
            if (config.Item("useItems").GetValue <bool>())
            {
                ItemHandler.UseItems(target, config, cmbDmg);
            }
            if (config.Item("usew", true).GetValue <bool>() && W.IsReady() && W.CanCast(target))
            {
                var tarPered = W.GetPrediction(target);
                if (justE && !Estun && ePos.IsValid() && target.Distance(ePos) < 375)
                {
                    if (W.Range - 80 > tarPered.CastPosition.Distance(player.Position) &&
                        tarPered.Hitchance >= HitChance.High)
                    {
                        W.Cast(target.Position);
                    }
                }
                else
                {
                    if (W.Range - 80 > tarPered.CastPosition.Distance(player.Position) &&
                        tarPered.Hitchance >= HitChance.VeryHigh && !config.Item("startWithE", true).GetValue <bool>())
                    {
                        W.Cast(tarPered.CastPosition);
                    }
                }
            }
            if (config.Item("usee", true).GetValue <bool>() && E.IsReady() &&
                (((canKill && config.Item("useekill", true).GetValue <bool>()) ||
                  (!config.Item("useekill", true).GetValue <bool>() && CheckMana())) ||
                 config.Item("startWithE", true).GetValue <bool>()))
            {
                switch (config.Item("eType", true).GetValue <StringList>().SelectedIndex)
                {
                case 0:
                    CastE(target);
                    return;

                case 1:
                    CastE(target, false);
                    return;

                    break;
                }
            }
            if (config.Item("usee", true).GetValue <bool>() && E.IsReady())
            {
                if (config.Item("useemin", true).GetValue <Slider>().Value > 1 &&
                    player.CountEnemiesInRange(E.Range + 175) >= config.Item("useemin", true).GetValue <Slider>().Value)
                {
                    switch (config.Item("eType", true).GetValue <StringList>().SelectedIndex)
                    {
                    case 0:
                        CastE(target, true, config.Item("useemin", true).GetValue <Slider>().Value);
                        return;
                    }
                }
            }
            if (config.Item("useq", true).GetValue <bool>() && Q.IsReady() && Q.CanCast(target) && target.IsValidTarget() &&
                !bush && !Estun)
            {
                CastQHero(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 > target.Health && hasIgnite && !player.IsChannelingImportantSpell() && !justQ &&
                  !Q.CanCast(target) && !justR && !R.CanCast(target) && CheckW(target)) || IgniteTarget != null))
            {
                if (IgniteTarget != null)
                {
                    player.Spellbook.CastSpell(player.GetSpellSlot("SummonerDot"), IgniteTarget);
                    return;
                }
                player.Spellbook.CastSpell(player.GetSpellSlot("SummonerDot"), target);
            }
            var castR = false;

            if (target.CountEnemiesInRange(2000) == 1)
            {
                castR = true;
            }
            else if (!config.Item("ult" + target.SkinName, true).GetValue <bool>())
            {
                castR = true;
            }
            if (R.IsReady() && R.CanCast(target) && CheckUltBlock(target) && config.Item("user", true).GetValue <bool>() &&
                castR && R.Instance.ManaCost < player.Mana &&
                !target.Buffs.Any(b => CombatHelper.invulnerable.Contains(b.Name)) &&
                !CombatHelper.CheckCriticalBuffs(target))
            {
                if (config.Item("userPred", true).GetValue <bool>())
                {
                    var Whit = wPos.IsValid() && System.Environment.TickCount - wTime > 700 &&
                               Prediction.GetPrediction(target, 0.55f).UnitPosition.Distance(wPos) < W.Width;
                    var targetHP = target.Health -
                                   Program.IncDamages.GetEnemyData(target.NetworkId).ProjectileDamageTaken;
                    var killWithIgnite = hasIgnite && config.Item("useIgnite", true).GetValue <bool>() &&
                                         R.GetDamage(target) + ignitedmg > targetHP && targetHP > R.GetDamage(target);

                    var killWithW = wPos != null && Whit && R.GetDamage(target) + W.GetDamage(target) > targetHP &&
                                    target.Health > R.GetDamage(target);

                    var killWithIgniteAndW = !killWithW && Whit && hasIgnite &&
                                             config.Item("useIgnite", true).GetValue <bool>() &&
                                             R.GetDamage(target) + W.GetDamage(target) + ignitedmg > targetHP &&
                                             targetHP > R.GetDamage(target) + W.GetDamage(target);

                    if (killWithW || (targetHP < R.GetDamage(target) && !justQ && CheckW(target)))
                    {
                        R.CastOnUnit(target);
                    }

                    if ((killWithIgnite || killWithIgniteAndW) && CheckW(target) && player.Distance(target) < 600)
                    {
                        R.CastOnUnit(target);
                        IgniteTarget = target;
                        Utility.DelayAction.Add(
                            200, () =>
                        {
                            IgniteTarget = null;
                            player.Spellbook.CastSpell(player.GetSpellSlot("SummonerDot"), target);
                        });
                    }
                }
                else
                {
                    if (target.Health < R.GetDamage(target))
                    {
                        R.CastOnUnit(target);
                    }
                }
            }
        }
Beispiel #34
0
        private ComboResult GetComboResult(Obj_AI_Hero target)
        {
            if (!target.IsValidTarget())
            {
                return(new ComboResult());
            }

            var player    = ObjectManager.Player;
            var result    = new ComboResult();
            var comboMana = 0f;
            var comboDmg  = 0d;

            foreach (var item in _items.Where(item => item.IsReady()))
            {
                switch (item.Id)
                {
                case 3128: comboDmg += player.GetItemDamage(target, Damage.DamageItems.Dfg); break;

                case 3077: comboDmg += player.GetItemDamage(target, Damage.DamageItems.Tiamat); break;

                case 3074: comboDmg += player.GetItemDamage(target, Damage.DamageItems.Hydra); break;

                case 3146: comboDmg += player.GetItemDamage(target, Damage.DamageItems.Hexgun); break;

                case 3144: comboDmg += player.GetItemDamage(target, Damage.DamageItems.Bilgewater); break;

                case 3153: comboDmg += player.GetItemDamage(target, Damage.DamageItems.Botrk); break;
                }

                if (comboDmg > target.Health)
                {
                    break;
                }
            }

            foreach (var spell in _spells.Where(spell => spell.Level > 0))
            {
                try
                {
                    comboDmg  += spell.GetDamage(target, 1);
                    comboMana += spell.Instance.ManaCost;
                    result.Spells.Add(spell.Slot);

                    if (comboDmg > target.Health)
                    {
                        break;
                    }
                }
                catch
                {
                }
            }

            if (_ignite != null && _ignite.State == SpellState.Ready && target.Health > comboDmg)
            {
                comboDmg += player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite);
            }

            result.IsKillable = comboDmg > target.Health && player.Mana > comboMana;
            result.ManaCost   = comboMana;

            if (result.IsKillable)
            {
                result.Text = string.Join("/", result.Spells);
            }

            if (player.Mana < comboMana)
            {
                result.Text = "LOW MANA";
            }

            return(result);
        }
Beispiel #35
0
        private void Game_OnGameUpdate(EventArgs args)
        {
            if (Config.Item("disableBlock", true).GetValue <KeyBind>().Active)
            {
                Orbwalking.Attack      = true;
                Orbwalking.Move        = true;
                OktwCommon.blockSpells = false;
                OktwCommon.blockAttack = false;
                OktwCommon.blockMove   = false;
                return;
            }
            else if (Player.IsChannelingImportantSpell() || Game.Time - RCastTime < 0.3)
            {
                if (Config.Item("forceBlockMove", true).GetValue <bool>())
                {
                    OktwCommon.blockMove   = true;
                    OktwCommon.blockAttack = true;
                    OktwCommon.blockSpells = true;
                }

                Orbwalking.Attack = false;
                Orbwalking.Move   = false;

                Program.debug("cast R");
                return;
            }
            else
            {
                Orbwalking.Attack = true;
                Orbwalking.Move   = true;
                if (Config.Item("forceBlockMove", true).GetValue <bool>())
                {
                    OktwCommon.blockAttack = false;
                    OktwCommon.blockMove   = false;
                    OktwCommon.blockSpells = false;
                }
                if (R.IsReady() && Config.Item("useR", true).GetValue <KeyBind>().Active)
                {
                    var t = TargetSelector.GetTarget(R.Range, TargetSelector.DamageType.Physical);
                    if (t.IsValidTarget(R.Range))
                    {
                        R.Cast(t, true, true);
                        RCastTime = Game.Time;
                        return;
                    }
                }
            }

            if (Config.Item("newTarget", true).GetValue <bool>())
            {
                var orbT = Orbwalker.GetTarget();

                Obj_AI_Hero t2 = null;

                if (orbT != null && orbT is Obj_AI_Hero)
                {
                    t2 = (Obj_AI_Hero)orbT;
                }

                if (t2.IsValidTarget() && t2.NetworkId == LastAttackId)
                {
                    var ta = ObjectManager.Get <Obj_AI_Hero>().Where(enemy =>
                                                                     enemy.IsValidTarget() && Orbwalking.InAutoAttackRange(enemy) &&
                                                                     (enemy.NetworkId != LastAttackId || enemy.Health < Player.GetAutoAttackDamage(enemy) * 2)).FirstOrDefault();

                    if (ta != null)
                    {
                        Orbwalker.ForceTarget(ta);
                    }
                }
            }

            if (Program.LagFree(1))
            {
                SetMana();
                Jungle();
            }

            if (Program.LagFree(2) && !Player.IsWindingUp && Q.IsReady() && Config.Item("autoQ", true).GetValue <bool>())
            {
                LogicQ();
            }

            if (Program.LagFree(3) && !Player.IsWindingUp && E.IsReady() && Config.Item("autoE", true).GetValue <bool>())
            {
                LogicE();
            }

            if (Program.LagFree(4) && !Player.IsWindingUp && R.IsReady() && Config.Item("autoR", true).GetValue <bool>())
            {
                LogicR();
            }
        }
Beispiel #36
0
        private static void Drawing_OnDraw(EventArgs args)
        {
            if (!Me.IsDead)
            {
                if (_config.Item("drawrange").GetValue <bool>())
                {
                    Render.Circle.DrawCircle(Me.Position, _w.Range, System.Drawing.Color.White, 3);
                }

                if (_config.Item("drawengage").GetValue <bool>())
                {
                    Render.Circle.DrawCircle(Me.Position, Me.AttackRange + _e.Range + 10, System.Drawing.Color.White, 3);
                }

                if (_maintarget.IsValidTarget(900) && _config.Item("drawtarg").GetValue <bool>())
                {
                    Render.Circle.DrawCircle(
                        _maintarget.Position, _maintarget.BoundingRadius - 50, System.Drawing.Color.Yellow, 6);
                }

                if (_config.Item("reckless").GetValue <KeyBind>().Active)
                {
                    var wts = Drawing.WorldToScreen(Me.Position);
                    Drawing.DrawText(wts[0] - 40, wts[1] + 30, System.Drawing.Color.Yellow, "鐩存帴寮€R");
                }
                else
                {
                    var wts = Drawing.WorldToScreen(Me.Position);
                    Drawing.DrawText(wts[0] - 25, wts[1] + 30, System.Drawing.Color.LawnGreen, "鍑绘潃鎵嶅紑R");
                }

                if (_config.Item("debugtrue").GetValue <bool>())
                {
                    Render.Circle.DrawCircle(Me.Position, _truerange, System.Drawing.Color.Yellow, 3);
                }

                if (_config.Item("drawpassive").GetValue <bool>())
                {
                    var wts = Drawing.WorldToScreen(Me.Position);
                    if (Me.Spellbook.CanUseSpell(SpellSlot.Q) == SpellState.NotLearned)
                    {
                        Drawing.DrawText(wts[0] - 48, wts[1] + 10, System.Drawing.Color.White, "Q: 鏈煡!");
                    }
                    else if (_qt <= 0)
                    {
                        Drawing.DrawText(wts[0] - 30, wts[1] + 10, System.Drawing.Color.White, "Q: 鍑嗗濂戒簡");
                    }
                    else
                    {
                        Drawing.DrawText(
                            wts[0] - 30, wts[1] + 10, System.Drawing.Color.White, "Q: " + _qt.ToString("0.0"));
                    }
                }
            }

            if (_config.Item("debugdmg").GetValue <bool>() && _maintarget.IsValidTarget(1000))
            {
                var wts = Drawing.WorldToScreen(_maintarget.Position);
                if (!_r.IsReady())
                {
                    Drawing.DrawText(wts[0] - 75, wts[1] + 40, System.Drawing.Color.Yellow,
                                     "杩炴嫑浼ゅ: " + (float)(_ra * 3 + _rq * 3 + _rw + Rrb4(_maintarget) + _ri + _ritems));
                }
                else
                {
                    Drawing.DrawText(wts[0] - 75, wts[1] + 40, System.Drawing.Color.Yellow,
                                     "杩炴嫑浼ゅ: " + (float)(_ua * 3 + _uq * 3 + _uw + Rrb4(_maintarget) + _ri + _ritems));
                }
            }

            if (_maintarget.IsValidTarget(1000) && _config.Item("drawkill").GetValue <bool>())
            {
                var wts = Drawing.WorldToScreen(_maintarget.Position);

                if ((float)(_ra + _rq * 2 + _rw + _ri + _ritems) > _maintarget.Health)
                {
                    Drawing.DrawText(wts[0] - 20, wts[1] + 20, System.Drawing.Color.LawnGreen, "鍙嚮鏉€!");
                }
                else if ((float)(_ra * 2 + _rq * 2 + _rw + _ritems) > _maintarget.Health)
                {
                    Drawing.DrawText(wts[0] - 40, wts[1] + 20, System.Drawing.Color.LawnGreen, "瀹规槗鍑绘潃!");
                }
                else if ((float)(_ra * 3 + _ra * 3 + _rw + _ri + Rrb4(_maintarget) + _ritems) > _maintarget.Health)
                {
                    Drawing.DrawText(wts[0] - 65, wts[1] + 20, System.Drawing.Color.LawnGreen, "鍏ㄩ儴杩炴嫑鍙嚮鏉€!");
                }
                else if ((float)(_ua * 3 + _uq * 3 + _uw + Rrb4(_maintarget) + _ri + _ritems) > _maintarget.Health)
                {
                    Drawing.DrawText(wts[0] - 70, wts[1] + 20, System.Drawing.Color.LawnGreen, "鍏ㄩ儴杩炴嫑闅惧嚮鏉€!");
                }
                else if ((float)(_ua * 3 + _uq * 3 + _uw + Rrb4(_maintarget) + _ri + _ritems) < _maintarget.Health)
                {
                    Drawing.DrawText(wts[0] - 40, wts[1] + 20, System.Drawing.Color.LawnGreen, "鍑绘潃涓嶄簡!");
                }
            }
        }
Beispiel #37
0
        private static void Game_OnGameUpdate(EventArgs args)
        {
            _maintarget = TargetSelector.GetTarget(1100, TargetSelector.DamageType.Physical);
            CheckDamage(_maintarget);
            Kappa();

            _orbwalker.SetAttack(_canattack);
            _orbwalker.SetMovement(_canmove);

            _astime    = 1 / (0.318 * Me.AttackSpeedMod);
            _truerange = Me.AttackRange + Me.Distance(Me.BBox.Minimum) + 1;

            _ulton    = Me.GetSpell(SpellSlot.R).Name != "RivenFengShuiEngine";
            _hashydra = Items.HasItem(3077) || Items.HasItem(3074);
            _canhydra = !_isattacking && (Items.CanUseItem(3077) || Items.CanUseItem(3074));

            _qt = (_qtRem - Game.Time > 0) ? (_qtRem - Game.Time) : 0;


            if (_maintarget.IsValidTarget(1000))
            {
                _movePos = _maintarget.ServerPosition +
                           Vector3.Normalize(Me.Position - _maintarget.ServerPosition) *
                           (Me.Distance(_maintarget.ServerPosition) + 51);
            }
            else
            {
                _movePos = Game.CursorPos;
            }

            if (_config.Item("fleemode").GetValue <KeyBind>().Active)
            {
                if (_candash && _e.IsReady())
                {
                    _e.Cast(Game.CursorPos);
                }

                if (!_e.IsReady() && Environment.TickCount - _lastcleave >= 300 && Environment.TickCount - _lastdash >= 200)
                {
                    _q.Cast(Game.CursorPos);
                }

                if (_canmove)
                {
                    Me.IssueOrder(GameObjectOrder.MoveTo, Game.CursorPos);
                }
            }

            foreach (var b in Me.Buffs)
            {
                if (b.Name == "RivenTriCleave")
                {
                    _cleavecount = b.Count;
                }

                if (b.Name == "rivenpassiveaaboost")
                {
                    _runiccount = b.Count;
                }
            }

            if (Me.HasBuff("RivenTriCleave", true) && Environment.TickCount - _lastcleave >= 3600)
            {
                if (_config.Item("keepq").GetValue <bool>() && !Me.IsRecalling())
                {
                    _q.Cast(Game.CursorPos);
                }
            }

            if (!Me.HasBuff("rivenpassiveaaboost", true))
            {
                Utility.DelayAction.Add(1000, () => _runiccount = 1);
            }

            if (!Me.HasBuff("RivenTriCleave", true))
            {
                Utility.DelayAction.Add(1000, () => _cleavecount = 0);
            }

            if (_config.Item("reckless").GetValue <KeyBind>().Active)
            {
                var wTarget = ObjectManager.Get <Obj_AI_Hero>()
                              .Where(huro => huro.IsValidTarget(_w.Range));

                if (wTarget.Count() >= _config.Item("autow").GetValue <Slider>().Value)
                {
                    if (_cankiburst && _w.IsReady())
                    {
                        _w.Cast();
                    }
                }
            }

            var obj = (_orbwalker.GetTarget() != null ? (Obj_AI_Base)_orbwalker.GetTarget() : _maintarget) ?? Me;

            var time = (int)(Me.AttackCastDelay * 1000) - 100 + Game.Ping / 2 +
                       1000 * (int)Me.Distance(obj.ServerPosition) / (int)Me.BasicAttack.MissileSpeed;

            if (_orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo)
            {
                NormalCombo(_maintarget);
            }

            if (_orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LaneClear)
            {
                LaneClear();
                JungleClear();
            }

            if (!_canwindslash && !_isattacking && _ulton && _r.IsReady())
            {
                _canwindslash = true;
            }

            if (!_candash && !(_iscleaving || _isattacking || _iskibursting) && _e.IsReady())
            {
                _candash = true;
            }

            if (!_cankiburst && !(_iscleaving || _isattacking || _isdashing) && _w.IsReady())
            {
                _cankiburst = true;
            }

            if (!_canmove && !(_isattacking || _iscleaving || _iskibursting || _isdashing) &&
                Environment.TickCount - _lastattack >= time)
            {
                _canmove = true;
            }

            if (!_canattack && !(_iscleaving || _isdashing || _iskibursting) &&
                Environment.TickCount - _lastattack >= time + 166)
            {
                _canattack = true;
            }

            var time2 = (int)((_astime * 100) - 10 - (Me.Level * 8 / 2) + Game.Ping / 2);

            if (_isattacking && Environment.TickCount - _lastattack >= time2)
            {
                _isattacking = false;
                _canmove     = true;

                if (_config.Item("usecomboq").GetValue <bool>())
                {
                    _cancleave = true;
                }
                if (_config.Item("usecomboe").GetValue <bool>())
                {
                    _candash = true;
                }
                if (_config.Item("usecombow").GetValue <bool>())
                {
                    _cankiburst = true;
                }
                if (_config.Item("usews").GetValue <bool>())
                {
                    _canwindslash = true;
                }
            }

            if (_iscleaving && Environment.TickCount - _lastcleave >= 273)
            {
                _iscleaving = false;
                _canmove    = true;
                _canattack  = true;
            }

            if (_iskibursting && Environment.TickCount - _lastkiburst >= 148)
            {
                _iskibursting = false;
                _canattack    = true;
                _canmove      = true;
            }

            if (_isdashing && Environment.TickCount - _lastdash >= 200)
            {
                _isdashing = false;
                _canmove   = true;
            }
        }
Beispiel #38
0
        public static void combo(bool useQ, bool useW, bool useE, bool useR)
        {
            var         focusSelected = menu.Item("selected").GetValue <bool>();
            Obj_AI_Hero Target        = SimpleTs.GetTarget(E.Range, SimpleTs.DamageType.Magical);

            int mode       = menu.Item("comboMode").GetValue <StringList>().SelectedIndex;
            int IgniteMode = menu.Item("igniteMode").GetValue <StringList>().SelectedIndex;

            int eDis = menu.Item("eDis").GetValue <Slider>().Value;

            if (SimpleTs.GetSelectedTarget() != null)
            {
                if (focusSelected && SimpleTs.GetSelectedTarget().Distance(Player.ServerPosition) < E.Range)
                {
                    Target = SimpleTs.GetSelectedTarget();
                }
            }

            if (!Target.HasBuffOfType(BuffType.Invulnerability) && Target.IsValidTarget(E.Range))
            {
                if (mode == 0) //qwe
                {
                    if (Target != null && DFG.IsReady() && E.IsReady() && menu.Item("dfg").GetValue <bool>())
                    {
                        DFG.Cast(Target);
                    }

                    if (useQ && Q.IsReady() && Player.Distance(Target) <= Q.Range && Target != null)
                    {
                        Q.Cast(Target, packets());
                    }

                    if (useE && Target != null && E.IsReady() && Player.Distance(Target) < E.Range &&
                        Player.Distance(Target) > eDis)
                    {
                        if (menu.Item("smartE").GetValue <bool>() &&
                            countEnemiesNearPosition(Target.ServerPosition, 500) > 2 &&
                            (!R.IsReady() || !(rSpell.State == SpellState.Surpressed && R.Level > 0)))
                        {
                            return;
                        }

                        E.Cast(Target, packets());
                    }
                }
                else if (mode == 1) //eqw
                {
                    if (Target != null && DFG.IsReady() && E.IsReady() && menu.Item("dfg").GetValue <bool>())
                    {
                        DFG.Cast(Target);
                    }

                    if (useE && Target != null && E.IsReady() && Player.Distance(Target) < E.Range &&
                        Player.Distance(Target) > eDis)
                    {
                        if (menu.Item("smartE").GetValue <bool>() &&
                            countEnemiesNearPosition(Target.ServerPosition, 500) > 2 &&
                            (!R.IsReady() || !(rSpell.State == SpellState.Surpressed && R.Level > 0)))
                        {
                            return;
                        }

                        E.Cast(Target, packets());
                    }

                    if (useQ && Q.IsReady() && Player.Distance(Target) <= Q.Range && Target != null)
                    {
                        Q.Cast(Target, packets());
                    }
                }

                //Ignite
                if (Target != null && menu.Item("ignite").GetValue <bool>() && IgniteSlot != SpellSlot.Unknown &&
                    Player.SummonerSpellbook.CanUseSpell(IgniteSlot) == SpellState.Ready)
                {
                    if (IgniteMode == 0 && GetComboDamage(Target) > Target.Health)
                    {
                        Player.SummonerSpellbook.CastSpell(IgniteSlot, Target);
                    }
                }

                if (useW && Target != null && W.IsReady() && Player.Distance(Target) <= W.Range)
                {
                    W.Cast();
                }

                if (useR && Target != null && R.IsReady() &&
                    countEnemiesNearPosition(Player.ServerPosition, R.Range) > 0)
                {
                    if (!Q.IsReady() && !E.IsReady() && !W.IsReady())
                    {
                        R.Cast();
                    }
                }
            }
        }
Beispiel #39
0
        private static void Combo()
        {
            var target = TargetSelector.GetTarget(spells[Spells.Q].Range, TargetSelector.DamageType.Physical);

            if (!target.IsValidTarget() || target == null)
            {
                return;
            }

            UseItems(target);

            if (target.HasQBuff() && ParamBool("ElLeeSin.Combo.Q2"))
            {
                if (castQAgain ||
                    target.HasBuffOfType(BuffType.Knockback) && !Player.IsValidTarget(300) &&
                    !spells[Spells.R].IsReady() || !target.IsValidTarget(Orbwalking.GetRealAutoAttackRange(Player)) ||
                    spells[Spells.Q].GetDamage(target, 1) > target.Health ||
                    ReturnQBuff().Distance(target) < Player.Distance(target) &&
                    !target.IsValidTarget(Orbwalking.GetRealAutoAttackRange(Player)))
                {
                    spells[Spells.Q].Cast(target);
                }
            }

            if (spells[Spells.R].GetDamage(target) >= target.Health && ParamBool("ElLeeSin.Combo.KS.R") &&
                target.IsValidTarget())
            {
                spells[Spells.R].Cast(target);
            }

            if (ParamBool("ElLeeSin.Combo.AAStacks") &&
                PassiveStacks > InitMenu.Menu.Item("ElLeeSin.Combo.PassiveStacks").GetValue <Slider>().Value &&
                Orbwalking.GetRealAutoAttackRange(Player) > Player.Distance(target))
            {
                return;
            }

            if (ParamBool("ElLeeSin.Combo.W"))
            {
                if (ParamBool("ElLeeSin.Combo.Mode.WW") &&
                    target.Distance(Player) > Orbwalking.GetRealAutoAttackRange(Player))
                {
                    WardJump(target.Position, false, true);
                }

                if (!ParamBool("ElLeeSin.Combo.Mode.WW") && target.Distance(Player) > spells[Spells.Q].Range)
                {
                    WardJump(target.Position, false, true);
                }
            }

            if (spells[Spells.E].IsReady() && ParamBool("ElLeeSin.Combo.E"))
            {
                if (EState && target.Distance(Player) < spells[Spells.E].Range)
                {
                    spells[Spells.E].Cast();
                    return;
                }

                if (!EState && target.Distance(Player) > Orbwalking.GetRealAutoAttackRange(Player) + 50)
                {
                    spells[Spells.E].Cast();
                }
            }

            if (spells[Spells.Q].IsReady() && spells[Spells.Q].Instance.Name == "BlindMonkQOne" &&
                ParamBool("ElLeeSin.Combo.Q"))
            {
                CastQ(target, ParamBool("qSmite"));
            }

            if (spells[Spells.R].IsReady() && spells[Spells.Q].IsReady() && target.HasQBuff() &&
                ParamBool("ElLeeSin.Combo.R"))
            {
                spells[Spells.R].CastOnUnit(target);
            }
        }
Beispiel #40
0
        private void Game_OnGameUpdate(EventArgs args)
        {
            orbwalker.SetMovement(true);
            if (player.HasBuff("KennenLightningRush"))
            {
                orbwalker.SetAttack(false);
            }
            else
            {
                orbwalker.SetAttack(true);
            }
            if (FpsBalancer.CheckCounter())
            {
                return;
            }
            Obj_AI_Hero target = getTarget();

            switch (orbwalker.ActiveMode)
            {
            case Orbwalking.OrbwalkingMode.Combo:
                Combo();
                break;

            case Orbwalking.OrbwalkingMode.Mixed:
                Harass();
                break;

            case Orbwalking.OrbwalkingMode.LaneClear:
                Clear();
                break;

            case Orbwalking.OrbwalkingMode.LastHit:
                LastHit();
                break;

            default:
                break;
            }
            if (target == null)
            {
                return;
            }
            var data = Program.IncDamages.GetAllyData(player.NetworkId);

            if (data != null && player.HasBuff("KennenShurikenStorm") &&
                (config.Item("Minhelath", true).GetValue <Slider>().Value > player.Health / player.MaxHealth * 100 ||
                 (data.IsAboutToDie && config.Item("Minhelath", true).GetValue <Slider>().Value > 0)))
            {
                if (Items.HasItem(ItemHandler.Wooglet.Id) && Items.CanUseItem(ItemHandler.Wooglet.Id))
                {
                    ItemHandler.Wooglet.Cast();
                }
                if (Items.HasItem(ItemHandler.Zhonya.Id) && Items.CanUseItem(ItemHandler.Zhonya.Id))
                {
                    ItemHandler.Zhonya.Cast();
                }
            }
            if (config.Item("autoq", true).GetValue <bool>())
            {
                if (Q.CanCast(target) && !target.IsDashing() &&
                    (MarkOfStorm(target) > 1 || (MarkOfStorm(target) > 0 && player.Distance(target) < W.Range)))
                {
                    Q.Cast(target);
                }
            }
            if (config.Item("autow", true).GetValue <bool>() && W.IsReady() && MarkOfStorm(target) > 1 &&
                !player.HasBuff("KennenShurikenStorm"))
            {
                if (player.Distance(target) < W.Range)
                {
                    W.Cast();
                }
            }
            if (config.Item("KenAutoQ", true).GetValue <KeyBind>().Active&& Q.IsReady() &&
                config.Item("KenminmanaaQ", true).GetValue <Slider>().Value < player.ManaPercent &&
                orbwalker.ActiveMode != Orbwalking.OrbwalkingMode.Combo && Orbwalking.CanMove(100) &&
                !player.UnderTurret(true))
            {
                if (target != null && Q.CanCast(target) && target.IsValidTarget())
                {
                    Q.CastIfHitchanceEquals(
                        target, CombatHelper.GetHitChance(config.Item("qHit", true).GetValue <Slider>().Value));
                }
            }
        }
        public bool CheckSingle(UltimateModeType mode, Obj_AI_Hero target)
        {
            try
            {
                if (_menu == null || target == null || !target.IsValidTarget())
                {
                    return(false);
                }

                if (ShouldSingle(mode))
                {
                    var minHealth = _menu.Item(_menu.Name + ".ultimate.single.min-health").GetValue <Slider>().Value;
                    if (Spells != null &&
                        !Spells.Any(
                            s =>
                            s.Slot != SpellSlot.R && s.IsReady() && s.IsInRange(target) &&
                            s.GetDamage(target, 1) > 10 && Math.Abs(s.Speed - float.MaxValue) < 1 ||
                            s.From.Distance(target.ServerPosition) / s.Speed + s.Delay <= 1.0f))
                    {
                        minHealth = 0;
                    }
                    if (target.HealthPercent < minHealth)
                    {
                        return(false);
                    }

                    var alliesRange = _menu.Item(_menu.Name + ".ultimate.single.range-allies").GetValue <Slider>().Value;
                    var alliesMax   = _menu.Item(_menu.Name + ".ultimate.single.max-add-allies").GetValue <Slider>().Value;

                    var enemiesRange = _menu.Item(_menu.Name + ".ultimate.single.range-allies").GetValue <Slider>().Value;
                    var enemiesMax   =
                        _menu.Item(_menu.Name + ".ultimate.single.max-add-enemies").GetValue <Slider>().Value;

                    var pos = ObjectManager.Player.Position.Extend(
                        target.Position, ObjectManager.Player.Distance(target) / 2f);
                    var aCount =
                        GameObjects.AllyHeroes.Count(
                            h => h.IsValid && !h.IsDead && !h.IsMe && h.Distance(pos) <= alliesRange);
                    var eCount =
                        GameObjects.EnemyHeroes.Count(
                            h =>
                            h.IsValid && !h.IsDead && h.IsVisible && h.NetworkId != target.NetworkId &&
                            h.Distance(pos) <= enemiesRange);

                    if (aCount > alliesMax || eCount > enemiesMax)
                    {
                        return(false);
                    }

                    if (DamageCalculation != null)
                    {
                        if (GetDamage(target, mode, 1) < target.Health)
                        {
                            return(false);
                        }
                    }

                    return(true);
                }
            }
            catch (Exception ex)
            {
                Global.Logger.AddItem(new LogItem(ex));
            }
            return(false);
        }
Beispiel #42
0
 /// <summary>
 /// Called when a possible interrupt is registered.
 /// </summary>
 /// <param name="sender">The Interruptable target</param>
 /// <param name="args">The interrupt data</param>
 internal static void Interrupter2_OnInterruptableTarget(Obj_AI_Hero sender, Interrupter2.InterruptableTargetEventArgs args)
 {
     if (menu.Item("dz191." + MenuName + ".settings.e.interrupter").GetValue <bool>() && Spells[SpellSlot.E].IsReady() && sender.IsValidTarget(Spells[SpellSlot.E].Range) && args.DangerLevel >= Interrupter2.DangerLevel.High)
     {
         Spells[SpellSlot.E].Cast(sender);
     }
 }
Beispiel #43
0
        private void Combo()
        {
            Obj_AI_Hero target = DrawHelper.GetBetterTarget(700, TargetSelector.DamageType.Physical);

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

            if (config.Item("useItems").GetValue <bool>() && !GarenQ)
            {
                ItemHandler.UseItems(target, config, combodamage);
            }
            bool hasIgnite = player.Spellbook.CanUseSpell(player.GetSpellSlot("SummonerDot")) == SpellState.Ready;
            var  ignitedmg = (float)player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite);

            if (config.Item("useIgnite").GetValue <bool>() && hasIgnite &&
                ((R.IsReady() && ignitedmg + R.GetDamage(target) > target.Health) || ignitedmg > target.Health) &&
                (target.Distance(player) > E.Range || player.HealthPercent < 20))
            {
                player.Spellbook.CastSpell(player.GetSpellSlot("SummonerDot"), target);
            }
            if (config.Item("useq", true).GetValue <bool>() && Q.IsReady() &&
                player.Distance(target) > player.AttackRange && !GarenE && !GarenQ &&
                player.Distance(target) > Orbwalking.GetRealAutoAttackRange(target) &&
                CombatHelper.IsPossibleToReachHim(target, 0.30f, new float[5] {
                1.5f, 2f, 2.5f, 3f, 3.5f
            }[Q.Level - 1]))
            {
                Q.Cast();
            }
            if (config.Item("useq", true).GetValue <bool>() && Q.IsReady() && !GarenQ &&
                (!GarenE || (Q.IsReady() && Damage.GetSpellDamage(player, target, SpellSlot.Q) > target.Health)))
            {
                if (GarenE)
                {
                    E.Cast();
                }
                Q.Cast();
                player.IssueOrder(GameObjectOrder.AutoAttack, target);
            }
            if (config.Item("usee", true).GetValue <bool>() && E.IsReady() && !Q.IsReady() && !GarenQ && !GarenE &&
                !Orbwalking.CanAttack() && !player.IsWindingUp && player.CountEnemiesInRange(E.Range) > 0)
            {
                E.Cast();
            }
            var targHP = target.Health + 20 - CombatHelper.IgniteDamage(target);
            var rLogic = config.Item("user", true).GetValue <bool>() && R.IsReady() && target.IsValidTarget() &&
                         (!config.Item("ult" + target.SkinName, true).GetValue <bool>() ||
                          player.CountEnemiesInRange(1500) == 1) && getRDamage(target) > targHP && targHP > 0;

            if (rLogic && target.Distance(player) < R.Range)
            {
                if (!(GarenE && target.Health < getEDamage(target, true) && target.Distance(player) < E.Range))
                {
                    if (GarenE)
                    {
                        E.Cast();
                    }
                    else
                    {
                        R.Cast(target);
                    }
                }
            }
            var data = Program.IncDamages.GetAllyData(player.NetworkId);

            if (config.Item("usew", true).GetValue <bool>() && W.IsReady() && target.IsFacing(player) &&
                data.DamageTaken > 40)
            {
                W.Cast();
            }
            bool hasFlash = player.Spellbook.CanUseSpell(player.GetSpellSlot("SummonerFlash")) == SpellState.Ready;

            if (config.Item("useFlash", true).GetValue <bool>() && hasFlash && rLogic &&
                target.Distance(player) < R.Range + 425 && target.Distance(player) > R.Range + 250 && !Q.IsReady() &&
                !CombatHelper.IsFacing(target, player.Position) && !GarenQ)
            {
                if (target.Distance(player) < R.Range + 300 && player.MoveSpeed > target.MoveSpeed)
                {
                    return;
                }
                if (GarenE)
                {
                    E.Cast();
                }
                else if (!player.Position.Extend(target.Position, 425f).IsWall())
                {
                }
                {
                    player.Spellbook.CastSpell(
                        player.GetSpellSlot("SummonerFlash"), player.Position.Extend(target.Position, 425f));
                }
            }
        }
Beispiel #44
0
        private void Combo()
        {
            Obj_AI_Hero target  = getTarget();
            Obj_AI_Hero Rtarget = TargetSelector.GetTarget(2000, TargetSelector.DamageType.Magical);

            if (target == null)
            {
                return;
            }
            if (config.Item("selected").GetValue <bool>())
            {
                target = CombatHelper.SetTarget(target, TargetSelector.GetSelectedTarget());
                orbwalker.ForceTarget(target);
            }
            var cmbDmg = GetComboDamage(target);

            if (config.Item("useItems").GetValue <bool>())
            {
                ItemHandler.UseItems(target, config, cmbDmg);
            }
            if (config.Item("useq", true).GetValue <bool>() && Q.IsReady() && Orbwalking.CanMove(100) &&
                target.IsValidTarget() && !justJumped)
            {
                var targQ = Q.GetPrediction(target);
                if (Q.Range - 100 > targQ.CastPosition.Distance(player.Position) && targQ.Hitchance >= HitChance.High)
                {
                    Q.Cast(targQ.CastPosition, config.Item("packets").GetValue <bool>());
                    return;
                }
            }
            if (config.Item("usew", true).GetValue <bool>() && W.IsReady() && Orbwalking.CanMove(100) && !justJumped &&
                (cmbDmg + player.GetAutoAttackDamage(target) > target.Health || player.Mana > Q.Instance.ManaCost * 2))
            {
                var tarPered = W.GetPrediction(target);
                if (W.Range - 80 > tarPered.CastPosition.Distance(player.Position))
                {
                    W.CastIfHitchanceEquals(target, HitChance.High, config.Item("packets").GetValue <bool>());
                    return;
                }
            }
            if (R.IsReady() && !justJumped)
            {
                var dist = player.Distance(Rtarget);
                if (config.Item("user", true).GetValue <bool>() && !justQ && !Q.CanCast(target) && !justW &&
                    !W.CanCast(target) && !CombatHelper.CheckCriticalBuffs(Rtarget) &&
                    config.Item("usermin", true).GetValue <Slider>().Value < dist && 3000 > dist &&
                    Rtarget.Health < R.GetDamage(Rtarget) * 0.7 && target.CountAlliesInRange(600) < 1)
                {
                    R.CastIfHitchanceEquals(target, HitChance.High, config.Item("packets").GetValue <bool>());
                }
                if (target.CountAlliesInRange(700) > 0)
                {
                    R.CastIfWillHit(
                        target, config.Item("usertf", true).GetValue <Slider>().Value,
                        config.Item("packets").GetValue <bool>());
                }
            }
            bool canKill = cmbDmg > target.Health;

            if (config.Item("usee", true).GetValue <bool>() && E.IsReady() &&
                ((config.Item("useekill", true).GetValue <bool>() && canKill) ||
                 (!config.Item("useekill", true).GetValue <bool>() &&
                  (target.CountEnemiesInRange(1200) <= target.CountAlliesInRange(1200) && player.Health > target.Health &&
                   TargetSelector.GetPriority(target) >= 2f) || canKill)))
            {
                var bestPositons =
                    (from pos in
                     CombatHelper.PointsAroundTheTarget(target.Position, 750)
                     .Where(
                         p =>
                         !p.IsWall() && p.IsValid() && p.Distance(player.Position) < E.Range &&
                         p.Distance(target.Position) < 680 && !p.UnderTurret(true))
                     let mob =
                         ObjectManager.Get <Obj_AI_Base>()
                         .Where(
                             m =>
                             m.IsEnemy && m.IsValidTarget() && m.Distance(target.Position) < 750 &&
                             m.SkinName != target.SkinName)
                         .OrderBy(m => m.Distance(pos))
                         .FirstOrDefault()
                         where (mob != null && mob.Distance(pos) > pos.Distance(target.Position) + 80) || (mob == null)
                         select pos).ToList();

                CastE(bestPositons, 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 > target.Health && hasIgnite &&
                !player.IsChannelingImportantSpell() && !justQ && !Q.CanCast(target) && !justW && !W.CanCast(target) &&
                !justJumped)
            {
                player.Spellbook.CastSpell(player.GetSpellSlot("SummonerDot"), target);
            }
        }
Beispiel #45
0
        static void Interrupter2_OnInterruptableTarget(Obj_AI_Hero sender, Interrupter2.InterruptableTargetEventArgs args)
        {
            var packetCast              = Config.Item("PacketCast").GetValue <bool>();
            var RInterrupetSpell        = Config.Item("RInterrupetSpell").GetValue <bool>();
            var RAntiGapcloserMinHealth = Config.Item("RAntiGapcloserMinHealth").GetValue <Slider>().Value;

            if (RInterrupetSpell && Player.GetHealthPerc() < RAntiGapcloserMinHealth && sender.IsValidTarget(R.Range) && args.DangerLevel >= Interrupter2.DangerLevel.High)
            {
                if (R.CastIfHitchanceEquals(sender, sender.IsMoving ? HitChance.High : HitChance.Medium))
                {
                    Game.PrintChat(string.Format("OnPosibleToInterrupt -> RInterrupetSpell on {0} !", sender.SkinName));
                }
            }
        }
Beispiel #46
0
//-------------------======================================================================================-----------------
        private static void RapeTime()
        {
            Obj_AI_Hero possibleVictim = SimpleTs.GetTarget(R.Range * 2 + Orbwalking.GetRealAutoAttackRange(player), SimpleTs.DamageType.Magical);

            try
            {
                if (rektmate.IsDead || Game.Time - assignTime > 1.5)
                {
                    //Console.WriteLine("Unassign - " + rektmate.ChampionName + " dead: " + rektmate.IsDead + "\n\n");
                    gotPath  = false;
                    rektmate = default(Obj_AI_Hero);
                }
            }catch (Exception ex) {}
            try
            {
                if (rektmate == default(Obj_AI_Hero) && IsRapeble(possibleVictim) > possibleVictim.Health)
                {
                    rektmate   = possibleVictim;
                    assignTime = Game.Time;
                    gotPath    = gapclosePath(possibleVictim);
                    //Console.WriteLine("Assign - " + rektmate.ChampionName + " time: " + assignTime+"\n\n");
                }
            }catch (Exception ex) {}
            if (rektmate != default(Obj_AI_Hero))
            {
                //!(menu.SubMenu("misc").Item("TowerDive").GetValue<Slider>().Value < player.Health/player.MaxHealth && Utility.UnderTurret(rektmate, true)) &&
                if (player.Distance(rektmate) < R.Range * 2 + Orbwalking.GetRealAutoAttackRange(player) && player.Distance(rektmate) > Q.Range)
                {
                    if (gotPath)
                    {
                        float AARange = Orbwalking.GetRealAutoAttackRange(player) + 50;
                        if (second_unit.unit != rektmate && first_unit.unit != player)
                        {
                            if (Vector3.Distance(first_unit.Position, player.Position) > AARange &&
                                Vector3.Distance(second_unit.Position, player.Position) > AARange &&
                                rektmate.Distance(player) > AARange)
                            {
                                R.Cast(first_unit.unit);
                            }
                            else if (Vector3.Distance(second_unit.Position, player.Position) > AARange &&
                                     rektmate.Distance(player) > AARange)
                            {
                                R.Cast(second_unit.unit);
                            }
                            else if (rektmate.Distance(player) > AARange)
                            {
                                R.Cast(rektmate);
                            }
                        }
                        else if (first_unit.unit != player)
                        {
                            if (Vector3.Distance(first_unit.Position, player.Position) > AARange &&
                                rektmate.Distance(player) > AARange)
                            {
                                R.Cast(first_unit.unit);
                            }
                            else if (rektmate.Distance(player) > AARange)
                            {
                                R.Cast(rektmate);
                            }
                        }
                        else if (rektmate.Distance(player) > AARange)
                        {
                            R.Cast(rektmate);
                        }
                    }
                    else if (player.Distance(rektmate) < Q.Range)
                    {
                        RaperinoCasterino(rektmate);
                    }
                    else
                    {
                        rektmate = default(Obj_AI_Hero); //Target is out of range. Unassign.
                    }
                }
            }
            else
            {
                orbwalker.SetAttacks(!Q.IsReady() && !E.IsReady());
                if (menu.SubMenu("combo").Item("useQ").GetValue <bool>())
                {
                    castQ(true);
                }
                if (menu.SubMenu("combo").Item("useE").GetValue <bool>())
                {
                    castE(true);
                }
                if (menu.SubMenu("combo").Item("useR").GetValue <bool>())
                {
                    Obj_AI_Hero target = SimpleTs.GetTarget(R.Range, SimpleTs.DamageType.Magical);
                    if ((target.IsValidTarget(R.Range) && target.Distance(player) > Orbwalking.GetRealAutoAttackRange(player)) || R.IsKillable(target))
                    {
                        R.Cast(target);
                    }
                }
            }
        }
Beispiel #47
0
        internal static bool IsKillableAndValidTarget(this Obj_AI_Hero target, double calculatedDamage,
                                                      TargetSelector.DamageType damageType, float distance = float.MaxValue)
        {
            if (target == null || !target.IsValidTarget(distance) || target.CharData.BaseSkinName == "gangplankbarrel")
            {
                return(false);
            }

            if (target.HasBuff("kindredrnodeathbuff"))
            {
                return(false);
            }

            // Tryndamere's Undying Rage (R)
            if (target.HasBuff("Undying Rage"))
            {
                return(false);
            }

            // Kayle's Intervention (R)
            if (target.HasBuff("JudicatorIntervention"))
            {
                return(false);
            }

            // Poppy's Diplomatic Immunity (R)
            if (target.HasBuff("DiplomaticImmunity") && !ObjectManager.Player.HasBuff("poppyulttargetmark"))
            {
                //TODO: Get the actual target mark buff name
                return(false);
            }

            // Banshee's Veil (PASSIVE)
            if (target.HasBuff("BansheesVeil"))
            {
                // TODO: Get exact Banshee's Veil buff name.
                return(false);
            }

            // Sivir's Spell Shield (E)
            if (target.HasBuff("SivirShield"))
            {
                // TODO: Get exact Sivir's Spell Shield buff name
                return(false);
            }

            // Nocturne's Shroud of Darkness (W)
            if (target.HasBuff("ShroudofDarkness"))
            {
                // TODO: Get exact Nocturne's Shourd of Darkness buff name
                return(false);
            }

            if (ObjectManager.Player.HasBuff("summonerexhaust"))
            {
                calculatedDamage *= 0.6;
            }

            if (target.ChampionName == "Blitzcrank")
            {
                if (!target.HasBuff("manabarriercooldown"))
                {
                    if (target.Health + target.HPRegenRate +
                        (damageType == TargetSelector.DamageType.Physical ? target.PhysicalShield : target.MagicalShield) +
                        target.Mana * 0.6 + target.PARRegenRate < calculatedDamage)
                    {
                        return(true);
                    }
                }
            }

            if (target.ChampionName == "Garen")
            {
                if (target.HasBuff("GarenW"))
                {
                    calculatedDamage *= 0.7;
                }
            }

            if (target.HasBuff("FerociousHowl"))
            {
                calculatedDamage *= 0.3;
            }

            return(target.Health + target.HPRegenRate +
                   (damageType == TargetSelector.DamageType.Physical ? target.PhysicalShield : target.MagicalShield) <
                   calculatedDamage - 2);
        }
Beispiel #48
0
 private void Interrupter2_OnInterruptableTarget(
     Obj_AI_Hero unit,
     Interrupter2.InterruptableTargetEventArgs args)
 {
     if (R.IsReady() && Config.Item("RInterruptable" + Id).GetValue <bool>() && unit.IsValidTarget(1500))
     {
         R.Cast(unit);
     }
 }
Beispiel #49
0
        static void Combo()
        {
            Obj_AI_Hero target = TargetSelector.GetTarget(Q.Range, TargetSelector.DamageType.Magical, Menu.Item("ignoreshield").GetValue <bool>());

            if (Dfg.IsReady() && Menu.Item("usedfg").GetValue <bool>())
            {
                if (target.IsValidTarget(Dfg.Range))
                {
                    Dfg.Cast(target);
                }
            }

            if (Bft.IsReady() && Menu.Item("usebft").GetValue <bool>())
            {
                if (target.IsValidTarget(Bft.Range))
                {
                    Bft.Cast(target);
                }
            }

            if (W.IsReady() && Menu.Item("useW").GetValue <bool>())
            {
                if (target.IsValidTarget(W.Range))
                {
                    if (Menu.Item("useblue").GetValue <bool>())
                    {
                        if (Utility.ManaPercentage(Player) < 20)
                        {
                            CardSelector.StartSelecting(Cards.Blue);
                        }
                        else
                        {
                            CardSelector.StartSelecting(Cards.Yellow);
                        }
                    }
                    else
                    {
                        CardSelector.StartSelecting(Cards.Yellow);
                    }
                }
            }

            if (Q.IsReady() && Menu.Item("useQ").GetValue <bool>())
            {
                if (target.IsValidTarget(Menu.Item("qrange").GetValue <Slider>().Value))
                {
                    var pred = Q.GetPrediction(target);

                    if (Menu.Item("cconly").GetValue <bool>())
                    {
                        if (pred.Hitchance >= HitChance.High && DetectCollision(target))
                        {
                            foreach (var buff in target.Buffs)
                            {
                                if (buff.Type == BuffType.Stun || buff.Type == BuffType.Taunt || buff.Type == BuffType.Snare || buff.Type == BuffType.Suppression || buff.Type == BuffType.Charm || buff.Type == BuffType.Fear || buff.Type == BuffType.Flee || buff.Type == BuffType.Slow)
                                {
                                    Q.Cast(target, Menu.Item("usepacket").GetValue <bool>());
                                }
                            }
                        }
                    }
                    else if (pred.Hitchance >= HitChance.VeryHigh && DetectCollision(target))
                    {
                        Q.Cast(target, Menu.Item("usepacket").GetValue <bool>());
                    }
                }
            }
        }
Beispiel #50
0
        private void Combo()
        {
            Obj_AI_Hero target = TargetSelector.GetTarget(1100, TargetSelector.DamageType.Physical, 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 > target.Health && hasIgnite &&
                !CombatHelper.CheckCriticalBuffs(target) &&
                ((target.Distance(player) > Orbwalking.GetRealAutoAttackRange(target) &&
                  (!Q.IsReady() || Q.ManaCost < player.Mana)) || player.HealthPercent < 35))
            {
                player.Spellbook.CastSpell(player.GetSpellSlot("SummonerDot"), target);
            }
            if (Q.CanCast(target))
            {
                if (config.Item("useqLimit", true).GetValue <bool>())
                {
                    if (player.CountEnemiesInRange(Q.Range) == 1 && config.Item("useq", true).GetValue <bool>() &&
                        (target.Distance(player) > Orbwalking.GetRealAutoAttackRange(target) ||
                         (Q.GetDamage(target) > target.Health) &&
                         (player.HealthPercent < 50 || player.CountAlliesInRange(900) > 0)))
                    {
                        if (Q.CastOnUnit(target, config.Item("packets").GetValue <bool>()))
                        {
                            HandleECombo();
                        }
                    }
                    if ((player.CountEnemiesInRange(Q.Range) > 1 && config.Item("useqSec", true).GetValue <bool>() &&
                         Q.GetDamage(target) > target.Health) || player.HealthPercent < 35f ||
                        target.Distance(player) > Orbwalking.GetRealAutoAttackRange(target))
                    {
                        if (Q.CastOnUnit(target, config.Item("packets").GetValue <bool>()))
                        {
                            HandleECombo();
                        }
                    }
                }
                else
                {
                    if (Q.CastOnUnit(target, config.Item("packets").GetValue <bool>()))
                    {
                        HandleECombo();
                    }
                }
            }
            if (R.IsReady() && config.Item("user", true).GetValue <bool>())
            {
                if (player.CountEnemiesInRange(Q.Range) >= config.Item("userMin", true).GetValue <Slider>().Value&&
                    Program.IncDamages.GetAllyData(player.NetworkId).DamageTaken > 40)
                {
                    R.Cast();
                }
                if (config.Item("userDmg", true).GetValue <bool>() &&
                    Program.IncDamages.GetAllyData(player.NetworkId).DamageTaken >= player.Health * 0.3f &&
                    player.Distance(target) < 450f)
                {
                    R.Cast();
                }
            }
            if (config.Item("useeAA", true).GetValue <bool>() && !Eactive &&
                Program.IncDamages.GetAllyData(player.NetworkId).AADamageTaken > target.GetAutoAttackDamage(player) - 10)
            {
                E.Cast();
            }
            if (Eactive)
            {
                if (E.IsReady() && target.IsValidTarget() && !target.MagicImmune &&
                    ((Prediction.GetPrediction(target, 0.1f).UnitPosition.Distance(player.Position) >
                      Orbwalking.GetRealAutoAttackRange(target) && target.Distance(player.Position) <= E.Range) ||
                     config.Item("useeStun", true).GetValue <bool>()))
                {
                    E.Cast();
                }
            }
            else
            {
                if (config.Item("useeStun", true).GetValue <bool>() &&
                    Prediction.GetPrediction(target, 0.1f).UnitPosition.Distance(player.Position) <
                    Orbwalking.GetRealAutoAttackRange(target) && target.Distance(player.Position) <= E.Range)
                {
                    E.Cast();
                }
            }
        }
Beispiel #51
0
        public static void Harass(Obj_AI_Hero targetHero, bool useW = true)
        {
            if (!targetHero.IsValidTarget())
            {
                _harassStage = HarassStage.Nothing;
                return;
            }
            switch (_harassStage)
            {
            case HarassStage.Nothing:
                _harassStage = HarassStage.Started;
                break;

            case HarassStage.Started:
                _harassStage = HarassStage.Doing;
                if (E.IsReady() &&
                    Vector3.DistanceSquared(Player.ServerPosition, targetHero.ServerPosition) <= 350 * 350 &&
                    LeeUtility.MenuParamBool("UseE1H"))
                {
                    E.Cast();
                    if (LeeUtility.MenuParamBool("UseE2H"))
                    {
                        Utility.DelayAction.Add(
                            250 - Game.Ping / 2 + 10, () =>
                        {
                            E.Cast(Player, true);
                            _harassStage = LeeUtility.MenuParamBool("UseQ1H") && Q.IsReady()
                                        ? HarassStage.Doing
                                        : HarassStage.Finished;
                        });
                    }
                }
                else
                {
                    _harassStage = HarassStage.Finished;
                }
                if (Q.IsReady() && LeeUtility.MenuParamBool("UseQ1H"))
                {
                    //LeeUtility.CastQ(targetHero, QMode.Harass);
                    if (LeeUtility.CastQ(targetHero, QMode.Harass) && LeeUtility.MenuParamBool("UseQ2H"))
                    {
                        var delay = (int)(targetHero.Distance(Player) / Q.Speed * 1000) + 300 + Game.Ping;
                        Utility.DelayAction.Add(
                            delay, () =>
                        {
                            Q.Cast(targetHero);
                            _harassInitialVector3 = Player.ServerPosition;
                        });
                        Utility.DelayAction.Add(delay * 2, () => _harassStage = HarassStage.Finished);
                    }
                    else
                    {
                        _harassStage = HarassStage.Finished;
                    }
                }
                else
                {
                    _harassStage = HarassStage.Finished;
                }
                break;

            case HarassStage.Doing:
                break;

            case HarassStage.Finished:
                if (LeeUtility.MenuParamBool("UseWH") && useW)
                {
                    LeeUtility.WardJump(_harassInitialVector3, LeeUtility.MenuParamBool("UseWardWH"));
                }
                _harassStage = HarassStage.Nothing;
                break;
            }
        }
Beispiel #52
0
        static void RapeTime()
        {
            Obj_AI_Hero possibleVictim = SimpleTs.GetTarget(R.Range * 2 + Orbwalking.GetRealAutoAttackRange(player), SimpleTs.DamageType.Magical);

            try
            {
                if (rektmate.IsDead || Game.Time - assignTime > 1.5)
                {
                    //Console.WriteLine("Unassign - " + rektmate.ChampionName + " dead: " + rektmate.IsDead + "\n\n");
                    rektmate = default(Obj_AI_Hero);
                }
            }
            catch (Exception ex) { }
            try
            {
                if (rektmate == default(Obj_AI_Hero) && IsRapeble(possibleVictim) > possibleVictim.Health)
                {
                    rektmate   = possibleVictim;
                    assignTime = Game.Time;
                    //Console.WriteLine("Assign - " + rektmate.ChampionName + " time: " + assignTime+"\n\n");
                }
            }
            catch (Exception ex) { }
            if (rektmate != default(Obj_AI_Hero))
            {
                //!(menu.SubMenu("misc").Item("TowerDive").GetValue<Slider>().Value < player.Health/player.MaxHealth && Utility.UnderTurret(rektmate, true)) &&
                if (player.Distance(rektmate) < R.Range * 2 + Orbwalking.GetRealAutoAttackRange(player) && player.Distance(rektmate) > Q.Range)
                {
                    CastR(rektmate.Position);
                }
                else if (player.Distance(rektmate) < Q.Range)
                {
                    RaperinoCasterino(rektmate);
                }
                else
                {
                    rektmate = default(Obj_AI_Hero); //Target is out of range. Unassign.
                }
            }
            else
            {
                LXOrbwalker.SetAttack(!Q.IsReady() && !E.IsReady());
                if (menu.SubMenu("combo").Item("useQ").GetValue <bool>())
                {
                    CastQ(true);
                }
                if (menu.SubMenu("combo").Item("useE").GetValue <bool>())
                {
                    CastE(true);
                }
                if (menu.SubMenu("combo").Item("useW").GetValue <bool>())
                {
                    CastW();
                }
                if (menu.SubMenu("combo").Item("useR").GetValue <bool>())
                {
                    Obj_AI_Hero target = SimpleTs.GetTarget(R.Range, SimpleTs.DamageType.Magical);
                    if ((target.IsValidTarget(R.Range) && target.Distance(player) > Orbwalking.GetRealAutoAttackRange(player)) || R.IsKillable(target))
                    {
                        R.Cast(target, packetCast);
                    }
                }
            }
        }
Beispiel #53
0
        private static void DrawingOnOnDraw(EventArgs args)
        {
            if (ObjectManager.Player.IsDead)
            {
                return;
            }

            if (MenuLocal.Item("Jump.Draw.Status").GetValue <bool>())
            {
                var enabled = MenuLocal.Item("Jump.Enabled").GetValue <KeyBind>().Active;
                var stat    = MenuLocal.Item("Jump.Mode").GetValue <StringList>().SelectedValue;
                CommonHelper.DrawText(CommonHelper.TextStatus, "Q Jump: " + stat, (int)ObjectManager.Player.HPBarPosition.X + 145, (int)ObjectManager.Player.HPBarPosition.Y + 5, enabled && stat != "Off" ? Color.White : Color.Gray);
            }

            if (!MenuLocal.Item("Jump.Draw.Arrows").GetValue <bool>())
            {
                return;
            }
            if (JumpTarget.IsValidTarget(Q.Range))
            {
                return;
            }

            if (JumpTarget.IsValidTarget() && ObjectManager.Player.Distance(JumpTarget) > Q.Range)
            {
                var toPolygon = new Common.CommonGeometry.Rectangle(ObjectManager.Player.Position.To2D(), ObjectManager.Player.Position.To2D().Extend(JumpTarget.Position.To2D(), Q.Range * 3), 250).ToPolygon();
                toPolygon.Draw(System.Drawing.Color.Red, 1);
                var otherEnemyObjects =
                    ObjectManager.Get <Obj_AI_Base>()
                    .Where(m => m.IsEnemy && !m.IsDead && !m.IsZombie && m.IsValidTarget(Q.Range) && m.NetworkId != JumpTarget.NetworkId)
                    .Where(m => toPolygon.IsInside(m))
                    .Where(m => ObjectManager.Player.Distance(JumpTarget) > ObjectManager.Player.Distance(m))
                    .Where(m => m.Health < Q.GetDamage(m))
                    .Where(m => !m.IsValidTarget(Orbwalking.GetRealAutoAttackRange(null) + 165))
                    .OrderBy(m => m.Distance(JumpTarget.Position));

                JumpObject = otherEnemyObjects.FirstOrDefault(m => m.Distance(JumpTarget.Position) <= Q.Range * 2 && m.Distance(JumpTarget.Position) > Orbwalking.GetRealAutoAttackRange(null));

                if (JumpObject != null)
                {
                    if (JumpObject.IsValidTarget(Q.Range))// && JumpTarget.Health <= ComboDamage(t, R.Instance.Ammo - 1 < 0 ? 0: R.Instance.Ammo - 1) && Utils.UltiChargeCount >= 2)
                    {
                        var startpos = ObjectManager.Player.Position;
                        var endpos   = JumpObject.Position;
                        var endpos1  = JumpObject.Position + (startpos - endpos).To2D().Normalized().Rotated(30 * (float)Math.PI / 180).To3D() * ObjectManager.Player.BoundingRadius * 2;
                        var endpos2  = JumpObject.Position + (startpos - endpos).To2D().Normalized().Rotated(-30 * (float)Math.PI / 180).To3D() * ObjectManager.Player.BoundingRadius * 2;

                        var width = 1;

                        var x = new Geometry.Polygon.Line(startpos, endpos); x.Draw(System.Drawing.Color.Blue, width);
                        var y = new Geometry.Polygon.Line(endpos, endpos1); y.Draw(System.Drawing.Color.Blue, width + 1);
                        var z = new Geometry.Polygon.Line(endpos, endpos2); z.Draw(System.Drawing.Color.Blue, width + 1);

                        Vector3[] objectCenter = new[] { ObjectManager.Player.Position, JumpObject.Position };
                        var       aX           = Drawing.WorldToScreen(new Vector3(Common.CommonHelper.CenterOfVectors(objectCenter).X, Common.CommonHelper.CenterOfVectors(objectCenter).Y, Common.CommonHelper.CenterOfVectors(objectCenter).Z));
                        Drawing.DrawText(aX.X - 15, aX.Y - 15, System.Drawing.Color.White, "1st Jump");

                        /*---------------------------------------------------------------------------------------------------------*/
                        var xStartPos = JumpObject.Position;
                        var xEndPos   = JumpTarget.Position;
                        var xEndPos1  = JumpTarget.Position + (xStartPos - xEndPos).To2D().Normalized().Rotated(30 * (float)Math.PI / 180).To3D() * JumpObject.BoundingRadius * 2;
                        var xEndPost2 = JumpTarget.Position + (xStartPos - xEndPos).To2D().Normalized().Rotated(-30 * (float)Math.PI / 180).To3D() * JumpObject.BoundingRadius * 2;

                        var xWidth = 1;

                        var x1 = new Geometry.Polygon.Line(xStartPos, xEndPos); x1.Draw(System.Drawing.Color.IndianRed, xWidth);

                        var y1 = new Geometry.Polygon.Line(xEndPos, xEndPos1); y1.Draw(System.Drawing.Color.IndianRed, xWidth + 1);
                        var z1 = new Geometry.Polygon.Line(xEndPos, xEndPost2); z1.Draw(System.Drawing.Color.IndianRed, xWidth + 1);

                        Vector3[] enemyCenter = new[] { JumpObject.Position, JumpTarget.Position };
                        var       bX          =
                            Drawing.WorldToScreen(new Vector3(Common.CommonHelper.CenterOfVectors(enemyCenter).X, Common.CommonHelper.CenterOfVectors(enemyCenter).Y,
                                                              Common.CommonHelper.CenterOfVectors(enemyCenter).Z));
                    }
                }
            }
        }
Beispiel #54
0
        private static void GameOnOnUpdate(EventArgs args)
        {
            JumpTarget = CommonTargetSelector.GetTarget(Q.Range * 3, TargetSelector.DamageType.Physical);
            if (ModeConfig.Orbwalker.ActiveMode != Orbwalking.OrbwalkingMode.Combo)
            {
                return;
            }

            if (!JumpTarget.IsValidTarget())
            {
                return;
            }

            if (!JumpObject.IsValidTarget(Q.Range))
            {
                return;
            }

            if (!Q.IsReady())
            {
                return;
            }

            if (!MenuLocal.Item("Jump.Enabled").GetValue <KeyBind>().Active)
            {
                return;
            }
            var jumpMode = MenuLocal.Item("Jump.Mode").GetValue <StringList>().SelectedIndex;

            if (jumpMode != 0)
            {
                switch (jumpMode)
                {
                case 1:
                {
                    Q.CastOnUnit(JumpObject);
                    break;
                }

                case 2:
                {
                    if (JumpTarget.CanStun())
                    {
                        Q.CastOnUnit(JumpObject);
                    }
                    break;
                }

                case 3:
                {
                    if (JumpTarget.Health < CommonMath.GetComboDamage(JumpTarget))
                    {
                        Q.CastOnUnit(JumpObject);
                    }
                    break;
                }

                case 4:
                {
                    if (JumpTarget.CanStun() || JumpTarget.Health < CommonMath.GetComboDamage(JumpTarget))
                    {
                        Q.CastOnUnit(JumpObject);
                    }
                    break;
                }
                }
            }

            //if (!JumpTarget.IsValidTarget(Q.Range) && !JumpTarget.IsValidTarget(Q.Range + Orbwalking.GetRealAutoAttackRange(null) + 65))
            //{
            //    ObjectManager.Player.IssueOrder(GameObjectOrder.MoveTo, JumpTarget);
            //}


            return;

            if (JumpTarget.UnderTurret(true) && MenuLocal.Item("Jump.TurretControl").GetValue <StringList>().SelectedIndex == 0)
            {
                return;
            }


            if (JumpTarget.UnderTurret(true) &&
                MenuLocal.Item("Jump.TurretControl").GetValue <StringList>().SelectedIndex == 1 &&
                JumpTarget.Health < Common.CommonMath.GetComboDamage(JumpTarget))
            {
                Q.CastOnUnit(JumpObject);
            }

            var jumpQ = MenuLocal.Item("Jump.TurretControl").GetValue <StringList>().SelectedIndex;

            switch (jumpQ)
            {
            case 0:
            {
                Q.CastOnUnit(JumpObject);
                break;
            }

            case 1:
            {
                if (JumpTarget.CanStun())
                {
                    Q.CastOnUnit(JumpObject);
                }
                break;
            }

            case 2:
            {
                if (JumpTarget.Health < Common.CommonMath.GetComboDamage(JumpTarget))
                {
                    Q.CastOnUnit(JumpObject);
                }
                break;
            }

            case 3:
            {
                if (JumpTarget.CanStun() && JumpTarget.Health < Common.CommonMath.GetComboDamage(JumpTarget))
                {
                    Q.CastOnUnit(JumpObject);
                }
                break;
            }
            }
        }
Beispiel #55
0
 public static bool CanCastSpell(Obj_AI_Hero target)
 {
     return
         (!(target.IsValidTarget() && Orbwalking.InAutoAttackRange(target) && (Orbwalking.CanAttack() || BadaoChecker.BadaoHasTiamat())) &&
          Orbwalking.CanMove(0));
 }
Beispiel #56
0
        private static void UseCombo()
        {
            var UseQ      = Config.Item("UseQ").GetValue <bool>();
            var UseW      = Config.Item("UseW").GetValue <bool>();
            var UseE      = Config.Item("UseE").GetValue <bool>();
            var UseR      = Config.Item("UseR").GetValue <bool>();
            var UseItems  = Config.Item("UseItems").GetValue <bool>();
            var UseIgnite = Config.Item("UseIgnite").GetValue <bool>();
            var UsePacket = Config.Item("UsePacket").GetValue <bool>();
            var UseQE     = Config.Item("UseQE").GetValue <bool>();

            if (target == null)
            {
                return;
            }

            if (UseItems && ComboDamage(target) && GetDistanceSqr(myHero, target) <= 750 * 750)
            {
                if (Items.CanUseItem(3128))
                {
                    Items.UseItem(3128, target);
                }
                if (Items.CanUseItem(3188))
                {
                    Items.UseItem(3188, target);
                }
            }
            if (UseQ && Q.IsReady() && GetDistanceSqr(myHero, target) <= Q.Range * Q.Range)
            {
                Q.CastIfHitchanceEquals(target, HitChance.High, UsePacket);
                if (target.IsValidTarget(550) && target.HasBuff("luxilluminatingfraulein"))
                {
                    myHero.IssueOrder(GameObjectOrder.AttackUnit, target);
                }
            }
            if (UseW && W.IsReady() && IsFacing(target) && myHero.Distance(target) <= 550)
            {
                W.Cast(target, UsePacket);
            }
            if (UseE && E.IsReady() && GetDistanceSqr(myHero, target) <= E.Range * E.Range)
            {
                if (UseQE)
                {
                    if (target.HasBuff("LuxLightBindingMis"))
                    {
                        E.Cast(target, UsePacket);
                        CastE2();
                    }
                }
                else
                {
                    E.CastIfHitchanceEquals(target, HitChance.High, UsePacket);
                    CastE2();
                }
                if (target.IsValidTarget(550) && target.HasBuff("luxilluminatingfraulein"))
                {
                    myHero.IssueOrder(GameObjectOrder.AttackUnit, target);
                }
            }
            if (UseR && R.IsReady() && IsKillable(myHero, target, new[] { SpellSlot.R }))
            {
                if (target.Health <= Damage.GetAutoAttackDamage(myHero, target, true) && myHero.Distance(target) < 550)
                {
                    myHero.IssueOrder(GameObjectOrder.AttackUnit, target);
                }
                else
                {
                    R.Cast(target, UsePacket);
                }
            }
            if (UseIgnite && IgniteKillable(myHero, target))
            {
                if (IgniteSlot != SpellSlot.Unknown && myHero.SummonerSpellbook.CanUseSpell(IgniteSlot) == SpellState.Ready && myHero.Distance(target) <= 600)
                {
                    if (target.Health <= Damage.GetAutoAttackDamage(myHero, target, true) && myHero.Distance(target) < 550)
                    {
                        myHero.IssueOrder(GameObjectOrder.AttackUnit, target);
                    }
                    else
                    {
                        myHero.SummonerSpellbook.CastSpell(IgniteSlot, target);
                    }
                }
            }
        }
        private static void OnDrawingDraw(EventArgs args)
        {
            try
            {
                if (_menu == null || ObjectManager.Player.IsDead)
                {
                    return;
                }
                var weightsRange        = _menu.Item(_menu.Name + ".drawing.weights-range").GetValue <bool>();
                var weightsSimple       = _menu.Item(_menu.Name + ".drawing.weights-simple").GetValue <bool>();
                var weightsAdvanced     = _menu.Item(_menu.Name + ".drawing.weights-advanced").GetValue <bool>();
                var weightMultiplicator =
                    _menu.Item(_menu.Name + ".weights.heroes.weight-multiplicator").GetValue <Slider>().Value;
                var lastTarget      = _menu.Item(_menu.Name + ".drawing.last-target").GetValue <Circle>();
                var assassin        = _menu.Item(_menu.Name + ".assassin-mode.enabled").GetValue <bool>();
                var assassinColor   = _menu.Item(_menu.Name + ".drawing.assassin-color").GetValue <Circle>();
                var assassinRange   = _menu.Item(_menu.Name + ".assassin-mode.range").GetValue <Slider>().Value;
                var circleThickness = _menu.Item(_menu.Name + ".drawing.circle-thickness").GetValue <Slider>().Value;
                var focusSelected   = _menu.Item(_menu.Name + ".focus-selected").GetValue <bool>();
                var selected        = _menu.Item(_menu.Name + ".drawing.selected-color").GetValue <Circle>();

                if (_selectedTarget != null && _selectedTarget.IsValidTarget() && focusSelected && selected.Active)
                {
                    Render.Circle.DrawCircle(
                        _selectedTarget.Position, _selectedTarget.BoundingRadius + SelectClickBuffer, selected.Color,
                        circleThickness);
                }

                if (assassin && assassinColor.Active)
                {
                    foreach (var target in
                             GameObjects.EnemyHeroes.Where(
                                 h =>
                                 _menu.Item(_menu.Name + ".assassin-mode.heroes." + h.ChampionName).GetValue <bool>() &&
                                 h.IsValidTarget(assassinRange) && h.Position.IsOnScreen()))
                    {
                        Render.Circle.DrawCircle(
                            target.Position, target.BoundingRadius + SelectClickBuffer, assassinColor.Color,
                            circleThickness);
                    }
                    Render.Circle.DrawCircle(
                        ObjectManager.Player.Position, assassinRange, assassinColor.Color, circleThickness);
                }
                if (lastTarget.Active)
                {
                    if (_lastTarget != null && !_lastTarget.IsDead && _lastTarget.IsVisible &&
                        _lastTarget.Position.IsOnScreen())
                    {
                        Render.Circle.DrawCircle(
                            _lastTarget.Position, _lastTarget.BoundingRadius + SelectClickBuffer, lastTarget.Color,
                            circleThickness);
                    }
                }
                if ((weightsSimple || weightsAdvanced) && _tsMode == TargetSelectorModeType.Weights)
                {
                    var enemies =
                        GameObjects.EnemyHeroes.Where(
                            h => h.IsValidTarget(weightsRange ? _debugRange : float.MaxValue) && h.Position.IsOnScreen())
                        .ToList();
                    foreach (var weight in WeightedItems.Where(w => w.Weight > 0))
                    {
                        weight.UpdateSimulatedMaxValue(enemies);
                    }
                    foreach (var target in enemies)
                    {
                        var position    = Drawing.WorldToScreen(target.Position);
                        var totalWeight = 0f;
                        var offset      = 0f;
                        foreach (var weight in WeightedItems.Where(w => w.Weight > 0))
                        {
                            var lastWeight = weight.SimulatedCalculatedWeight(target);
                            if (lastWeight > 0)
                            {
                                if (_menu != null)
                                {
                                    var heroMultiplicator =
                                        _menu.Item(_menu.Name + ".weights.heroes." + target.ChampionName)
                                        .GetValue <Slider>()
                                        .Value;
                                    if (heroMultiplicator > 1)
                                    {
                                        lastWeight += _averageWeight * heroMultiplicator;
                                    }
                                    if (weightMultiplicator > 1)
                                    {
                                        lastWeight *= weightMultiplicator;
                                    }
                                }
                                if (weightsAdvanced)
                                {
                                    Drawing.DrawText(
                                        position.X + target.BoundingRadius, position.Y - 100 + offset, Color.White,
                                        lastWeight.ToString("0.0").Replace(",", ".") + " - " + weight.DisplayName);
                                    offset += 17f;
                                }
                                totalWeight += lastWeight;
                            }
                        }
                        if (weightsSimple)
                        {
                            Drawing.DrawText(
                                target.HPBarPosition.X + 55f, target.HPBarPosition.Y - 20f, Color.White,
                                totalWeight.ToString("0.0").Replace(",", "."));
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Global.Logger.AddItem(new LogItem(ex));
            }
        }
Beispiel #58
0
        private static void OnCombo(Obj_AI_Hero target)
        {
            if (_menu.Item("miscIgnite").GetValue <bool>() && Ignite.IsReady() &&
                Ignite.GetDamage(target) > target.Health)
            {
                Ignite.Cast(target);
            }

            float pounceDistance = target.IsHunted() ? 740 : _pounce.Range;

            if (_player.IsCougar())
            {
                if (_menu.Item("useTakedown").GetValue <bool>() && _takedown.IsReady() &&
                    _player.Distance(target.Position) <= _takedown.Range)
                {
                    _takedown.Cast(true);
                }

                if (_pounce.IsReady() && _menu.Item("usePounce").GetValue <bool>())
                {
                    if (_menu.Item("turretSafety").GetValue <bool>() && IsUnderEnemyTurret(target))
                    {
                        ShowNotification("Target is under turret, won't pounce.", Color.Red, 3100);
                        return;
                    }

                    if (target.IsHunted() && _player.Distance(target.Position) <= 740)
                    {
                        _pounce.Cast(target.ServerPosition);
                    }
                    else if (_player.Distance(target.Position) <= 400)
                    {
                        _pounce.Cast(target.Position);
                    }
                }

                if (_menu.Item("useSwipe").GetValue <bool>() && _swipe.IsReady() &&
                    _player.Distance(target.Position) <= _swipe.RangeSqr)
                {
                    if (!_pounce.IsReady())
                    {
                        _swipe.Cast(target);
                    }
                }

                if (_menu.Item("useHuman").GetValue <bool>())
                {
                    if (!_pounce.IsReady() && _player.Distance(target.Position) > pounceDistance &&
                        _cooldownTracker.CheckSpell(CooldownTracker.CooldownSpell.Javelin) &&
                        _javelinToss.GetPrediction(target).Hitchance >= CustomHitChance)
                    {
                        if (_aspectOfTheCougar.IsReady())
                        {
                            _aspectOfTheCougar.Cast();
                        }
                    }
                }
            }
            else
            {
                if (_menu.Item("useJavelin").GetValue <bool>() && _javelinToss.IsReady() &&
                    target.IsValidTarget(_javelinToss.Range) && _player.Distance(target.Position) <= _javelinToss.Range)
                {
                    _javelinToss.CastIfHitchanceEquals(target, CustomHitChance);
                }

                if (_menu.Item("useBushwhack").GetValue <bool>() && _bushwhack.IsReady() &&
                    target.IsValidTarget(_bushwhack.Range) && _player.Distance(target.Position) <= _bushwhack.Range)
                {
                    _bushwhack.CastIfHitchanceEquals(target, CustomHitChance);
                }

                if (target.IsHunted() && !_javelinToss.IsReady() && _player.Distance(target.Position) < pounceDistance)
                {
                    if (_aspectOfTheCougar.IsReady() && _menu.Item("useCougar").GetValue <bool>())
                    {
                        _aspectOfTheCougar.Cast();
                    }
                }
            }
        }
Beispiel #59
0
        private bool IsCondemnable(Obj_AI_Hero hero)
        {
            if (!hero.IsValidTarget(550f) || hero.HasBuffOfType(BuffType.SpellShield) ||
                hero.HasBuffOfType(BuffType.SpellImmunity) || hero.IsDashing())
            {
                return(false);
            }

            //values for pred calc pP = player position; p = enemy position; pD = push distance
            var pP   = ObjectManager.Player.ServerPosition;
            var p    = hero.ServerPosition;
            var pD   = EPushDistanceSlider.Value;
            var mode = EModeStringList.SelectedValue;


            if (mode == "PRADASMART" && (IsCollisionable(p.Extend(pP, -pD)) || IsCollisionable(p.Extend(pP, -pD / 2f)) ||
                                         IsCollisionable(p.Extend(pP, -pD / 3f))))
            {
                if (!hero.CanMove ||
                    (hero.IsWindingUp))
                {
                    return(true);
                }

                var enemiesCount = ObjectManager.Player.CountEnemyHeroesInRange(1200);
                if (enemiesCount > 1 && enemiesCount <= 3)
                {
                    var prediction = E.GetPrediction(hero);
                    for (var i = 15; i < pD; i += 75)
                    {
                        if (i > pD)
                        {
                            var lastPosFlags = NavMesh.GetCollisionFlags(
                                prediction.UnitPosition.ToVector2()
                                .Extend(
                                    pP.ToVector2(),
                                    -pD)
                                .ToVector3());
                            if (lastPosFlags.HasFlag(CollisionFlags.Wall) || lastPosFlags.HasFlag(CollisionFlags.Building))
                            {
                                return(true);
                            }
                            return(false);
                        }
                        var posFlags = NavMesh.GetCollisionFlags(
                            prediction.UnitPosition.ToVector2()
                            .Extend(
                                pP.ToVector2(),
                                -i)
                            .ToVector3());
                        if (posFlags.HasFlag(CollisionFlags.Wall) || posFlags.HasFlag(CollisionFlags.Building))
                        {
                            return(true);
                        }
                    }
                    return(false);
                }
                else
                {
                    var         hitchance      = EHitchanceSlider.Value;
                    var         angle          = 0.20 * hitchance;
                    const float travelDistance = 0.5f;
                    var         alpha          = new Vector2((float)(p.X + travelDistance * Math.Cos(Math.PI / 180 * angle)),
                                                             (float)(p.X + travelDistance * Math.Sin(Math.PI / 180 * angle)));
                    var beta = new Vector2((float)(p.X - travelDistance * Math.Cos(Math.PI / 180 * angle)),
                                           (float)(p.X - travelDistance * Math.Sin(Math.PI / 180 * angle)));

                    for (var i = 15; i < pD; i += 100)
                    {
                        if (i > pD)
                        {
                            return(false);
                        }
                        if (IsCollisionable(pP.ToVector2().Extend(alpha,
                                                                  i)
                                            .ToVector3()) && IsCollisionable(pP.ToVector2().Extend(beta, i).ToVector3()))
                        {
                            return(true);
                        }
                    }
                    return(false);
                }
            }

            if (mode == "PRADAPERFECT" &&
                (IsCollisionable(p.Extend(pP, -pD)) || IsCollisionable(p.Extend(pP, -pD / 2f)) ||
                 IsCollisionable(p.Extend(pP, -pD / 3f))))
            {
                if (!hero.CanMove ||
                    (hero.IsWindingUp))
                {
                    return(true);
                }

                var         hitchance      = EHitchanceSlider.Value;
                var         angle          = 0.20 * hitchance;
                const float travelDistance = 0.5f;
                var         alpha          = new Vector2((float)(p.X + travelDistance * Math.Cos(Math.PI / 180 * angle)),
                                                         (float)(p.X + travelDistance * Math.Sin(Math.PI / 180 * angle)));
                var beta = new Vector2((float)(p.X - travelDistance * Math.Cos(Math.PI / 180 * angle)),
                                       (float)(p.X - travelDistance * Math.Sin(Math.PI / 180 * angle)));

                for (var i = 15; i < pD; i += 100)
                {
                    if (i > pD)
                    {
                        return(IsCollisionable(alpha.Extend(pP.ToVector2(),
                                                            -pD)
                                               .ToVector3()) && IsCollisionable(beta.Extend(pP.ToVector2(), -pD).ToVector3()));
                    }
                    if (IsCollisionable(alpha.Extend(pP.ToVector2(),
                                                     -i)
                                        .ToVector3()) && IsCollisionable(beta.Extend(pP.ToVector2(), -i).ToVector3()))
                    {
                        return(true);
                    }
                }
                return(false);
            }

            if (mode == "OLDPRADA")
            {
                if (!hero.CanMove ||
                    (hero.IsWindingUp))
                {
                    return(true);
                }

                var         hitchance      = EHitchanceSlider.Value;
                var         angle          = 0.20 * hitchance;
                const float travelDistance = 0.5f;
                var         alpha          = new Vector2((float)(p.X + travelDistance * Math.Cos(Math.PI / 180 * angle)),
                                                         (float)(p.X + travelDistance * Math.Sin(Math.PI / 180 * angle)));
                var beta = new Vector2((float)(p.X - travelDistance * Math.Cos(Math.PI / 180 * angle)),
                                       (float)(p.X - travelDistance * Math.Sin(Math.PI / 180 * angle)));

                for (var i = 15; i < pD; i += 100)
                {
                    if (IsCollisionable(pP.ToVector2().Extend(alpha,
                                                              i)
                                        .ToVector3()) || IsCollisionable(pP.ToVector2().Extend(beta, i).ToVector3()))
                    {
                        return(true);
                    }
                }
                return(false);
            }

            if (mode == "MARKSMAN")
            {
                var prediction = E.GetPrediction(hero);
                return(NavMesh.GetCollisionFlags(
                           prediction.UnitPosition.ToVector2()
                           .Extend(
                               pP.ToVector2(),
                               -pD)
                           .ToVector3()).HasFlag(CollisionFlags.Wall) ||
                       NavMesh.GetCollisionFlags(
                           prediction.UnitPosition.ToVector2()
                           .Extend(
                               pP.ToVector2(),
                               -pD / 2f)
                           .ToVector3()).HasFlag(CollisionFlags.Wall));
            }

            if (mode == "SHARPSHOOTER")
            {
                var prediction = E.GetPrediction(hero);
                for (var i = 15; i < pD; i += 100)
                {
                    if (i > pD)
                    {
                        return(false);
                    }
                    var posCF = NavMesh.GetCollisionFlags(
                        prediction.UnitPosition.ToVector2()
                        .Extend(
                            pP.ToVector2(),
                            -i)
                        .ToVector3());
                    if (posCF.HasFlag(CollisionFlags.Wall) || posCF.HasFlag(CollisionFlags.Building))
                    {
                        return(true);
                    }
                }
                return(false);
            }

            if (mode == "GOSU")
            {
                var prediction = E.GetPrediction(hero);
                for (var i = 15; i < pD; i += 75)
                {
                    var posCF = NavMesh.GetCollisionFlags(
                        prediction.UnitPosition.ToVector2()
                        .Extend(
                            pP.ToVector2(),
                            -i)
                        .ToVector3());
                    if (posCF.HasFlag(CollisionFlags.Wall) || posCF.HasFlag(CollisionFlags.Building))
                    {
                        return(true);
                    }
                }
                return(false);
            }

            if (mode == "VHR")
            {
                var prediction = E.GetPrediction(hero);
                for (var i = 15; i < pD; i += (int)hero.BoundingRadius) //:frosty:
                {
                    var posCF = NavMesh.GetCollisionFlags(
                        prediction.UnitPosition.ToVector2()
                        .Extend(
                            pP.ToVector2(),
                            -i)
                        .ToVector3());
                    if (posCF.HasFlag(CollisionFlags.Wall) || posCF.HasFlag(CollisionFlags.Building))
                    {
                        return(true);
                    }
                }
                return(false);
            }

            if (mode == "PRADALEGACY")
            {
                var prediction = E.GetPrediction(hero);
                for (var i = 15; i < pD; i += 75)
                {
                    var posCF = NavMesh.GetCollisionFlags(
                        prediction.UnitPosition.ToVector2()
                        .Extend(
                            pP.ToVector2(),
                            -i)
                        .ToVector3());
                    if (posCF.HasFlag(CollisionFlags.Wall) || posCF.HasFlag(CollisionFlags.Building))
                    {
                        return(true);
                    }
                }
                return(false);
            }

            if (mode == "FASTEST" &&
                (IsCollisionable(p.Extend(pP, -pD)) || IsCollisionable(p.Extend(pP, -pD / 2f)) ||
                 IsCollisionable(p.Extend(pP, -pD / 3f))))
            {
                return(true);
            }

            return(false);
        }
Beispiel #60
0
        private static bool AutoKill()
        {
            if (!Menu.Item("KSEnabled").IsActive())
            {
                return(false);
            }

            var minHealth  = Menu.Item("KSHealth").GetValue <Slider>().Value;
            var channeling = Player.IsChannelingImportantSpell();

            if (channeling && !Menu.Item("KSRCancel").IsActive())
            {
                return(false);
            }

            var delay = (int)(150 + Game.Ping / 2f + Random.Next(150));

            if (Q.LastCastedDelay(delay) || E.LastCastedDelay(delay) || R.LastCastedDelay(delay))
            {
                return(false);
            }

            if (KSTarget != null && !KSTarget.IsValidTarget(E.Range))
            {
                KSTarget = null;
            }

            foreach (var enemy in
                     Enemies.Where(
                         h =>
                         h.IsValidTarget(E.Range + Q.Range) && !h.IsZombie &&
                         (KSTarget == null || KSTarget.NetworkId == h.NetworkId)).OrderBy(h => h.Health))
            {
                if (E.IsInRange(enemy))
                {
                    if (W.IsCastable(enemy, true) && W.Cast())
                    {
                        KSTarget = enemy;
                        return(true);
                    }

                    if (Q.IsCastable(enemy, true) && Q.CastOnUnit(enemy))
                    {
                        KSTarget = enemy;
                        return(true);
                    }

                    if (Q.IsCastable(enemy, true, false) && W.IsCastable(enemy, true, false) &&
                        enemy.GetComboDamage(Q, W) > enemy.Health && Q.CastOnUnit(enemy))
                    {
                        KSTarget = enemy;
                        return(true);
                    }

                    if (Player.HealthPercent < minHealth)
                    {
                        continue;
                    }

                    if (E.IsCastable(enemy, true) && E.CastOnUnit(enemy))
                    {
                        KSTarget = enemy;
                        return(true);
                    }

                    if (enemy.GetKSDamage() > enemy.Health && Combo(enemy))
                    {
                        KSTarget = enemy;
                        return(true);
                    }

                    continue;
                }

                // doing some gapclosers and hops here
                if (!E.IsActive(true) || !E.IsReady())
                {
                    continue;
                }

                var closestTarget = Utility.GetClosestETarget(enemy);
                if (Menu.Item("KSGapclose").IsActive() && closestTarget != null)
                {
                    var gapcloseDmg = enemy.GetGapcloseDamage(closestTarget);
                    if (enemy.Health < gapcloseDmg &&
                        enemy.CountEnemiesInRange(300) <= Menu.Item("KSEnemies").GetValue <Slider>().Value&&
                        (!Menu.Item("KSTurret").IsActive() || !closestTarget.UnderTurret(true)) &&
                        E.CastOnUnit(closestTarget))
                    {
                        return(true);
                    }
                }
                if (!Menu.Item("KSWardJump").IsActive())
                {
                    continue;
                }

                var wardSlot = Utility.GetReadyWard();

                if (wardSlot.Equals(SpellSlot.Unknown) || !LastWardPlacement.HasTimePassed(2000))
                {
                    continue;
                }

                var range = Player.Spellbook.GetSpell(wardSlot).SData.CastRange;

                if (!enemy.IsValidTarget(Q.Range + range))
                {
                    continue;
                }

                var pos = Player.ServerPosition.Extend(enemy.ServerPosition, range);

                if (Menu.Item("KSTurret").IsActive() && pos.UnderTurret(true))
                {
                    continue;
                }

                if (pos.CountEnemiesInRange(300) - 1 > 2)
                {
                    continue;
                }

                if (enemy.Health < enemy.GetGapcloseDamage(pos) && Player.Spellbook.CastSpell(wardSlot, pos))
                {
                    LastWardPlacement = Utils.TickCount;
                    WardJumping       = true;
                    return(true);
                }
            }
            return(false);
        }