Beispiel #1
0
        private static void BeforeAuto(BeforeAttackArgs args)
        {
            if (!CassioUtils.getCheckBoxItem(CassiopeiaMenu.Combo, "Combo.Useauto") && PortAIO.OrbwalkerManager.isComboActive)
            {
                args.Process = false;
                return;

            }
            if (CassioUtils.getCheckBoxItem(CassiopeiaMenu.Combo, "Combo.Disableautoifspellsready") && PortAIO.OrbwalkerManager.isComboActive)
            {
                if (SpellSlot.Q.IsReady() || SpellSlot.W.IsReady() || SpellSlot.E.IsReady() || SpellSlot.R.IsReady())
                {
                    args.Process = false;
                    return;
                }
            }
            if (!CassioUtils.getCheckBoxItem(CassiopeiaMenu.Waveclear, "Waveclear.Useauto") && PortAIO.OrbwalkerManager.isLaneClearActive)
            {
                args.Process = false;
                return;
            }
            if (!CassioUtils.getCheckBoxItem(CassiopeiaMenu.Farm, "Farm.Useauto") && (PortAIO.OrbwalkerManager.isHarassActive || PortAIO.OrbwalkerManager.isLastHitActive))
            {
                args.Process = false;
                return;
            }


        }
        /// <summary>
        /// Invokes before attack event
        /// </summary>
        /// <param name="instance">Orbwalker instance</param>
        /// <param name="target">Target</param>
        /// <returns></returns>
        public static BeforeAttackArgs FireBeforeAttack(LSOrbwalker instance, AttackableUnit target)
        {
            BeforeAttackArgs args = new BeforeAttackArgs();
            args.Instance = instance;
            args.Target = target;

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

            return args;
        }
Beispiel #3
0
        private void OW(BeforeAttackArgs args)
        {
            if (ShouldGetExecuted() && ObjectManager.Player.Buffs.Any(m => m.Name.ToLower() == "vaynetumblefade"))
            {
                if (ObjectManager.Player.CountEnemiesInRange(1100f) <= 1
                    || ObjectManager.Player.CountEnemiesInRange(1100f) < MenuGenerator.miscMenu["dz191.vhr.misc.tumble.noaa.enemies"].Cast<Slider>().CurrentValue || ObjectManager.Player.HealthPercent > MenuGenerator.miscMenu["dz191.vhr.misc.tumble.noaastealthex.hp"].Cast<Slider>().CurrentValue)
                {
                    return;
                }

                args.Process = false;
            }
        }
        /// <summary>
        /// Invokes before attack event
        /// </summary>
        /// <param name="instance">Orbwalker instance</param>
        /// <param name="target">Target</param>
        /// <returns></returns>
        public static BeforeAttackArgs FireBeforeAttack(LSOrbwalker instance, AttackableUnit target)
        {
            BeforeAttackArgs args = new BeforeAttackArgs();

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

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

            return(args);
        }
Beispiel #5
0
        private void iJava(BeforeAttackArgs args)
        {
            if (!ShouldGetExecuted() || !args.Target.IsEnemy)
                return;

            if (Player.HasBuff("vaynetumblefade"))
            {
                var stealthtime = MenuGenerator.miscMenu["dz191.vhr.misc.tumble.noaastealth.duration"].Cast<Slider>().CurrentValue;
                var stealthbuff = Player.GetBuff("vaynetumblefade");
                if (stealthbuff.EndTime - Game.Time > stealthbuff.EndTime - stealthbuff.StartTime - stealthtime / 1000f)
                {
                    args.Process = false;
                }
            }
            else
            {
                args.Process = true;
            }
        }
Beispiel #6
0
 private static void OrbwalkingOnBeforeAttack(BeforeAttackArgs args)
 {
     if (args.Target is AIHeroClient)
         args.Process = CardSelector.Status != SelectStatus.Selecting &&
                        Utils.TickCount - CardSelector.LastWSent > 300;
 }
Beispiel #7
0
 /// <summary>
 ///     The BeforeAttack event which called by orbwalker.
 /// </summary>
 /// <param name="args">The args.</param>
 protected virtual void OrbwalkingEvents_BeforeAttack(BeforeAttackArgs args)
 {
     //
 }
