示例#1
0
        private static void BeforeAttack(BeforeAttackEventArgs Args)
        {
            if (!Args.Unit.IsMe || Me.IsDead || Args.Target == null || Args.Target.ObjectType != GameObjectType.AIHeroClient)
            {
                return;
            }

            if (isComboMode)
            {
                if (ComboOption.UseQ && Q.IsReady() && AxeCount < ComboOption.GetSlider("MaxAxeCount"))
                {
                    var target = Args.Target as AIHeroClient;

                    if (target.IsValidTarget())
                    {
                        Q.Cast();
                    }
                }
            }
            else if (isHarassMode || isFarmMode && MyManaManager.SpellHarass)
            {
                if (HarassOption.HasEnouguMana)
                {
                    if (HarassOption.UseQ && Q.IsReady() && AxeCount < 2)
                    {
                        var target = Args.Target as AIHeroClient;

                        if (target.IsValidTarget())
                        {
                            Q.Cast();
                        }
                    }
                }
            }
        }
 private static void Orbwalker_OnBeforeAttack(object sender, BeforeAttackEventArgs e)
 {
     if (Player.HavePassive() && Variables.TickCount - Last_E >= 1000)
     {
         CanUseQNow = true;
     }
 }
示例#3
0
        private static void BeforeAttack(BeforeAttackEventArgs Args)
        {
            if (!Args.Unit.IsMe)
            {
                return;
            }

            if (MiscOption.GetBool("Forcus"))
            {
                if (isComboMode || isHarassMode)
                {
                    foreach (var enemy in ObjectManager.Heroes.Enemies.Where(x => !x.IsDead && !x.IsZombie && HavePassive(x)))
                    {
                        myOrbwalker.ForceTarget(enemy);
                    }
                }

                if (isLaneClearMode || isJungleClearMode)
                {
                    var all = MinionManager.GetMinions(Me.Position, Orbwalker.GetRealAutoAttackRange(Me),
                                                       MinionTypes.All, MinionTeam.NotAlly).Where(HavePassive).ToArray();

                    if (all.Any())
                    {
                        myOrbwalker.ForceTarget(all.FirstOrDefault());
                    }
                }
            }
        }
示例#4
0
        private static void BeforeAttack(BeforeAttackEventArgs Args)
        {
            if (MiscOption.GetBool("Forcus"))
            {
                if (isComboMode || isHarassMode)
                {
                    foreach (var target in ObjectManager.Heroes.Enemies.Where(x => !x.IsDead && !x.IsZombie &&
                                                                              Orbwalker.InAutoAttackRange(x) &&
                                                                              x.HasBuff("kalistacoopstrikemarkally"))
                             )
                    {
                        if (!target.IsDead && target.IsValidTarget(Orbwalker.GetRealAutoAttackRange(target)))
                        {
                            myOrbwalker.ForceTarget(target);
                        }
                    }
                }
                else if (isLaneClearMode || isJungleClearMode)
                {
                    var minion = MinionManager
                                 .GetMinions(Me.Position, Orbwalker.GetRealAutoAttackRange(Me),
                                             MinionTypes.All, MinionTeam.NotAlly)
                                 .FirstOrDefault(x => Orbwalker.InAutoAttackRange(x) && x.HasBuff("kalistacoopstrikemarkally"));

                    if (minion != null && minion.IsValidTarget(Orbwalker.GetRealAutoAttackRange(minion)))
                    {
                        myOrbwalker.ForceTarget(minion);
                    }
                }
            }
        }
示例#5
0
 private static void OnBeforeAttack(object sender, BeforeAttackEventArgs args)
 {
     if (Orbwalker.ActiveMode == OrbwalkerMode.Combo)
     {
         Combo.CastQ(args);
     }
 }
示例#6
0
        protected static bool ProcessBeforeAttack(IAttackable target)
        {
            var args = new BeforeAttackEventArgs(target);

            BeforeAttack.SafeInvoke(args);

            return(!args.IsBlocked);
        }
