Example #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();
            }
        }
Example #2
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);

            }
        }
Example #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();
            }
        }
Example #4
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);
                }
            }
        }
Example #5
0
 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;
     }
 }
Example #6
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;
 }
Example #7
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;
 }
Example #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);
     }
 }
Example #9
0
 public static void CastR(Obj_AI_Hero target)
 {
     if (isCombo() && target.IsValidTarget() && R.IsInRange(target.ServerPosition) && isEn("UseR"))
     {
         R.Cast(target,true);
     }
 }
Example #10
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);
        }
Example #11
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);
     }
 }
Example #12
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;
 }
Example #13
0
 private void Interrupter2_OnInterruptableTarget(Obj_AI_Hero sender, Interrupter2.InterruptableTargetEventArgs args)
 {
     if (E.IsReady() && sender.IsValidTarget(E.Range))
     {
         E.Cast(sender);
     }
 }
Example #14
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);
     }
 }
Example #15
0
 public override void OnPossibleToInterrupt(Obj_AI_Hero unit, Interrupter2.InterruptableTargetEventArgs spell)
 {
     if (E.IsReady() && unit.IsValidTarget(E.Range))
     {
         E.Cast(unit);
     }
 }
Example #16
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);
     }
 }
Example #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);
     }
 }
Example #18
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();
 }
Example #19
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);
                }

            }
        }
 public static void SetTarget(Obj_AI_Hero hero)
 {
     if (hero.IsValidTarget())
     {
         Selected.Target = hero;
     }
 }
Example #21
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);
             }
         }
     }
 }
Example #22
0
 private void Interrupter_OnInterruptable(Obj_AI_Hero sender, Interrupter2.InterruptableTargetEventArgs args)
 {
     if (sender.IsValidTarget() && IsMenuEnabled("Interrupter") && E.IsReady())
     {
         E.CastIfHitchanceEquals(sender, CustomHitChance, Packets());
     }
 }
Example #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>());
         }
     }
 }
Example #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;
 }
Example #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;
                }
                

                
            }
        }
Example #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);
             }
         }
     }
 }
Example #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);
     }
 }
Example #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);
         }
     }
 }
Example #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);
     }
 }
Example #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);
     }
 }