Beispiel #8
0
        private void Orbwalker_OnPreAttack(BeforeAttackArgs args)
        {
            if (args.Process)
            {
                IsWindingUp = true;
            }
            else
            {
                IsWindingUp = false;
            }
            if (R.IsReady() && Orbwalker.ActiveMode == LSOrbwalker.OrbwalkingMode.Combo && UseRBool && args.Target is EloBuddy.AIHeroClient && (!(args.Target as EloBuddy.AIHeroClient).IsUnderEnemyTurret() || EloBuddy.ObjectManager.Player.IsUnderEnemyTurret()) && EloBuddy.ObjectManager.Player.CountAllyHeroesInRange(800) >= EloBuddy.ObjectManager.Player.CountEnemyHeroesInRange(800))
            {
                R.Cast();
            }
            var possible2WTarget = ValidTargets.FirstOrDefault(
                h =>
                    h.ServerPosition.Distance(EloBuddy.ObjectManager.Player.ServerPosition) < 500 &&
                    h.GetBuffCount("vaynesilvereddebuff") == 2);
            if (TryToFocus2WBool && possible2WTarget.LSIsValidTarget())
            {
                Orbwalker.ForceTarget(possible2WTarget);
            }
            if (EloBuddy.ObjectManager.Player.HasBuff("vaynetumblefade") && DontAttackWhileInvisibleAndMeelesNearBool)
            {
                if (
                    ValidTargets.Any(
                        e => e.ServerPosition.Distance(EloBuddy.ObjectManager.Player.ServerPosition) < 350 && e.IsMelee))
                {
                    args.Process = false;
                }
            }
            var possibleTarget = TargetSelector.GetTarget(615, EloBuddy.DamageType.Physical);
            if (possibleTarget != null && args.Target is EloBuddy.Obj_AI_Minion &&
                UseQBonusOnEnemiesNotCS && EloBuddy.ObjectManager.Player.HasBuff("vaynetumblebonus"))
            {
                Orbwalker.ForceTarget(possibleTarget);
                args.Process = false;
            }
            var possibleNearbyMeleeChampion =
                ValidTargets.FirstOrDefault(
                    e => e.ServerPosition.Distance(EloBuddy.ObjectManager.Player.ServerPosition) < 350);

            if (possibleNearbyMeleeChampion.LSIsValidTarget())
            {
                if (Q.IsReady() && UseQBool)
                {
                    var pos = EloBuddy.ObjectManager.Player.ServerPosition.LSExtend(possibleNearbyMeleeChampion.ServerPosition,
                        -350);
                    if (!IsDangerousPosition(pos))
                    {
                        Q.Cast(pos);
                        args.Process = false;
                    }
                }
                if (UseEWhenMeleesNearBool && !Q.IsReady() && E.IsReady())
                {
                    var possibleMeleeChampionsGapclosers = from tuplet in CachedGapclosers
                                                           where tuplet.Item1 == possibleNearbyMeleeChampion.CharData.BaseSkinName
                                                           select tuplet.Item2;
                    if (possibleMeleeChampionsGapclosers.FirstOrDefault() != null)
                    {
                        if (
                            possibleMeleeChampionsGapclosers.Any(
                                gapcloserEntry =>
                                    possibleNearbyMeleeChampion.Spellbook.GetSpell(gapcloserEntry.Slot).IsReady()))
                        {
                            return;
                        }
                    }
                    if (
                        LeagueSharp.SDK.Core.Utils.MathUtils.GetWaypoints(possibleNearbyMeleeChampion)
                            .LastOrDefault()
                            .Distance(EloBuddy.ObjectManager.Player.ServerPosition) < possibleNearbyMeleeChampion.AttackRange)
                    {
                        if (EDelaySlider > 0)
                        {
                            var thisEnemy = possibleNearbyMeleeChampion;
                            LeagueSharp.SDK.Core.Utils.DelayAction.Add(EDelaySlider, () => E.CastOnUnit(thisEnemy));
                            return;
                        }
                        E.CastOnUnit(possibleNearbyMeleeChampion);
                    }
                }
            }
        }