示例#7
0
        public bool Attack(BattleUnitsStack target)
        {
            if (_state != BattleState.InGame)
            {
                return(false);
            }

            var source = GetCurrentStack();

            if (source.GetArmy() == target.GetArmy())
            {
                return(false);
            }

            var hitPoints = DamageUtils.CalcDamageHitPoints(source, target);

            // Fire before attack event
            var beforeAttackEventArgs = new BeforeAttackEventArgs(source, target, hitPoints);

            EventBus.OnBeforeAttack(this, beforeAttackEventArgs);
            if (beforeAttackEventArgs.Cancel)
            {
                return(false);
            }

            hitPoints = beforeAttackEventArgs.HitPoints;

            target.Damage(hitPoints);

            // Fire after attack event
            EventBus.OnAfterAttack(this, new AfterAttackEventArgs(source, target, hitPoints));

            if (target.IsAlive() && !target.IsAnswered())
            {
                var answerHitPoints = DamageUtils.CalcDamageHitPoints(target, source);

                // Fire before answer event
                var beforeAnswerEventArgs = new BeforeAnswerEventArgs(source, target, answerHitPoints);
                EventBus.OnBeforeAnswer(this, beforeAnswerEventArgs);

                if (!beforeAnswerEventArgs.Cancel)
                {
                    answerHitPoints = beforeAnswerEventArgs.HitPoints;

                    source.Damage(answerHitPoints);
                    target.SetAnswered(beforeAnswerEventArgs.IsAnswered);

                    // Fire after answer event
                    EventBus.OnAfterAnswer(this,
                                           new AfterAnswerEventArgs(source, target, hitPoints, beforeAnswerEventArgs.IsAnswered));
                }
            }

            NextTurn();

            return(true);
        }
示例#8
0
        public static void CastW(BeforeAttackEventArgs args)
        {
            if (!ComboMenu.WBool.Enabled)
            {
                return;
            }

            W.Cast();
        }
示例#9
0
        private static void BeforeAttack(BeforeAttackEventArgs Args)
        {
            if (Me.IsDead)
            {
                return;
            }

            Args.Process = !Q.IsCharging;
        }
示例#10
0
        public static void CastQ(BeforeAttackEventArgs args)
        {
            if (ComboMenu.QList.Index != 0 || !Q.IsReady())
            {
                return;
            }

            Q.Cast();
        }
示例#11
0
        private static void OnBeforeAttack(object sender, BeforeAttackEventArgs e)
        {
            if (e.Target.GetType() != typeof(AIHeroClient) || Orbwalker.ActiveMode != OrbwalkerMode.Combo || !mainMenu.GetValue <MenuBool>("useQCombo").Enabled)
            {
                return;
            }

            if (Q.IsReady())
            {
                Q.Cast();
            }
        }
示例#12
0
        public static void CastE(BeforeAttackEventArgs args)
        {
            var target = args.Target as AIHeroClient;

            if (target == null)
            {
                return;
            }

            if (ComboMenu.EBool.Enabled)
            {
                E.CastOnUnit(target);
            }
        }
示例#13
0
        public static void CastQ(BeforeAttackEventArgs args)
        {
            var target = args.Target as AIHeroClient;

            if (target == null)
            {
                return;
            }

            if (ComboMenu.QBool.Enabled)
            {
                Q.Cast();
            }
        }
示例#14
0
        private static void CastE(BeforeAttackEventArgs args)
        {
            if (!StructureclearMenu.ESliderButton.Enabled)
            {
                return;
            }

            if (StructureclearMenu.ESliderButton.Value >= Player.ManaPercent)
            {
                return;
            }

            E.CastOnUnit(args.Target);
        }
