Beispiel #1
0
 private void Drawing_OnDraw(EventArgs args)
 {
     // Accurate Draw AutoAttack
     if (Config.drawAA.GetValue <bool>())
     {
         Render.Circle.DrawCircle(Player.Position, Orbwalking.GetRealAutoAttackRange(null), Color.Gold);
     }
     if (Config.drawW.GetValue <bool>())
     {
         Render.Circle.DrawCircle(Player.Position, W.Range, Color.SkyBlue);
     }
 }
Beispiel #2
0
 private static void Drawing_OnDraw(EventArgs args)
 {
     // Accurate Draw AutoAttack
     if (Menu.Item("DrawAA").GetValue <bool>())
     {
         Render.Circle.DrawCircle(Player.Position, Orbwalking.GetRealAutoAttackRange(null), Color.Gold);
     }
     if (Menu.Item("DrawW").GetValue <bool>())
     {
         Render.Circle.DrawCircle(Player.Position, W.Range, Color.SkyBlue);
     }
 }
Beispiel #3
0
        /// <summary>
        ///     Drawings
        /// </summary>
        /// <param name="args"></param>
        private static void Drawing_OnDraw(EventArgs args)
        {
            if (Player.IsDead)
            {
                return;
            }
            if (Menu.Item("DrawAA").GetValue <bool>())
            {
                Render.Circle.DrawCircle(ObjectManager.Player.Position, Orbwalking.GetRealAutoAttackRange(null),
                                         System.Drawing.Color.BlueViolet);
            }
            if (Menu.Item("DrawQ").GetValue <bool>())
            {
                Render.Circle.DrawCircle(ObjectManager.Player.Position, Q.Range, System.Drawing.Color.Chartreuse);
            }
            if (Menu.Item("DrawR").GetValue <bool>() && (R.Level > 0) && R.Instance.IsReady())
            {
                Render.Circle.DrawCircle(ObjectManager.Player.Position, R.Range, System.Drawing.Color.DeepPink);
            }

            if (Menu.Item("QMinionDrawHelper").GetValue <bool>())
            {
                foreach (
                    var creature in
                    ObjectManager.Get <Obj_AI_Minion>()
                    .Where(
                        x =>
                        x.Name.ToLower().Contains("minion") && x.IsHPBarRendered && x.IsValidTarget(1000) &&
                        (x.Health < Q.GetDamage(x) + GetSheenDamage(x)) && x.IsEnemy))
                {
                    Render.Circle.DrawCircle(creature.Position, 35, System.Drawing.Color.Chartreuse);
                }
            }

            if (!Menu.Item("DrawStunnable").GetValue <bool>())
            {
                return;
            }

            foreach (var enemy in
                     ObjectManager.Get <Obj_AI_Hero>().Where(x => Stunnable(x) && x.IsValidTarget()))
            {
                var drawPos  = Drawing.WorldToScreen(enemy.Position);
                var textSize = Drawing.GetTextExtent("Stunnable");
                Drawing.DrawText(drawPos.X - textSize.Width / 2f, drawPos.Y, System.Drawing.Color.DeepPink, "Stunnable");
            }
        }