Beispiel #9
0
        private static void OnBeforeAttack(BeforeAttackArgs args)
        {
            var combo = PortAIO.OrbwalkerManager.isComboActive;
            var harass = PortAIO.OrbwalkerManager.isHarassActive;
            var QC = getCheckBoxItem(comboMenu, "UseQC");
            var QH = getCheckBoxItem(harassMenu, "UseQH");
            var mode = getBoxItem(comboMenu, "ComboPrio") == 0
                       || getBoxItem(comboMenu, "ComboPrio") == 2;
            if (!(args.Target is AIHeroClient))
            {
                return;
            }

            if (_player.HasBuff("rengarpassivebuff") || _player.HasBuff("RengarR"))
            {
                return;
            }

            if (_player.Mana <= 4)
            {
                if (combo && QC && _q.IsReady() && Orbwalking.InAutoAttackRange(args.Target)
                    && args.Target.LSIsValidTarget(_q.Range))
                {
                    _q.Cast();
                }

                if (harass && QH && _q.IsReady() && Orbwalking.InAutoAttackRange(args.Target)
                    && args.Target.LSIsValidTarget(_q.Range))
                {
                    _q.Cast();
                }
            }

            if (_player.Mana == 5)
            {
                if (combo && QC && _q.IsReady() && Orbwalking.InAutoAttackRange(args.Target) && mode
                    && args.Target.LSIsValidTarget(_q.Range))
                {
                    _q.Cast();
                }

                if (harass && QH && _q.IsReady() && Orbwalking.InAutoAttackRange(args.Target) && mode
                    && args.Target.LSIsValidTarget(_q.Range))
                {
                    _q.Cast();
                }
            }
        }
Beispiel #10
0
        private static void Orbwalker_OnPreAttack(BeforeAttackArgs args)
        {
            _axeDropObjectDataList.RemoveAll(x => !x.Object.IsValid);

            if (PortAIO.OrbwalkerManager.isComboActive)
            {
                if (args.Target.Type == GameObjectType.AIHeroClient)
                {
                    if (useQ)
                    {
                        if (AxeCount < 2)
                        {
                            if (Q.IsReady())
                            {
                                Q.Cast();
                            }
                        }
                    }
                }
            }
            else if (PortAIO.OrbwalkerManager.isHarassActive)
            {
                if (useQH)
                {
                    if (myHero.IsManaPercentOkay(manaH))
                    {
                        if (AxeCount < 2)
                        {
                            if (Q.IsReady())
                            {
                                Q.Cast();
                            }
                        }
                    }
                }
            }
            else if (PortAIO.OrbwalkerManager.isLaneClearActive)
            {
                if (EntityManager.MinionsAndMonsters.GetLaneMinions().Any(x => x.NetworkId == args.Target.NetworkId))
                {
                    if (useQLC)
                    {
                        if (myHero.IsManaPercentOkay(manaLC))
                        {
                            if (AxeCount < 2)
                            {
                                if (Q.IsReady())
                                {
                                    Q.Cast();
                                }
                            }
                        }
                    }
                }

                if (
                    EntityManager.MinionsAndMonsters.GetJungleMonsters()
                        .Any(x => x.NetworkId == args.Target.NetworkId))
                {
                    if (useQJG)
                    {
                        if (myHero.IsManaPercentOkay(manaJG))
                        {
                            if (AxeCount < 2)
                            {
                                if (Q.IsReady())
                                {
                                    Q.Cast();
                                }
                            }
                        }
                    }
                }
            }
        }
Beispiel #11
0
        private void Orbwalker_OnPreAttack(BeforeAttackArgs args)
        {
            if (PortAIO.OrbwalkerManager.isLaneClearActive)
            {
                var minion = args.Target as Obj_AI_Minion;
                AttackingToMinion = minion != null;

                if (minion != null)
                {
                    TargetMinionNetworkId = minion.NetworkId;
                    AttackingToSiegeMinion = minion.BaseSkinName == "SRU_ChaosMinionSiege" ||
                                             minion.BaseSkinName == "SRU_ChaosMinionSuper";
                }
            }
        }
Beispiel #12
0
 private static void BeforeAttack(BeforeAttackArgs args)
 {
     LogicQ();
 }
Beispiel #13
0
 private static void BeforeAttack(BeforeAttackArgs args)
 {
     if (getCheckBoxItem(comboMenu, "combo.w") &&
         PortAIO.OrbwalkerManager.isComboActive &&
         args.Target != null &&
         args.Target.Type == GameObjectType.AIHeroClient &&
         args.Target.LSIsValidTarget() ||
         getCheckBoxItem(harassMenu, "harass.w") &&
         PortAIO.OrbwalkerManager.isHarassActive &&
         args.Target != null &&
         args.Target.Type == GameObjectType.AIHeroClient &&
         args.Target.LSIsValidTarget())
         Spells.W.Cast();
 }