示例#15
0
        public static void CastQ(BeforeAttackEventArgs args)
        {
            if (!JungleclearMenu.QSliderButton.Enabled)
            {
                return;
            }

            if (JungleclearMenu.QSliderButton.Value >= Player.ManaPercent)
            {
                return;
            }

            Q.CastOnUnit(args.Target);
        }
 private static void Orbwalker_OnBeforeAttack(object sender, BeforeAttackEventArgs e)
 {
     if (aaa == true)
     {
         aaa = false;
     }
     if (baa == false)
     {
         baa = true;
     }
     if (oaa == true)
     {
         oaa = false;
     }
 }
示例#17
0
        public static void CastQ(BeforeAttackEventArgs args)
        {
            var target = args.Target as AIBaseClient;

            if (!Extension.Has4Shot() || target.Health <= Player.GetAutoAttackDamage(target))
            {
                return;
            }

            if (!ComboMenu.QBool.Enabled)
            {
                return;
            }

            Q.CastOnUnit(target);
        }
示例#18
0
        private static void OnBeforeAttack(object sender, BeforeAttackEventArgs args)
        {
            Laneclear.CastQAOE();
            if (!Extension.ActivatedRockets)
            {
                return;
            }

            switch (args.Target)
            {
            case AITurretClient _:
            case AIMinionClient _ when  Orbwalker.ActiveMode == OrbwalkerMode.Harass:
                Q.Cast();
                break;
            }
        }
示例#19
0
        private static void OnBeforeAttack(object sender, BeforeAttackEventArgs args)
        {
            if (Extension.IsUltShooting())
            {
                args.Process = true;
            }

            switch (Orbwalker.ActiveMode)
            {
            case OrbwalkerMode.Combo:
                if (Q.IsReady())
                {
                    Extra.CastQ(args);
                }
                break;
            }
        }
示例#20
0
        private static void OnBeforeAA(object sender, BeforeAttackEventArgs args)
        {
            var target = TargetSelector.GetTarget(1000f);

            if (target != null)
            {
                if (Orbwalker.ActiveMode == OrbwalkerMode.Combo && (Q.IsReady() || W.IsReady()) && myhero.IsFacing(target) && myhero.InAutoAttackRange(target))
                {
                    args.Process = false;
                }

                if (Orbwalker.ActiveMode == OrbwalkerMode.LaneClear && Q.IsReady() && comb(laneclear, "lq") == 2)
                {
                    args.Process = false;
                }
            }
        }
示例#21
0
        public static void Cast(BeforeAttackEventArgs args)
        {
            if (StructureclearMenu.NoEnemiesRange.Enabled &&
                (Player.CountEnemyHeroesInRange(Player.GetRealAutoAttackRange()) >=
                 StructureclearMenu.NoEnemiesRange.Value))
            {
                return;
            }

            var turret = GameObjects.EnemyTurrets.FirstOrDefault(x => x.IsValidTarget(Player.GetRealAutoAttackRange()));

            if (turret == null)
            {
                return;
            }
            CastQ();
            CastE(args);
        }
示例#22
0
		public static void Before_Attack(BeforeAttackEventArgs ArgsTarget)
		{
			if (Orb.ActiveMode.Equals(Orbwalker.OrbwalkingMode.Combo) && ComboMenu.GetCheckbox("useW"))
			{
				W.Cast();
			}
			if (Orb.ActiveMode.Equals(Orbwalker.OrbwalkingMode.Harass) && HarassMenu.GetCheckbox("useW"))
			{
				W.Cast();
			}
			if (Orb.ActiveMode.Equals(Orbwalker.OrbwalkingMode.LaneClear) && LaneclearMenu.GetCheckbox("useW"))
			{
				W.Cast();
			}
			if (Orb.ActiveMode.Equals(Orbwalker.OrbwalkingMode.JungleClear) && JungleclearMenu.GetCheckbox("useW"))
			{
				W.Cast();
			}
		}