Beispiel #4
0
        private static void Combo()
        {
            // If target's champion target him, if it's not target surrounding enemy [creep, etc]
            var target = Orbwalker.GetTarget() as Obj_AI_Hero;

            if (target == null)
            {
                target = TargetSelector.GetTarget(W.Range, TargetSelector.DamageType.Physical);
            }

            if ((target != null) && target.IsValidTarget())
            {
                if ((Menu.Item("ComboUseQ").GetValue <bool>() &&
                     target.IsValidTarget(Orbwalking.GetRealAutoAttackRange(null)) && Q.IsReady() &&
                     (Player.Mana > Q.Instance.ManaCost + R.Instance.ManaCost)) ||
                    (target.Health < 5 * Player.GetAutoAttackDamage(Player)))
                {
                    Q.Cast();
                }
                if (Menu.Item("ComboUseW").GetValue <bool>() && W.IsReady() &&
                    (Player.Mana > W.Instance.ManaCost + R.Instance.ManaCost) && target.IsValidTarget(W.Range))
                {
                    SebbySpell(W, target);
                }
                DontREnemyNearAlly();
                foreach (
                    var ulttarget in
                    HeroManager.Enemies.Where(ulttarget => target.IsValidTarget(2000) && OktwCommon.ValidUlt(ulttarget))
                    )
                {
                    if (Menu.Item("ComboUseR").GetValue <bool>() && target.IsValidTarget(W.Range) &&
                        (target.Health <
                         W.GetDamage(target) + R.GetDamage(target) + 3 * Player.GetAutoAttackDamage(target) +
                         OktwCommon.GetIncomingDamage(target)) && !target.HasBuff("rebirth"))
                    {
                        SebbySpell(R, target);
                        if (Q.IsReady())
                        {
                            Q.Cast();
                        }
                    }
                }
            }
        }
Beispiel #5
0
        /// <summary>
        ///     Fired when the game loads.
        /// </summary>
        /// <param name="args">The <see cref="EventArgs" /> instance containing the event data.</param>
        public static void OnGameLoad()
        {
            try
            {
                if (!Player.IsChampion("Zilean"))
                {
                    return;
                }

                var igniteSlot = Player.GetSpellSlot("summonerdot");
                if (igniteSlot != SpellSlot.Unknown)
                {
                    IgniteSpell = new Spell(igniteSlot, 600f);
                }

                foreach (var ally in HeroManager.Allies)
                {
                    IncomingDamageManager.AddChampion(ally);
                }

                IncomingDamageManager.Skillshots = true;

                Q = new Spell(SpellSlot.Q, 900f - 100f);
                W = new Spell(SpellSlot.W, Orbwalking.GetRealAutoAttackRange(Player));
                E = new Spell(SpellSlot.E, 700f);
                R = new Spell(SpellSlot.R, 900f);

                Q.SetSkillshot(0.7f, 140f - 25f, int.MaxValue, false, SkillshotType.SkillshotCircle);

                GenerateMenu();

                Game.OnUpdate  += OnUpdate;
                Drawing.OnDraw += OnDraw;
                Interrupter2.OnInterruptableTarget += OnInterruptableTarget;
                Obj_AI_Base.OnProcessSpellCast     += OnProcessSpellCast;
                Orbwalking.BeforeAttack            += BeforeAttack;
            }
            catch (Exception exception)
            {
                Console.WriteLine(exception);
            }
        }
Beispiel #6
0
        private static void Harass()
        {
            var SpellQ = Menu.Item("HarassUseQ").GetValue <bool>();
            var SpellW = Menu.Item("HarassUseW").GetValue <bool>();
            var target = Orbwalker.GetTarget() as Obj_AI_Hero;

            if (target == null)
            {
                target = TargetSelector.GetTarget(W.Range, TargetSelector.DamageType.Physical);
            }

            if ((target != null) && target.IsValidTarget())
            {
                if (target.IsValidTarget(W.Range) && SpellW)
                {
                    SebbySpell(W, target);
                }

                if (Q.IsReady() && SpellQ && target.IsValidTarget(Orbwalking.GetRealAutoAttackRange(null)))
                {
                    Q.Cast();
                }
            }
        }
