예제 #1
0
        private void Orbwalking_AfterAttack(AfterAttackArgs args)
        {
            if (Player.ChampionName == "Riven")
                return;

            if (!Menu["use" + Name].Cast<CheckBox>().CurrentValue || !IsReady())
                return;

            var hero = args.Target as AIHeroClient;
            if (hero.LSIsValidTarget(Range))
            {
                if (Activator.omenu[Activator.omenu.UniqueMenuId + "useon" + Tar.Player.NetworkId] == null)
                {
                    return;
                }
                if (!Activator.omenu[Activator.omenu.UniqueMenuId + "useon" + hero.NetworkId].Cast<CheckBox>().CurrentValue)
                    return;

                if (hero.Health / hero.MaxHealth * 100 <= Menu["enemylowhp" + Name + "pct"].Cast<Slider>().CurrentValue)
                {
                    UseItem(Tar.Player, true);
                }

                if (Player.Health / Player.MaxHealth * 100 <= Menu["selflowhp" + Name + "pct"].Cast<Slider>().CurrentValue)
                {
                    UseItem(Tar.Player, true);
                }
            }
        }
예제 #2
0
        /// <summary>
        /// Invokes after attack event
        /// </summary>
        /// <param name="instance">Orbwalker instance</param>
        /// <param name="target">Target</param>
        /// <returns></returns>
        public static AfterAttackArgs FireAfterAttack(LSOrbwalker instance, AttackableUnit target)
        {
            if (instance != null)
            {
                instance.ForceTarget(null);
            }

            AfterAttackArgs args = new AfterAttackArgs();

            args.Instance = instance;
            args.Target   = target;

            if (AfterAttack != null)
            {
                AfterAttack(args);
            }

            if (args.ResetAATimer)
            {
                instance.ResetAutoAttackTimer();
                instance.reset = true;
            }

            return(args);
        }
예제 #3
0
 private static void Orbwalking_AfterAttack(AfterAttackArgs args)
 {
     if (!PortAIO.OrbwalkerManager.isHarassActive || !(args.Target is AIHeroClient))
         return;
     if (args.Target.Position.LSDistance(ObjectManager.Player.Position) <= 200 + 125 + 140)
         BadaoChecker.BadaoUseTiamat();
 }