示例#23
0
        public static void CastQ(BeforeAttackEventArgs args)
        {
            if (!HarassMenu.QSliderButton.Enabled)
            {
                return;
            }

            if (HarassMenu.QSliderButton.Value >= Player.ManaPercent)
            {
                return;
            }

            var target = args.Target as AIHeroClient;

            if (target == null)
            {
                return;
            }

            Q.Cast();
        }
示例#24
0
        private static void BeforeAttack(BeforeAttackEventArgs Args)
        {
            if (!Args.Unit.IsMe)
            {
                return;
            }

            if (isComboMode || isHarassMode)
            {
                var ForcusTarget = ObjectManager.Heroes.Enemies.FirstOrDefault(x => x.IsValidTarget(Me.AttackRange + Me.BoundingRadius) && Has2WStacks(x));

                if (MiscOption.GetBool("ForcusAttack") && ForcusTarget != null && ForcusTarget.IsValidTarget(Me.AttackRange + Me.BoundingRadius - ForcusTarget.BoundingRadius + 15))
                {
                    myOrbwalker.ForceTarget(ForcusTarget);
                }
                else
                {
                    myOrbwalker.ForceTarget(null);
                }
            }
        }
示例#25
0
        private static void OnBeforeAA(object sender, BeforeAttackEventArgs args)
        {
            var target = TargetSelector.GetTarget(1000f);

            if (target != null)
            {
                if (Orbwalker.ActiveMode == OrbwalkerMode.Combo && (Q.IsReady() || W.IsReady()) && myhero.IsFacing(target) && target.InAARangeOf(myhero))
                {
                    args.Process = false;
                }

                if (Orbwalker.ActiveMode == OrbwalkerMode.LaneClear && Q.IsReady() && comb(laneclear, "lq") == 2 && myhero.ManaPercent >= slider(laneclear, "manamin"))
                {
                    args.Process = false;
                }
            }

            if (Orbwalker.ActiveMode == OrbwalkerMode.Combo && combo.check("cnaa"))
            {
                args.Process = false;
            }
        }
示例#26
0
        private static void BeforeAttack(BeforeAttackEventArgs Args)
        {
            if (!Args.Unit.IsMe || Me.IsDead || Args.Target == null || !Args.Target.IsValidTarget() || !isLaneClearMode)
            {
                return;
            }

            if (LaneClearOption.HasEnouguMana)
            {
                if (LaneClearOption.UseW && W.IsReady() && Me.CountEnemiesInRange(850) == 0)
                {
                    if (Args.Target.ObjectType == GameObjectType.obj_AI_Turret || Args.Target.ObjectType == GameObjectType.obj_Barracks ||
                        Args.Target.ObjectType == GameObjectType.obj_HQ || Args.Target.ObjectType == GameObjectType.obj_Turret ||
                        Args.Target.ObjectType == GameObjectType.obj_BarracksDampener)
                    {
                        if (W.IsReady() && Me.CountAlliesInRange(W.Range) >= 1)
                        {
                            W.Cast(ObjectManager.Heroes.Allies.Find(x => x.DistanceToPlayer() <= W.Range).Position, true);
                        }
                    }
                }
            }
        }
 private static void Orbwalker_OnBeforeAttack(object sender, BeforeAttackEventArgs e)
 {
     if (aaa == true)
     {
         aaa = false;
     }
     if (baa == false)
     {
         baa = true;
     }
     if (oaa == true)
     {
         oaa = false;
     }
     if (killminion == true)
     {
         killminion = false;
     }
     if (premove == true)
     {
         premove = false;
     }
 }