Beispiel #14
0
 /// <summary>
 /// </summary>
 /// <param name="args"></param>
 private static void OrbwalkingBeforeAttack(BeforeAttackArgs args)
 {
     if (getCheckBoxItem(miscMenu, "AA.Block") && PortAIO.OrbwalkerManager.isComboActive)
     {
         args.Process = false;
     }
     else
     {
         if (PortAIO.OrbwalkerManager.isComboActive)
         {
             args.Process = !(Q.IsReady() || Player.LSDistance(args.Target) >= 1000);
         }
     }
 }
Beispiel #15
0
 private static void Orbwalker_OnPreAttack(BeforeAttackArgs args)
 {
     if (getCheckBoxItem(SupportConfig, "SupportMode")
         && GetAdc(getSliderItem(SupportConfig, "SupportModeRange")) != null
         && (PortAIO.OrbwalkerManager.isHarassActive || PortAIO.OrbwalkerManager.isLaneClearActive || PortAIO.OrbwalkerManager.isLastHitActive))
     {
         args.Process = false;
     }
 }
Beispiel #16
0
 private void Orbwalking_BeforeAttack(BeforeAttackArgs args)
 {
     if (PortAIO.OrbwalkerManager.isComboActive)
     {
         args.Process = !_spellQ.IsReady();
     }
     else if (PortAIO.OrbwalkerManager.isLastHitActive)
     {
         bool farmQ = getBoxItem(farmMenu, "farmQ") == 0 ||
                      getBoxItem(farmMenu, "farmQ") == 2;
         args.Process =
             !(farmQ && _spellQ.IsReady() &&
               GetManaPercent() >= getSliderItem(farmMenu, "farmQPercent"));
     }
 }
Beispiel #17
0
        private static void Orbwalking_BeforeAttack(BeforeAttackArgs args)
        {
            if (getCheckBoxItem(exmenu, "supp"))
            {
                if (PortAIO.OrbwalkerManager.isHarassActive ||
                    PortAIO.OrbwalkerManager.isLastHitActive)
                {
                    var minion = args.Target as Obj_AI_Base;
                    if (minion != null && minion.IsMinion && minion.LSIsValidTarget())
                    {
                        if (HeroManager.Allies.Any(x => x.LSIsValidTarget(1000, false) && !x.IsMe))
                        {
                            if (Player.HasBuff("talentreaperdisplay"))
                            {
                                var b = Player.GetBuff("talentreaperdisplay");
                                if (b.Count > 0)
                                {
                                    args.Process = true;
                                    return;
                                }
                            }

                            args.Process = false;
                        }
                    }
                }
            }
        }
Beispiel #18
0
 public static void OnAttack(BeforeAttackArgs args)
 {
     if (PortAIO.OrbwalkerManager.isComboActive)
     {
         if (ItemData.Youmuus_Ghostblade.GetItem().IsReady())
             ItemData.Youmuus_Ghostblade.GetItem().Cast();
     }
 }
Beispiel #19
0
 private static void Orbwalking_BeforeAttack(BeforeAttackArgs args)
 {
     ChampionClass.Orbwalking_BeforeAttack(args);
 }
Beispiel #20
0
 public virtual void Orbwalking_BeforeAttack(BeforeAttackArgs args)
 {
 }
Beispiel #21
0
        /// <summary>
        ///     Called before the orbwalker attacks a unit.
        /// </summary>
        /// <param name="args">The <see cref="Orbwalking.BeforeAttackEventArgs" /> instance containing the event data.</param>
        private static void OrbwalkingOnBeforeAttack(BeforeAttackArgs args)
        {
            if (args.Target.IsValid<Obj_AI_Minion>() &&
                (PortAIO.OrbwalkerManager.isHarassActive ||
                PortAIO.OrbwalkerManager.isLastHitActive)
                && !getCheckBoxItem(miscMenu, "AttackMinions") && ObjectManager.Player.CountAlliesInRange(1200) > 0)
            {
                args.Process = false;
            }

            if (args.Target.IsValid<AIHeroClient>() && !getCheckBoxItem(miscMenu, "AttackChampions") && ObjectManager.Player.CountAlliesInRange(1000) > 0)
            {
                args.Process = false;
            }
        }
Beispiel #22
0
 private static void OnBeforeAttack(BeforeAttackArgs args)
 {
     if (args.Target.Type == GameObjectType.obj_AI_Minion &&
         PortAIO.OrbwalkerManager.isHarassActive &&
         getCheckBoxItem(miscMenu, "dz191.bard.misc.attackMinions"))
     {
         if (
             ObjectManager.Player.CountAlliesInRange(getSliderItem(miscMenu, "dz191.bard.misc.attackMinionsRange")) >
             0)
         {
             args.Process = false;
         }
     }
 }