Beispiel #7
0
        private void LaneClear()
        {
            if (!Config.EnableFarming.GetValue <bool>())
            {
                return;
            }

            // LaneClear | Notes: Rework on early levels not using that much abilities since Spell Damage is lower, higher Lvl is fine
            if (Config.UseQLC.GetValue <bool>() || Config.UseELC.GetValue <bool>())
            {
                if (Player.ManaPercent > Config.laneclearMinimumMana.GetValue <Slider>().Value)
                {
                    var ryzeebuffed =
                        MinionManager.GetMinions(Player.Position, Q.Range)
                        .Find(x => x.HasBuff("RyzeE") && x.IsValidTarget(Q.Range));
                    var ryzenotebuffed =
                        MinionManager.GetMinions(Player.Position, Q.Range)
                        .Find(x => !x.HasBuff("RyzeE") && x.IsValidTarget(Q.Range));
                    var allMinionsQ = Cache.GetMinions(Player.ServerPosition, Q.Range, MinionTeam.Enemy);
                    var allMinions  = Cache.GetMinions(Player.ServerPosition, E.Range, MinionTeam.Enemy);
                    if (Q.IsReady() && !E.IsReady())
                    {
                        if (allMinionsQ.Count > 0)
                        {
                            foreach (var minion in allMinionsQ)
                            {
                                if (!minion.IsValidTarget() || (minion == null))
                                {
                                    return;
                                }
                                if (minion.Health < QGetRealDamage(minion))
                                {
                                    Q.Cast(minion);
                                }
                                else if ((minion.Health < QGetRealDamage(minion) + Player.GetAutoAttackDamage(minion)) &&
                                         minion.IsValidTarget(Orbwalking.GetRealAutoAttackRange(minion)))
                                {
                                    Q.Cast(minion);
                                    Orbwalker.ForceTarget(minion);
                                }
                            }
                        }
                    }
                    if (!Q.IsReady() && (Q.Level > 0) && E.IsReady())
                    {
                        if (ryzeebuffed != null)
                        {
                            if ((ryzeebuffed.Health < E.GetDamage(ryzeebuffed) + QGetRealDamage(ryzeebuffed)) &&
                                ryzeebuffed.IsValidTarget(E.Range))
                            {
                                E.CastOnUnit(ryzeebuffed);
                                if (Q.IsReady())
                                {
                                    Q.Cast(ryzeebuffed);
                                }

                                Orbwalker.ForceTarget(ryzeebuffed);
                            }
                        }
                        else if (ryzeebuffed == null)
                        {
                            foreach (var minion in allMinions)
                            {
                                if (minion.IsValidTarget(E.Range) &&
                                    (minion.Health < E.GetDamage(minion) + QGetRealDamage(minion)))
                                {
                                    E.CastOnUnit(minion);
                                    if (Q.IsReady())
                                    {
                                        Q.Cast(ryzeebuffed);
                                    }
                                }
                            }
                        }
                    }
                    if (Q.IsReady() && E.IsReady())
                    {
                        if (ryzeebuffed != null)
                        {
                            if ((ryzeebuffed.Health <
                                 Q.GetDamage(ryzeebuffed) + E.GetDamage(ryzeebuffed) + Q.GetDamage(ryzeebuffed)) &&
                                ryzeebuffed.IsValidTarget(E.Range))
                            {
                                Q.Cast(ryzeebuffed);
                                if (ryzeebuffed.IsValidTarget(E.Range))
                                {
                                    E.CastOnUnit(ryzeebuffed);
                                }
                                if (!E.IsReady() && Q.IsReady())
                                {
                                    Q.Cast(ryzeebuffed);
                                }
                            }
                        }
                        else if (ryzeebuffed == null)
                        {
                            if ((ryzenotebuffed.Health <
                                 Q.GetDamage(ryzenotebuffed) + E.GetDamage(ryzenotebuffed) + Q.GetDamage(ryzenotebuffed)) &&
                                ryzenotebuffed.IsValidTarget(E.Range))
                            {
                                Q.Cast(ryzenotebuffed);
                                if (ryzenotebuffed.IsValidTarget(E.Range))
                                {
                                    Orbwalker.ForceTarget(ryzenotebuffed);
                                    E.CastOnUnit(ryzenotebuffed);
                                }
                                if (!E.IsReady() && Q.IsReady())
                                {
                                    Q.Cast(ryzenotebuffed);
                                }
                            }
                        }
                    }
                }
            }
        } // LaneClear End