示例#28
0
        private static void BeforeAttack(BeforeAttackEventArgs Args)
        {
            if (!Args.Target.IsMe)
            {
                return;
            }

            if (isComboMode || isHarassMode)
            {
                var ForcusETarget =
                    ObjectManager.Heroes.Enemies.FirstOrDefault(
                        x =>
                        x.IsValidTarget(Orbwalker.GetRealAutoAttackRange(Me)) &&
                        x.HasBuff("kindredecharge"));

                var ForcusTarget =
                    ObjectManager.Heroes.Enemies.FirstOrDefault(
                        x =>
                        x.IsValidTarget(Orbwalker.GetRealAutoAttackRange(Me)) &&
                        x.HasBuff("kindredhittracker"));

                if (ForcusETarget.IsValidTarget(Orbwalker.GetRealAutoAttackRange(Me)) &&
                    MiscOption.GetBool("ForcusE"))
                {
                    myOrbwalker.ForceTarget(ForcusETarget);
                }
                else if (MiscOption.GetBool("Forcus") &&
                         ForcusTarget.IsValidTarget(Orbwalker.GetRealAutoAttackRange(Me)))
                {
                    myOrbwalker.ForceTarget(ForcusTarget);
                }
                else
                {
                    myOrbwalker.ForceTarget(null);
                }
            }
        }
示例#29
0
        public static void CastE(BeforeAttackEventArgs args)
        {
            if (!LaneclearMenu.ESliderButton.Enabled)
            {
                return;
            }

            if (LaneclearMenu.ESliderButton.Value >= Player.ManaPercent)
            {
                return;
            }

            var bestMinion = GameObjects.EnemyMinions.FirstOrDefault(x =>
                                                                     x.IsValidTarget(Player.GetRealAutoAttackRange()) &&
                                                                     CountInRange(x, 300, GameObjects.EnemyMinions) >=
                                                                     LaneclearMenu.EMinionSlider.Value);

            if (bestMinion == null)
            {
                return;
            }

            E.CastOnUnit(bestMinion);
        }
示例#30
0
        private static void BeforeAttack(BeforeAttackEventArgs Args)
        {
            if (!Args.Unit.IsMe)
            {
                return;
            }

            if (isComboMode)
            {
                if (MiscOption.GetBool("Forcustarget"))
                {
                    foreach (
                        var enemy in
                        ObjectManager.Heroes.Enemies.Where(
                            enemy => Orbwalker.InAutoAttackRange(enemy) && enemy.HasBuff("TristanaEChargeSound")))
                    {
                        myOrbwalker.ForceTarget(enemy);
                    }
                }

                if (ComboOption.UseQ && Q.IsReady())
                {
                    if (ComboOption.GetBool("ComboQAlways"))
                    {
                        var Target = Args.Target.ObjectType == GameObjectType.AIHeroClient
                            ? (AIHeroClient)Args.Target
                            : null;

                        if (Target != null &&
                            (Target.HasBuff("TristanaEChargeSound") || Target.HasBuff("TristanaECharge")))
                        {
                            Q.Cast();
                        }
                    }
                    else
                    {
                        Q.Cast();
                    }
                }
            }
            else if (isHarassMode)
            {
                if (MiscOption.GetBool("Forcustarget"))
                {
                    foreach (
                        var enemy in
                        ObjectManager.Heroes.Enemies.Where(
                            enemy => Orbwalker.InAutoAttackRange(enemy) && enemy.HasBuff("TristanaEChargeSound")))
                    {
                        myOrbwalker.ForceTarget(enemy);
                    }
                }
            }
            else if (isJungleClearMode && JungleClearOption.HasEnouguMana)
            {
                if (JungleClearOption.UseQ && Q.IsReady())
                {
                    var minion =
                        MinionManager.GetMinions(Orbwalker.GetRealAutoAttackRange(ObjectManager.Player),
                                                 MinionTypes.All, MinionTeam.Neutral, MinionOrderTypes.MaxHealth);

                    if (minion.Any(x => x.NetworkId == Args.Target.NetworkId))
                    {
                        Q.Cast();
                    }
                }
            }
        }
示例#31
0
 private static void Orbwalking_BeforeAttack(BeforeAttackEventArgs args)
 {
 }