public static void OnBeforeAttack(AttackableUnit target, Orbwalker.PreAttackArgs args)
{
if (args.Target is AIHeroClient)
{
args.Process = CardSelector.Status != SelectStatus.Selecting &&
Environment.TickCount - CardSelector.LastWSent > 300;
}
if (CardSelector.Status == SelectStatus.Selecting &&
((Config.IsChecked(Config.Combo, "disableAAselectingC") &&
Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo)) ||
(Config.IsChecked(Config.Harass, "disableAAselectingH") &&
Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Harass)) ||
(Config.IsChecked(Config.LaneClear, "disableAAselectingLC") &&
Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.LaneClear)) ||
(Config.IsChecked(Config.JungleClear, "disableAAselectingJC") &&
Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.JungleClear))))
{
args.Process = false;
}
}
internal static void Naoatacarminion(AttackableUnit target, Orbwalker.PreAttackArgs args)
{
if (target.Type == GameObjectType.obj_AI_Minion)
{
if (Fugir)
{
args.Process = false;
}
else
{
args.Process = !Utility["NaM"].Cast <CheckBox>().CurrentValue;
}
}
if (Multi["AtvSeg"].Cast <KeyBind>().CurrentValue&& target.Type == GameObjectType.AIHeroClient)
{
if (Eu.Distance(Tip) <= 890 || Fugir)
{
args.Process = false;
}
}
}
private static void Orbwalker_OnPreAttack(AttackableUnit target, Orbwalker.PreAttackArgs args)
{
if (!Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.LaneClear) &&
!Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.LastHit) &&
!Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.JungleClear))
{
return;
}
var t = target as Obj_AI_Minion;
if (t == null)
{
return;
}
{
if (MiscMenu["support"].Cast <CheckBox>().CurrentValue)
{
args.Process = false;
}
}
}
private static void beforeAttack(AttackableUnit target, Orbwalker.PreAttackArgs args)
{
if (W.IsReady() && Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo) &&
args.Target is AIHeroClient && checkFuryMode(SpellSlot.W, (Obj_AI_Base)args.Target) &&
getCheckBoxItem(comboMenu, "usew"))
{
if ((player.Mana > 40 && !fury) || (Q.IsReady() && canBeOpWIthQ(player.Position)))
{
return;
}
W.Cast();
return;
}
if (W.IsReady() && Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Harass) &&
getCheckBoxItem(harassMenu, "usewH") && args.Target is AIHeroClient &&
getBoxItem(harassMenu, "useCH") != 0)
{
W.Cast();
}
}
public override void Orbwalking_BeforeAttack(AttackableUnit target, Orbwalker.PreAttackArgs args)
{
if (!getCheckBoxItem(miscMenu, "Support") ||
!HeroManager.Allies.Any(x => x.LSIsValidTarget(1000, false) && !x.IsMe))
{
return;
}
if (!Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Harass) &&
!Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.LastHit))
{
return;
}
var minion = args.Target as Obj_AI_Base;
if (minion != null && minion.IsMinion && minion.LSIsValidTarget())
{
args.Process = false;
}
}
private void iJava(AttackableUnit target, Orbwalker.PreAttackArgs 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;
}
}
private static void OrbwalkerOnPreAttack(AttackableUnit target, Orbwalker.PreAttackArgs args)
{
if (target == null)
{
return;
}
if (_q.IsReady())
{
if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo) ||
Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.LaneClear) ||
Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.JungleClear))
{
if (target is AIHeroClient)
{
if (Value.Use("combo.q".AddName()) && AxeCount < Value.Get("misc.axe.count"))
{
_q.Cast();
}
}
// ReSharper disable once PossibleNullReferenceException
if ((target as Obj_AI_Base).IsMinion)
{
if (Value.Use("lane.q") && AxeCount < Value.Get("misc.axe.count"))
{
_q.Cast();
}
}
// ReSharper disable once PossibleNullReferenceException
if ((target as Obj_AI_Base).IsMonster)
{
if (Value.Use("jungle.q") && AxeCount < Value.Get("misc.axe.count"))
{
_q.Cast();
}
}
}
}
}
private static void Orbwalker_OnPreAttack(AttackableUnit target, Orbwalker.PreAttackArgs args)
{
try
{
if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo) ||
Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Harass))
{
if (!(args.Target is AIHeroClient))
{
return;
}
var targeta =
HeroManager.Enemies.Find(
x => x.HasBuff("TristanaECharge") && x.IsValidTarget(spells[Spells.E].Range));
if (targeta == null)
{
return;
}
if (Orbwalking.InAutoAttackRange(targeta))
{
Orbwalker.ForcedTarget = targeta;
}
}
if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.LastHit) ||
Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.LaneClear))
{
var minion = args.Target as Obj_AI_Minion;
if (minion != null && minion.HasBuff("TristanaECharge"))
{
Orbwalker.ForcedTarget = minion;
}
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
public static void Orbwalker_OnPreAttack(AttackableUnit target, Orbwalker.PreAttackArgs args)
{
if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo))
{
var hero = args.Target as AIHeroClient;
if (Mode.getBoxItem(MenuConfig.comboMenu, "ComboMode") == 1)
{
if (MenuConfig.TripleQAAReset)
{
if (Player.Mana == 5)
{
Spells.Q.Cast(hero);
}
if (Player.Mana < 5)
{
Spells.Q.Cast(hero);
}
}
}
}
}
public static void Orbwalker_OnPreAttack(AttackableUnit target, Orbwalker.PreAttackArgs args)
{
/// <summary>
/// The Target Forcing Logic.
/// </summary>
if (args.Target is AIHeroClient)
{
if (!GameObjects.EnemyHeroes.Any(
t =>
t.LSIsValidTarget(Vars.AARange) &&
t.HasBuff("TristanaECharge")))
{
Orbwalker.ForcedTarget = null;
return;
}
Orbwalker.ForcedTarget = GameObjects.EnemyHeroes.FirstOrDefault(
t =>
t.IsValidTarget(Vars.AARange) &&
t.HasBuff("TristanaECharge"));
}
}
internal static void OnBeforeAttack(AttackableUnit target, Orbwalker.PreAttackArgs args)
{
if (args.Target.Type == GameObjectType.obj_AI_Minion &&
Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Harass) &&
Config.IsChecked(Config.Harass, "disableAAH"))
{
var air = Player.Instance.CountAlliesInRange(Config.GetSliderValue(Config.Harass, "allyRangeH"));
if (air > 1)
{
args.Process = false;
}
}
if ((Config.IsChecked(Config.Combo, "comboDisableAA") ||
(Config.IsChecked(Config.Combo, "bLvlDisableAA") &&
Player.Instance.Level >= Config.GetSliderValue(Config.Combo, "lvlDisableAA"))) &&
Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo) &&
args.Target.Type == GameObjectType.AIHeroClient)
{
args.Process = false;
}
}
private void Orbwalking_BeforeAttack(AttackableUnit target, Orbwalker.PreAttackArgs args)
{
if (getSliderItem("TsAa") != 0 || !getCheckBoxItem("extraFocus") || !Program.Combo)
{
DrawInfo = null;
return;
}
if (args.Target is AIHeroClient)
{
var newTarget = (AIHeroClient)args.Target;
var forceFocusEnemy = newTarget;
// if (newTarget.Health / Player.GetAutoAttackDamage(newTarget) > FocusTarget.Health / Player.GetAutoAttackDamage(FocusTarget))
{
}
// else
{
var aaRange = Player.AttackRange + Player.BoundingRadius + getSliderItem("extraRang");
foreach (var enemy in Program.Enemies.Where(enemy => enemy.LSIsValidTarget(aaRange)))
{
if (enemy.Health / Player.GetAutoAttackDamage(enemy) + 1 <
forceFocusEnemy.Health / Player.GetAutoAttackDamage(forceFocusEnemy))
{
forceFocusEnemy = enemy;
}
}
}
if (forceFocusEnemy.NetworkId != newTarget.NetworkId &&
Game.Time - LatFocusTime < getSliderItem("extraTime") / 1000)
{
args.Process = false;
Program.debug("Focus: " + forceFocusEnemy.ChampionName);
DrawInfo = forceFocusEnemy;
return;
}
}
DrawInfo = null;
}
private void OnPreAttack(AttackableUnit target, Orbwalker.PreAttackArgs args)
{
if (Value.Mode(Orbwalker.ActiveModes.Combo))
{
if (Value.Use("combo.aa"))
{
var forcedtarget = Variables.CloseEnemies(_q.Range).Find
(a => a.HasBuff("kalistaexpungemarker"));
Orbwalker.ForcedTarget = forcedtarget;
}
else
{
Orbwalker.ForcedTarget = target;
}
}
if (Value.Mode(Orbwalker.ActiveModes.LaneClear))
{
var unit =
EntityManager.MinionsAndMonsters.EnemyMinions.FirstOrDefault(
u =>
u.IsValidTarget(Player.Instance.GetAutoAttackRange(u)));
if (unit == null)
{
return;
}
if (Value.Use("lane.refresh.buff") && EDamage(unit) <= unit.Health &&
unit.HasBuff("kalistaexpungemarker"))
{
Orbwalker.ForcedTarget = unit;
}
else
{
Orbwalker.ForcedTarget = unit;
}
}
}
private static void OrbwalkingBeforeAttack(AttackableUnit target, Orbwalker.PreAttackArgs args)
{
if (getCheckBoxItem(miscMenu, "AA.Block") && Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo))
{
args.Process = false;
}
else
{
if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo))
{
args.Process = !(spells[Spells.Q].IsReady() || Player.Distance(args.Target) >= 1000);
}
}
if (getCheckBoxItem(miscMenu, "ElZilean.SupportMode"))
{
if (args.Target is Obj_AI_Minion)
{
args.Process = false;
}
}
}
public static void Orbwalker_OnPreAttack(AttackableUnit target, Orbwalker.PreAttackArgs args)
{
/// <summary>
/// Stop attack commands while channeling R.
/// </summary>
if (GameObjects.Player.HasBuff("missfortunebulletsound"))
{
args.Process = false;
}
/// <summary>
/// The Target Switching Logic (Passive Stacks).
/// </summary>
if (args.Target is AIHeroClient &&
args.Target.NetworkId == Vars.PassiveTarget.NetworkId &&
Vars.getCheckBoxItem(Vars.MiscMenu, "passive"))
{
if (Vars.GetRealHealth(args.Target as AIHeroClient) >
GameObjects.Player.GetAutoAttackDamage(args.Target as AIHeroClient) * 3)
{
if (GameObjects.EnemyHeroes.Any(
t =>
t.IsValidTarget(Vars.AARange) &&
t.NetworkId != Vars.PassiveTarget.NetworkId))
{
args.Process = false;
Orbwalker.ForcedTarget = GameObjects.EnemyHeroes.Where(
t =>
t.IsValidTarget(Vars.AARange) &&
t.NetworkId != Vars.PassiveTarget.NetworkId).OrderByDescending(
o =>
Data.Get <ChampionPriorityData>().GetPriority(o.ChampionName)).First();
return;
}
Orbwalker.ForcedTarget = null;
}
}
}
private static void Orbwalker_OnPreAttack(AttackableUnit target, Orbwalker.PreAttackArgs args)
{
IsPreAttack = true;
if (!Settings.LaneClear.UseEOnTowers || !Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.LaneClear) || Player.Instance.ManaPercent < Settings.LaneClear.MinManaE || !E.IsReady())
{
return;
}
if (args.Target.GetType() != typeof(Obj_AI_Turret) || !args.Target.IsValidTargetCached() ||
(args.Target.Health < Player.Instance.GetAutoAttackDamageCached(args.Target as Obj_AI_Base) * 2.5f))
{
return;
}
if (Settings.LaneClear.UseQInLaneClear && Q.IsReady())
{
Q.Cast();
}
E.Cast(args.Target as Obj_AI_Base);
}
public override void Orbwalking_BeforeAttack(AttackableUnit target, Orbwalker.PreAttackArgs 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();
}
}
static void Orbwalker_OnPreAttack(AttackableUnit ff, Orbwalker.PreAttackArgs args)
{
if (MiscMenu["disableAA"].Cast <CheckBox>().CurrentValue&& Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo))
{
args.Process = false;
}
else
{
if (Q.IsReady() && Player.Distance(args.Target) < Q.Range - 100 && Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo))
{
args.Process = false;
}
}
if (MiscMenu["suppmode"].Cast <CheckBox>().CurrentValue)
{
if (args.Target is Obj_AI_Minion)
{
args.Process = false;
}
}
}
private static void OrbwalkingBeforeAttack(AttackableUnit target, Orbwalker.PreAttackArgs args)
{
if (args.Target is AIHeroClient)
{
if (W.IsReady() && getCheckBoxItem(miscMenu, "Misc.AutoW") && !shenBuffActive)
{
W.Cast();
}
foreach (
var item in
Items.ItemDb.Where(
i =>
i.Value.ItemType == Items.EnumItemType.OnTarget &&
i.Value.TargetingType == Items.EnumItemTargettingType.EnemyHero &&
i.Value.Item.IsReady()))
{
//Game.PrintChat(item.Value.Item.Id.ToString());
item.Value.Item.Cast();
}
}
}
/// <summary>
/// Called on orbwalker action.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="args">The <see cref="OrbwalkingActionArgs" /> instance containing the event data.</param>
public static void OnAction(AttackableUnit target, Orbwalker.PreAttackArgs args)
{
/// <summary>
/// The Target Forcing Logic.
/// </summary>
if (args.Target is AIHeroClient)
{
if (!GameObjects.EnemyHeroes.Any(
t =>
t.LSIsValidTarget(Vars.AARange) &&
t.HasBuff("luxilluminatingfraulein")))
{
Orbwalker.ForcedTarget = null;
return;
}
Orbwalker.ForcedTarget = GameObjects.EnemyHeroes.FirstOrDefault(
t =>
t.LSIsValidTarget(Vars.AARange) &&
t.HasBuff("luxilluminatingfraulein"));
return;
}
if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.LaneClear) || Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.JungleClear) || Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.LastHit))
{
/// <summary>
/// The 'Support Mode' Logic.
/// </summary>
if (Vars.getCheckBoxItem(Vars.MiscMenu, "support"))
{
if (args.Target is Obj_AI_Minion &&
GameObjects.AllyHeroes.Any(a => a.Distance(GameObjects.Player) < 2500))
{
args.Process = false;
}
}
}
}
private static void Orbwalker_OnPreAttack(AttackableUnit target, Orbwalker.PreAttackArgs args)
{
if (!Q.IsReady() || !getCheckBoxItem(qMenu, "autoQ") || !FishBoneActive)
{
return;
}
var t = args.Target as AIHeroClient;
if (t != null)
{
var realDistance = GetRealDistance(t) - 50;
if (Program.Combo &&
(realDistance < GetRealPowPowRange(t) ||
(Player.Mana < RMANA + 20 && Player.GetAutoAttackDamage(t) * 3 < t.Health)))
{
Q.Cast();
}
else if (Program.Farm && getCheckBoxItem(qMenu, "Qharras") &&
(realDistance > bonusRange() || realDistance < GetRealPowPowRange(t) ||
Player.Mana < RMANA + EMANA + WMANA + WMANA))
{
Q.Cast();
}
}
var minion = args.Target as Obj_AI_Minion;
if (Program.Farm && minion != null)
{
var realDistance = GetRealDistance(minion);
if (realDistance < GetRealPowPowRange(minion) || Player.ManaPercent < getSliderItem(farmMenu, "Mana"))
{
Q.Cast();
}
}
}
private static void BeforeAttack(AttackableUnit target, Orbwalker.PreAttackArgs args)
{
try
{
if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo) && !HasPassive &&
spells[Spells.Q].IsReady() &&
!(MenuInit.getBoxItem(MenuInit.comboMenu, "Combo.Prio") == 0 ||
MenuInit.getBoxItem(MenuInit.comboMenu, "Combo.Prio") == 1 && Ferocity == 5))
{
var x = Prediction.GetPrediction(args.Target as Obj_AI_Base, Player.AttackCastDelay + 0.04f);
if (Player.Position.To2D().Distance(x.UnitPosition.To2D())
>= Player.BoundingRadius + Player.AttackRange + args.Target.BoundingRadius)
{
args.Process = false;
spells[Spells.Q].Cast();
}
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
/// <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(AttackableUnit target, Orbwalker.PreAttackArgs args)
{
if (args.Target.IsValid <Obj_AI_Minion>() &&
(Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Harass) ||
Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.LastHit)) &&
!getCheckBoxItem(miscMenu, "AttackMinions"))
{
if (ObjectManager.Player.CountAlliesInRange(1200) != 0)
{
args.Process = false;
}
}
if (!args.Target.IsValid <AIHeroClient>() || getCheckBoxItem(miscMenu, "AttackChampions"))
{
return;
}
if (ObjectManager.Player.CountAlliesInRange(1200) != 0)
{
args.Process = false;
}
}
public override void Orbwalker_OnPreAttack(AttackableUnit target, Orbwalker.PreAttackArgs args)
{
if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo))
{
if (!combo.IsActive("aa"))
{
args.Process = false; return;
}
if (!combo.IsActive("aa.maxrange") && Player.Distance(target) >= 530)
{
args.Process = false; return;
}
}
if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Harass))
{
if (!harass.IsActive("aa.maxrange") && Player.Distance(target) >= 530)
{
args.Process = false; return;
}
}
}
/// <summary>
/// Called after a attack.
/// </summary>
/// <param name="target">The Target</param>
/// <param name="args">The Args</param>
private static void Orbwalker_OnPreAttack(AttackableUnit target, Orbwalker.PreAttackArgs args)
{
var t = target as AIHeroClient;
var m = target as Obj_AI_Base;
if (!NidaleeMenu.MiscMenu["useQC_AfterAttack"].Cast <CheckBox>().CurrentValue)
{
return;
}
if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo) &&
NidaleeMenu.ComboMenu["useQC"].Cast <CheckBox>().CurrentValue&& t != null)
{
if (t.IsValidTarget(QCat.Range) && !target.IsStructure())
{
QCat.Cast(t);
}
}
if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.LaneClear) &&
NidaleeMenu.LaneClearMenu["useQC"].Cast <CheckBox>().CurrentValue&& m != null)
{
if (m.IsValidTarget(QCat.Range) && !target.IsStructure())
{
QCat.Cast(m);
}
}
if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.JungleClear) &&
NidaleeMenu.JungleClearMenu["useQC"].Cast <CheckBox>().CurrentValue&& m != null)
{
if (m.IsValidTarget(QCat.Range) && !target.IsStructure())
{
QCat.Cast(m);
}
}
}
/// <summary>
/// After Attack
/// </summary>
/// <param name="target">The Target that got attacked</param>
/// <param name="args">The Args</param>
private static void Orbwalker_OnPreAttack(AttackableUnit target, Orbwalker.PreAttackArgs args)
{
var t = target as AIHeroClient;
var m = target as Obj_AI_Base;
if (!CatForm())
{
return;
}
if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo) && ComboMenu["useQCat"].Cast <CheckBox>().CurrentValue)
{
if (t != null)
{
if (t.IsValidTarget() && !t.IsZombie && QCat.IsInRange(t))
{
QCat.Cast(t);
}
}
}
if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.LaneClear) && LaneClearMenu["useQCat"].Cast <CheckBox>().CurrentValue)
{
if (m.IsValidTarget() && QCat.IsInRange(m))
{
QCat.Cast(m);
}
}
if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.JungleClear) && JungleClearMenu["useQCat"].Cast <CheckBox>().CurrentValue)
{
if (m.IsValidTarget() && QCat.IsInRange(m))
{
QCat.Cast(m);
}
}
}
private void Orbwalker_OnPreAttack(AttackableUnit target, Orbwalker.PreAttackArgs args)
{
//Anti Melee
var possibleNearbyMeleeChampion =
ValidTargets.FirstOrDefault(
e => e.IsMelee && e.ServerPosition.Distance(ObjectManager.Player.ServerPosition) < 350 && e.IsEnemy);
if (possibleNearbyMeleeChampion.LSIsValidTarget())
{
if (E.IsReady() && UseEAntiMelee)
{
var pos = ObjectManager.Player.ServerPosition.LSExtend(possibleNearbyMeleeChampion.ServerPosition,
-Misc.GiveRandomInt(250, 475));
if (!IsDangerousPosition(pos))
{
if (pos.IsUnderEnemyTurret() && !ObjectManager.Player.IsUnderEnemyTurret())
{
return;
}
E.Cast(pos);
}
}
}
}
private static void Orbwalker_OnPreAttack(AttackableUnit target, Orbwalker.PreAttackArgs args)
{
try
{
if (Standarts.Rengar.IsDead)
{
return;
}
if (!Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo))
{
return;
}
if (Standarts.RengarHasPassive && !Standarts.RengarHasUltimate)
{
args.Process = false;
BushTargeting();
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
private static void Orbwalker_OnPreAttack(AttackableUnit target, Orbwalker.PreAttackArgs args)
{
args.Process = AttacksEnabled;
}
private static void Orbwalker_OnPreAttack(AttackableUnit tgt, Orbwalker.PreAttackArgs args)
{
nextMove = Game.Time + ObjectManager.Player.AttackCastDelay +
(Game.Ping + adjustAnimation + RandGen.r.Next(maxAdditionalTime)) / 1000f;
}