Beispiel #23
0
 public override void Orbwalking_BeforeAttack(BeforeAttackArgs args)
 {
     args.Process = !Q.IsCharging;
 }
Beispiel #24
0
 private static void BeforeAttack(BeforeAttackArgs args)
 {
     if (E.IsReady() && args.Target.IsValid<AIHeroClient>() && getCheckBoxItem(weMenu, "autoE"))
         E.Cast();
 }
Beispiel #25
0
 private static void BeforeAttack(BeforeAttackArgs args)
 {
     attackNow = false;
 }
Beispiel #26
0
        private static void OrbwalkingBeforeAttack(BeforeAttackArgs args)
        {
            if (!(args.Target is AIHeroClient) || !PortAIO.OrbwalkerManager.isComboActive)
            {
                return;
            }

            if (Q.IsReady())
            {
                Q.Cast();
            }

            if (W.IsReady())
            {
                W.Cast();
            }
        }
Beispiel #27
0
        public override void Orbwalking_BeforeAttack(BeforeAttackArgs args)
        {
            if (!W.IsReady())
            {
                return;
            }

            if (Program.misc["Misc.UseW.Inhibitor"].Cast<CheckBox>().CurrentValue && args.Target is Obj_BarracksDampener)
            {
                W.Cast();
            }

            if (Program.misc["Misc.UseW.Nexus"].Cast<CheckBox>().CurrentValue && args.Target is Obj_HQ)
            {
                W.Cast();
            }

            if (Program.misc["Misc.UseW.Turret"].Cast<CheckBox>().CurrentValue && args.Target is Obj_AI_Turret)
            {
                W.Cast();
            }
        }
Beispiel #28
0
        private static void OrbwalkingOnBeforeAttack(BeforeAttackArgs args)
        {
            if (!Common.CommonHelper.ShouldCastSpell(TargetSelector.GetTarget(Orbwalking.GetRealAutoAttackRange(null) + 65, DamageType.Physical)))
            {
                return;
            }

            if (!W.IsReady() || !PortAIO.OrbwalkerManager.isComboActive || getBoxItem(MenuLocal, "Combo.W") == 0)
            {
                return;
            }

            if (Common.CommonHelper.ShouldCastSpell((AIHeroClient)args.Target) && args.Target is AIHeroClient)
            {
                W.Cast();
            }
        }
Beispiel #29
0
        private static void Orbwalking_BeforeAttack(BeforeAttackArgs args)
        {
            if (AIOmode == 2)
                return;

            if (Combo && getCheckBoxItem("comboDisableMode"))
            {
                var t = (AIHeroClient)args.Target;
                if (4 * Player.LSGetAutoAttackDamage(t) < t.Health - OktwCommon.GetIncomingDamage(t) &&
                    !t.HasBuff("luxilluminatingfraulein") && !Player.HasBuff("sheen") && !Player.HasBuff("Mastery6261"))
                    args.Process = false;
            }

            if (!Player.IsMelee && OktwCommon.CollisionYasuo(Player.ServerPosition, args.Target.Position) &&
                getCheckBoxItem("collAA"))
            {
                args.Process = false;
            }

            if (PortAIO.OrbwalkerManager.isHarassActive && getCheckBoxItem("supportMode"))
            {
                if (args.Target.Type == GameObjectType.obj_AI_Minion) args.Process = false;
            }
        }
Beispiel #30
0
        public static void Orbwalking_BeforeAttack(BeforeAttackArgs args)
        {
            try
            {

            }
            catch (Exception)
            {
                if (NowTime() > ErrorTime)
                {
                    Chat.Print(ChampName + " in FreshBooster isn't Load. Error Code 10");
                    ErrorTime = TickCount(10000);
                }
            }

        }
Beispiel #31
0
 private void Orbwalker_OnPreAttack(BeforeAttackArgs args)
 {
     if (getCheckBoxItem(miscMenu, "support"))
     {
         if (PortAIO.OrbwalkerManager.isHarassActive ||
             PortAIO.OrbwalkerManager.isLastHitActive)
         {
             var minion = args.Target as Obj_AI_Base;
             if (minion != null && minion.IsMinion && minion.LSIsValidTarget())
             {
                 if (HeroManager.Allies.Any(x => x.LSIsValidTarget(1000) && !x.IsMe))
                 {
                     args.Process = false;
                 }
             }
         }
     }
 }