예제 #4
0
        private static void AfterAttack(AfterAttackArgs args)
        {
            try
            {
                var enemy = args.Target as Obj_AI_Base;
                if (enemy == null || !(args.Target is AIHeroClient))
                {
                    return;
                }

                if (PortAIO.OrbwalkerManager.isComboActive ||
                    PortAIO.OrbwalkerManager.isHarassActive)
                {
                    if (Player.LSCountEnemiesInRange(Player.AttackRange + Player.BoundingRadius + 100) != 0)
                    {
                        spells[Spells.Q].Cast();
                        ActiveModes.CastItems(enemy);
                    }
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
            }
        }
예제 #5
0
 private static void AfterAttack(AfterAttackArgs args)
 {
     var target = args.Target;
     if (Q.IsReady() && getCheckBoxItem(miscMenu, "useqAAA") && !GarenE && target.IsEnemy && PortAIO.OrbwalkerManager.isComboActive)
     {
         Q.Cast(getCheckBoxItem(config, "packets"));
         PortAIO.OrbwalkerManager.ResetAutoAttackTimer();
     }
 }
 private static void Orbwalking_AfterAttack(AfterAttackArgs args)
 {
     if (!PortAIO.OrbwalkerManager.isLaneClearActive || !PortAIO.OrbwalkerManager.isLaneClearActive)
         return;
     if (args.Target.Team != GameObjectTeam.Neutral)
         return;
     if (args.Target.Position.LSDistance(ObjectManager.Player.Position) <= 200 + 125 + 140)
         BadaoChecker.BadaoUseTiamat();
 }
예제 #7
0
        private static void afterAttack(AfterAttackArgs args)
        {
            if (Player.Mana < RMANA + WMANA || !W.IsReady())
                return;

            var t = args.Target as AIHeroClient;

            if (t.LSIsValidTarget())
                W.Cast();
        }
예제 #8
0
        /// <summary>
        /// Invokes after attack event
        /// </summary>
        /// <param name="instance">Orbwalker instance</param>
        /// <param name="target">Target</param>
        /// <returns></returns>
        public static AfterAttackArgs FireAfterAttack(LSOrbwalker instance, AttackableUnit target)
        {
            if (instance != null)
                instance.ForceTarget(null);

            AfterAttackArgs args = new AfterAttackArgs();
            args.Instance = instance;
            args.Target = target;

            if (AfterAttack != null)
                AfterAttack(args);

            if (args.ResetAATimer)
            {
                instance.ResetAutoAttackTimer();
                instance.reset = true;
            }

            return args;
        }
예제 #9
0
        private static void OnAfterAttack(AfterAttackArgs args)
        {
            var target = args.Target;
            if (!target.IsMe || !target.IsValid) return;

            if (PortAIO.OrbwalkerManager.isComboActive)
            {
                if (getCheckBoxItem(comboMenu, "com.isivir.combo.useW") && target.IsValid<AIHeroClient>())
                    {
                        if (ObjectManager.Player.LSGetAutoAttackDamage((AIHeroClient)target, true)
                            * getSliderItem(miscMenu, "com.isivir.miscc.noW") > target.Health) return;

                        Spells[SpellSlot.W].Cast();
                    }

                if (PortAIO.OrbwalkerManager.isHarassActive)
                {
                    if (getCheckBoxItem(harassMenu, "com.isivir.harass.useW") && target.IsValid<AIHeroClient>()
                        && ObjectManager.Player.ManaPercent
                        >= getSliderItem(harassMenu, "com.isivir.harass.mana"))
                    {
                        Spells[SpellSlot.W].Cast();
                    }

                    if (PortAIO.OrbwalkerManager.isLaneClearActive)
                    {
                        if (getCheckBoxItem(laneMenu, "com.isivir.laneclear.useW") && target.IsValid<Obj_AI_Minion>()
                        && ObjectManager.Player.ManaPercent
                        >= getSliderItem(laneMenu, "com.isivir.laneclear.mana"))
                    {
                        Spells[SpellSlot.W].Cast();
                    }
            }
                }
            }
        }
예제 #10
0
 public virtual void Orbwalking_AfterAttack(AfterAttackArgs args)
 {
 }
예제 #11
0
 private static void afterAttack(AfterAttackArgs args)
 {
     //if (!target.IsMe)
         //return;
 }
예제 #12
0
 private void Orbwalker_OnPostAttack(AfterAttackArgs args)
 {
     Orbwalker.ForceTarget(null);
     var possible2WTarget = ValidTargets.FirstOrDefault(
         h =>
             h.ServerPosition.Distance(EloBuddy.ObjectManager.Player.ServerPosition) < 500 &&
             h.GetBuffCount("vaynesilvereddebuff") == 2);
     if (Orbwalker.ActiveMode != LSOrbwalker.OrbwalkingMode.Combo)
     {
         if (possible2WTarget.LSIsValidTarget() && UseEAs3rdWProcBool && LeagueSharp.SDK.Core.Utils.MathUtils.GetWaypoints(possible2WTarget).LastOrDefault().Distance(EloBuddy.ObjectManager.Player.ServerPosition) < 1000)
         {
             if (EDelaySlider > 0)
             {
                 var thisEnemy = possible2WTarget;
                 LeagueSharp.SDK.Core.Utils.DelayAction.Add(EDelaySlider, () => E.CastOnUnit(thisEnemy));
                 return;
             }
             E.CastOnUnit(possible2WTarget);
         }
     }
     if (args.Target is EloBuddy.AIHeroClient && UseQBool)
     {
         if (Q.IsReady())
         {
             var tg = args.Target as EloBuddy.AIHeroClient;
             if (tg != null)
             {
                 var mode = QModeStringList;
                 var tumblePosition = EloBuddy.Game.CursorPos;
                 switch (mode)
                 {
                     case 1:
                         tumblePosition = GetTumblePos(tg);
                         break;
                     default:
                         tumblePosition = EloBuddy.Game.CursorPos;
                         break;
                 }
                 if (tumblePosition.Distance(EloBuddy.ObjectManager.Player.Position) > 2000 || IsDangerousPosition(tumblePosition)) return;
                 Q.Cast(tumblePosition);
             }
         }
     }
     if (args.Target is EloBuddy.Obj_AI_Minion && Orbwalker.ActiveMode == LSOrbwalker.OrbwalkingMode.LaneClear)
     {
         var tg = args.Target as EloBuddy.Obj_AI_Minion;
         if (E.IsReady())
         {
             if (this.IsMinionCondemnable(tg) && GameObjects.Jungle.Any(m => m.NetworkId == tg.NetworkId) && tg.LSIsValidTarget() && this.UseEJungleFarm)
             {
                 if (this.EDelaySlider > 0)
                 {
                     var thisEnemy = tg;
                     LeagueSharp.SDK.Core.Utils.DelayAction.Add(EDelaySlider, () => E.CastOnUnit(thisEnemy));
                     return;
                 }
                 E.CastOnUnit(tg);
             }
         }
         if (this.UseQFarm && this.Q.IsReady())
         {
             if (tg.CharData.BaseSkinName.Contains("SRU_") && !tg.CharData.BaseSkinName.Contains("Mini") && tg.LSIsValidTarget() && !this.IsDangerousPosition(EloBuddy.Game.CursorPos))
             {
                 Q.Cast(EloBuddy.Game.CursorPos);
             }
             if (EloBuddy.ObjectManager.Player.UnderAllyTurret() && GameObjects.EnemyMinions.Count(
                     m =>
                         m.Position.Distance(EloBuddy.ObjectManager.Player.Position) < 550 && m.Health < EloBuddy.ObjectManager.Player.LSGetAutoAttackDamage(m) && Health.GetPrediction(m, (int)(100 + (EloBuddy.Game.Ping / 2) + EloBuddy.ObjectManager.Player.AttackCastDelay * 1000)) > 3) > 1 &&
                 !this.IsDangerousPosition(EloBuddy.Game.CursorPos))
             {
                 Q.Cast(EloBuddy.Game.CursorPos);
             }
             if (EloBuddy.ObjectManager.Player.UnderAllyTurret())
             {
                 if (GameObjects.EnemyMinions.Count(
                     m =>
                         m.Position.Distance(EloBuddy.ObjectManager.Player.Position) < 550 &&
                         m.Health < EloBuddy.ObjectManager.Player.LSGetAutoAttackDamage(m) + Q.GetDamage(m)) > 0 && !this.IsDangerousPosition(EloBuddy.Game.CursorPos))
                 {
                     Q.Cast(EloBuddy.Game.CursorPos);
                 }
             }
         }
     }
     if (UseQOnlyAt2WStacksBool && Orbwalker.ActiveMode != LSOrbwalker.OrbwalkingMode.Combo && possible2WTarget.LSIsValidTarget())
     {
         Q.Cast(GetTumblePos(possible2WTarget));
     }
 }
예제 #13
0
        public override void Orbwalking_AfterAttack(AfterAttackArgs args)
        {
            var t = args.Target as AIHeroClient;
            if (t == null || (!ComboActive && !HarassActive))
                return;

            var useQ = ComboActive ? Program.combo["UseQC"].Cast<CheckBox>().CurrentValue : Program.harass["UseQH"].Cast<CheckBox>().CurrentValue;
            var useE = ComboActive ? Program.combo["UseEC"].Cast<CheckBox>().CurrentValue : Program.harass["UseEH"].Cast<CheckBox>().CurrentValue;
            var useR = ComboActive ? Program.combo["UseRC"].Cast<CheckBox>().CurrentValue : Program.harass["UseRH"].Cast<CheckBox>().CurrentValue;
            var rLim = ComboActive ? Program.combo["RlimC"].Cast<Slider>().CurrentValue : Program.harass["RlimH"].Cast<Slider>().CurrentValue;

            if (useQ && Q.IsReady())
                if (Q.Cast(t, false, true) == LeagueSharp.Common.Spell.CastStates.SuccessfullyCasted)
                    return;

            if (useE && E.IsReady())
                if (E.Cast(t, false, true) == LeagueSharp.Common.Spell.CastStates.SuccessfullyCasted)
                    return;

            if (useR && R1.IsReady() && ObjectManager.Player.Spellbook.GetSpell(SpellSlot.R).Ammo > rLim)
            {
                if (HasBigRocket())
                {
                    R2.Cast(t, false, true);
                }
                else
                {
                    R1.Cast(t, false, true);
                }
            }
        }
예제 #14
0
 private static void AfterAttack(AfterAttackArgs args)
 {
 }
예제 #15
0
        private static void Orbwalking_AfterAttack(AfterAttackArgs args)
        {
            var mana = _player.ManaPercent > getSliderItem(harassMenu, "Harrasmana");
            if (args.Target.IsMe)
                if (args.Target.Type == GameObjectType.AIHeroClient)
                {
                    if (PortAIO.OrbwalkerManager.isComboActive
                        || (PortAIO.OrbwalkerManager.isHarassActive && mana))
                    {
                        var useQ = getCheckBoxItem(comboMenu, "UseQC") || getCheckBoxItem(harassMenu, "UseQH");
                        var useW = getCheckBoxItem(comboMenu, "UseWC") || getCheckBoxItem(harassMenu, "UseWH");
                        if (useQ && _q.IsReady())
                        {
                            var t = TargetSelector.GetTarget(_q.Range, DamageType.Physical);
                            if (t.LSIsValidTarget(_q.Range - 70)) _q.CastIfHitchanceEquals(t, HitChance.High, true);
                        }

                        if (useW && _w.IsReady())
                        {
                            var t = TargetSelector.GetTarget(_w.Range, DamageType.Magical);
                            if (t.LSIsValidTarget(_w.Range)) _w.CastIfHitchanceEquals(t, HitChance.High, true);
                        }
                    }

                    var useE = getCheckBoxItem(comboMenu, "UseEC");
                    var ta = TargetSelector.GetTarget(700, DamageType.Magical);
                    if (PortAIO.OrbwalkerManager.isComboActive && _e.IsReady())
                    {
                        if (ObjectManager.Player.Position.LSExtend(Game.CursorPos, 700).CountEnemiesInRange(700) <= 1
                            && useE)
                        {
                            if (!ta.UnderTurret()) _e.Cast(ObjectManager.Player.Position.LSExtend(Game.CursorPos, 450));
                            else if (ta.UnderTurret() && _e.IsReady() && ta.LSIsValidTarget()
                                     && _q.ManaCost + _e.ManaCost < _player.Mana)
                                if (ta.Health < _q.GetDamage(ta) && ta.LSIsValidTarget())
                                {
                                    _e.Cast(ObjectManager.Player.Position.LSExtend(Game.CursorPos, 450));
                                    _q.CastIfHitchanceEquals(ta, HitChance.High, true);
                                }
                        }

                        var useEreload = getCheckBoxItem(comboMenu, "UseEreload");;
                        if (!_player.HasBuff("GravesBasicAttackAmmo2") && _e.IsReady() && useEreload)
                        {
                            var direction = (Game.CursorPos - _player.ServerPosition).LSTo2D().Normalized();
                            for (var step = 0f; step < 360; step += 30)
                            {
                                for (var a = 450; a > 0; a -= 50)
                                {
                                    var currentAngle = step * (float)Math.PI / 90;
                                    var currentCheckPoint = _player.ServerPosition.LSTo2D()
                                                            + a * direction.Rotated(currentAngle);
                                    if (currentCheckPoint.To3D().UnderTurret(true) || currentCheckPoint.To3D().IsWall())
                                    {
                                        return;
                                    }

                                    _e.Cast((Vector3)currentCheckPoint);
                                }
                            }
                        }
                    }
                }
        }
예제 #16
0
        public override void Orbwalking_AfterAttack(AfterAttackArgs args)
        {
            var t = args.Target as AIHeroClient;
            if (t != null && (ComboActive || HarassActive))
            {
                var useQ = ComboActive ? Program.combo["UseQC"].Cast<CheckBox>().CurrentValue : Program.harass["UseQH"].Cast<CheckBox>().CurrentValue;

                if (useQ && Q.IsReady())
                    Q.CastOnUnit(t);
            }
        }
예제 #17
0
        public override void Orbwalking_AfterAttack(AfterAttackArgs args)
        {
            var target = args.Target;
            if (target != null && (!ComboActive && !HarassActive) || !(target is AIHeroClient))
            {
                return;
            }

            var t = (AIHeroClient)target;
            var useW = ComboActive ? Program.combo["UseWC"].Cast<CheckBox>().CurrentValue : Program.harass["UseWH"].Cast<CheckBox>().CurrentValue;
            var useE = ComboActive ? Program.combo["UseEC"].Cast<CheckBox>().CurrentValue : Program.harass["UseEH"].Cast<CheckBox>().CurrentValue;

            if (useW && W.IsReady())
                W.Cast();

            if (useE && E.IsReady())
            {
                CastE(t);
            }
            //if (E.Cast(t, false, true) == Spell.CastStates.SuccessfullyCasted)
            //  return;
        }
예제 #18
0
 private static void Orbwalking_AfterAttackNoTarget(AfterAttackArgs args)
 {
     if (PortAIO.OrbwalkerManager.isComboActive || OrbwalkerPassive || OrbwalkLastClickActive)
     {
         if (Ecombo && E.IsReady() && Player.CountEnemiesInRange(Player.AttackRange + 200) >= 1)
         {
             E.Cast();
         }
         else if (HasItem() && Player.CountEnemiesInRange(Player.AttackRange + 200) >= 1)
         {
             CastItem();
         }
     }
     if (PortAIO.OrbwalkerManager.isHarassActive)
     {
         if (Eharass && E.IsReady() && Player.ManaPercent >= Manaharass
             && Player.CountEnemiesInRange(Player.AttackRange + 200) >= 1)
         {
             E.Cast();
         }
         else if (HasItem() && Player.CountEnemiesInRange(Player.AttackRange + 200) >= 1)
         {
             CastItem();
         }
     }
     if (PortAIO.OrbwalkerManager.isLaneClearActive)
     {
         // jungclear
         if (EJclear && E.IsReady() && Player.Mana * 100 / Player.MaxMana >= ManaJclear && !PortAIO.OrbwalkerManager.ShouldWait()
             && Player.Position.CountMinionsInRange(Player.AttackRange + 200, true) >= 1)
         {
             E.Cast();
         }
         else if (TimatJClear && HasItem() && !PortAIO.OrbwalkerManager.ShouldWait()
             && Player.Position.CountMinionsInRange(Player.AttackRange + 200, true) >= 1)
         {
             CastItem();
         }
         // laneclear
         if (ELclear && E.IsReady() && Player.Mana * 100 / Player.MaxMana >= ManaLclear && !PortAIO.OrbwalkerManager.ShouldWait()
             && Player.Position.CountMinionsInRange(Player.AttackRange + 200, false) >= 1)
         {
             E.Cast();
         }
         else if (TimatLClear && HasItem() && !PortAIO.OrbwalkerManager.ShouldWait()
             && Player.Position.CountMinionsInRange(Player.AttackRange + 200, false) >= 1)
         {
             CastItem();
         }
     }
 }
예제 #19
0
 private static void afterAttack(AfterAttackArgs args)
 {
     if (W.IsReady() && getCheckBoxItem(wMenu, "wPush") && args.Target.IsValid<Obj_AI_Turret>() && Player.Mana > RMANA + EMANA + QMANA + WMANA + WMANA + RMANA)
     {
         foreach (var ally in Program.Allies)
         {
             if (!ally.IsMe && ally.IsAlly && ally.LSDistance(Player.Position) < 600)
                 W.Cast(ally);
         }
     }
 }
예제 #20
0
 private static void afterAttack(AfterAttackArgs args)
 {
     if (getCheckBoxItem(rMenu, "afterAA") && R.IsReady() && args.Target is AIHeroClient)
     {
         R.Cast();
     }
 }
예제 #21
0
 private static void Orbwalking_AfterAttack(AfterAttackArgs args)
 {
     var target = args.Target;
     if (!BadaoPoppyHelper.AssasinateActive())
         return;
     if (target.Position.LSDistance(ObjectManager.Player.Position) <= 200 + 125 + 140)
         BadaoChecker.BadaoUseTiamat();
 }
예제 #22
0
        private static void OrbwalkingOnAfterAttack(AfterAttackArgs args)
        {
            var target = args.Target;
            if (!(target is AIHeroClient))
            {
                return;
            }

            if (!target.LSIsValidTarget())
            {
                return;
            }

            if (Hydra.IsReady())
            {
                Hydra.Cast();
            }
            else if (Tiamat.IsReady())
            {
                Tiamat.Cast();
            }
        }
예제 #23
0
        public static void Orbwalking_AfterAttack(AfterAttackArgs args)
        {
            var target = args.Target;
            if ((PortAIO.OrbwalkerManager.isLaneClearActive) && 100 * (Player.Mana / Player.MaxMana) > getSliderItem(qmenu, "Junglemana"))
            {
                var mob = MinionManager.GetMinions(Player.ServerPosition, E.Range, MinionTypes.All, MinionTeam.Neutral, MinionOrderTypes.MaxHealth).FirstOrDefault();
                var Minions = MinionManager.GetMinions(Player.Position.LSExtend(Game.CursorPos, Q.Range), Player.AttackRange, MinionTypes.All);
                var useQ = getCheckBoxItem(qmenu, "UseQJ");
                int countMinions = 0;

                foreach (var minions in Minions.Where(minion => minion.Health < Player.LSGetAutoAttackDamage(minion) || minion.Health < Q.GetDamage(minion) + Player.LSGetAutoAttackDamage(minion) || minion.Health < Q.GetDamage(minion)))
                {
                    countMinions++;
                }

                if (countMinions >= 2 && useQ && Q.IsReady() && Minions != null)
                    Q.Cast(Player.Position.LSExtend(Game.CursorPos, Q.Range / 2));

                if (useQ && Q.IsReady() && Orbwalking.InAutoAttackRange(mob) && mob != null)
                {
                    Q.Cast(Game.CursorPos);
                }
            }

            if (!(target is AIHeroClient)) return;

            tar = (AIHeroClient)target;

            if (getKeyBindItem(menu, "aaqaa"))
            {
                if (Q.IsReady())
                {
                    Q.Cast(Game.CursorPos);
                }

                PortAIO.OrbwalkerManager.MoveA(Game.CursorPos);
            }

            if (getKeyBindItem(emenu, "UseEaa"))
            {
                E.Cast((Obj_AI_Base)target);
                emenu["UseEaa"].Cast<KeyBind>().CurrentValue = !getCheckBoxItem(emenu, "UseEaa");
            }

            if (Q.IsReady() && ((PortAIO.OrbwalkerManager.isComboActive && getCheckBoxItem(qmenu, "UseQC")) || (PortAIO.OrbwalkerManager.isHarassActive && getCheckBoxItem(qmenu, "hq"))))
            {
                if (getCheckBoxItem(qmenu, "restrictq"))
                {
                    var after = ObjectManager.Player.Position + Normalize(Game.CursorPos - ObjectManager.Player.Position) * 300;
                    var disafter = Vector3.DistanceSquared(after, tar.Position);
                    if ((disafter < 630 * 630) && disafter > 150 * 150)
                    {
                        Q.Cast(Game.CursorPos);
                    }

                    if (Vector3.DistanceSquared(tar.Position, ObjectManager.Player.Position) > 630 * 630 && disafter < 630 * 630)
                    {
                        Q.Cast(Game.CursorPos);
                    }
                }
                else
                {
                    Q.Cast(Game.CursorPos);
                }
            }
        }
예제 #24
0
        public override void Orbwalking_AfterAttack(AfterAttackArgs args)
        {
            var target = args.Target;
            var t = target as AIHeroClient;
            if (t == null || (!ComboActive && !HarassActive)) return;

            if (Q.IsReady() && ComboActive ? Program.combo["UseQC"].Cast<CheckBox>().CurrentValue : Program.harass["UseQH"].Cast<CheckBox>().CurrentValue)
                Q.Cast(t, false, true);
        }
예제 #25
0
 public override void Orbwalking_AfterAttack(AfterAttackArgs args)
 {
     Console.WriteLine("Hai");
     Console.WriteLine(Program.misc["maxqamount"].Cast<Slider>().CurrentValue);
     var qOnHero = QBuffCount();
     if (((ComboActive && Program.combo["UseQC"].Cast<CheckBox>().CurrentValue) ||
          (HarassActive && Program.harass["UseQH"].Cast<CheckBox>().CurrentValue)) && qOnHero < 2 &&
         qOnHero + ExistingReticles.Count < Program.misc["maxqamount"].Cast<Slider>().CurrentValue)
     {
         Q.Cast();
         Console.WriteLine("Casted Q");
     }
 }
예제 #26
0
        public static void Orbwalker_AfterAttack(AfterAttackArgs args)
        {
            var target = args.Target;
            if (target.Type != GameObjectType.AIHeroClient)
                return;

            if (Program.Combo && Player.Mana > RMANA + QMANA && Q.IsReady() && getCheckBoxItem(qMenu, "autoQ"))
            {
                var t = target as AIHeroClient;
                if (t.LSIsValidTarget())
                {
                    var dashPos = Dash.CastDash();
                    if (!dashPos.IsZero && dashPos.CountEnemiesInRange(500) > 0)
                    {
                        Q.Cast(dashPos);
                    }
                }
            }
        }
예제 #27
0
 public override void Orbwalking_AfterAttack(AfterAttackArgs args)
 {
     /*
     if (PortAIO.OrbwalkerManager.isComboActive && Program.combo["Combo.UseQ"].Cast<CheckBox>().CurrentValue && Q.IsReady())
     {
         var enemy = target as AIHeroClient;
         if (enemy != null)
         {
             if (ObjectManager.Player.TotalAttackDamage < enemy.Health + enemy.AllShield)
             {
                 Q.Cast(enemy);
             }
         }
     }
     */
 }
예제 #28
0
        private static void Orbwalker_OnPostAttack(AfterAttackArgs args)
        {
            if (MasterYi.W.IsReady() && getCheckBoxItem(comboMenu, "comboWreset") && getSliderItem(evadeMenu, "useWatHP") >= MasterYi.player.HealthPercent && args.Target is AIHeroClient && PortAIO.OrbwalkerManager.isComboActive)
            {
                var dmg = ObjectManager.Player.GetAutoAttackDamage(args.Target as AIHeroClient);
                var howmanyautos = (int)args.Target.Health / dmg;

                if (howmanyautos <= 3 && howmanyautos > 0 && getCheckBoxItem(comboMenu, "wSmart"))
                {
                    MasterYi.W.Cast();
                    Utility.DelayAction.Add(100,
                        () =>
                        {
                            PortAIO.OrbwalkerManager.ResetAutoAttackTimer();
                            PortAIO.OrbwalkerManager.SetMovement(true);
                            PortAIO.OrbwalkerManager.MoveA(Game.CursorPos);
                            Player.IssueOrder(GameObjectOrder.MoveTo, Game.CursorPos);
                        }
                        );
                }
                else
                {
                    MasterYi.W.Cast();
                    Utility.DelayAction.Add(100,
                        () =>
                        {
                            PortAIO.OrbwalkerManager.ResetAutoAttackTimer();
                            PortAIO.OrbwalkerManager.SetMovement(true);
                            PortAIO.OrbwalkerManager.MoveA(Game.CursorPos);
                            Player.IssueOrder(GameObjectOrder.MoveTo, Game.CursorPos);
                        }
                        );
                }
            }
        }
예제 #29
0
 private static void OnAfterAttack(AfterAttackArgs args)
 {
     var target = args.Target;
     var combo = PortAIO.OrbwalkerManager.isComboActive;
     var Q = getCheckBoxItem(comboMenu, "UseQC");
     if (!target.IsMe) return;
     if (combo && _q.IsReady() && Q && target.LSIsValidTarget(_q.Range))
     {
         _q.Cast();
     }
 }
예제 #30
0
        private static void AfterAttack(AfterAttackArgs args)
        {
            #region After attack

            if (!Player.IsMiniGnar())
                return;

            var targets = TargetSelector.GetTarget(GnarSpells.QMini.Range, DamageType.Physical);
            if (Player.LSDistance(args.Target) <= 450)
            {
                if (GnarSpells.QnMini.IsReady())
                    GnarSpells.QnMini.Cast(targets);
            }

            #endregion
        }
예제 #31
0
 /// <summary>
 ///     The AfterAttack event which called by orbwalker.
 /// </summary>
 /// <param name="args">The args.</param>
 protected virtual void OrbwalkingEvents_AfterAttack(AfterAttackArgs args)
 {
     //
 }