protected override void OnAfterAttack(AttackableUnit unit, AttackableUnit target)
{
if (!unit.IsMe) return;
if (unit.IsMe)
{
if (myOrbwalker.ActiveMode == myOrbwalker.OrbwalkingMode.Combo)
{
if (config.Item("UseWCombo").GetValue<bool>() &&
!Player.IsWindingUp &&
W.IsReady() &&
target.IsValidTarget() && Orbwalking.InAutoAttackRange(target)) W.Cast();
}
if (myOrbwalker.ActiveMode == myOrbwalker.OrbwalkingMode.Harass)
{
if (config.Item("UseWHarass").GetValue<bool>() &&
!Player.IsWindingUp &&
W.IsReady() &&
target.IsValidTarget() && Orbwalking.InAutoAttackRange(target)) W.Cast();
}
if (myOrbwalker.ActiveMode == myOrbwalker.OrbwalkingMode.JungleClear)
{
if (target is Obj_AI_Minion && target.Team == GameObjectTeam.Neutral && !target.Name.Contains("Mini") &&
!Player.IsWindingUp && Orbwalking.InAutoAttackRange(target))
{
if (W.IsReady() && config.Item("UseWJFarm").GetValue<bool>()) W.Cast();
}
}
}
}
private void Orbwalking_AfterAttack(AttackableUnit unit, AttackableUnit target)
{
if (unit.IsMe)
if (target.Type == GameObjectType.obj_AI_Hero)
switch (MenuProvider.Orbwalker.ActiveMode)
{
case Orbwalking.OrbwalkingMode.LastHit:
break;
case Orbwalking.OrbwalkingMode.Mixed:
break;
case Orbwalking.OrbwalkingMode.LaneClear:
break;
case Orbwalking.OrbwalkingMode.Combo:
if (MenuProvider.Champion.Combo.UseQ)
if (target.IsValidTarget(_q.Range))
if (_q.IsReadyPerfectly())
_q.CastOnUnit(target as Obj_AI_Base);
break;
case Orbwalking.OrbwalkingMode.None:
if (MenuProvider.Champion.Harass.UseQ)
if (target.IsValidTarget(_q.Range))
if (_q.IsReadyPerfectly())
_q.CastOnUnit(target as Obj_AI_Base);
break;
default:
break;
}
}
internal static float GetRealAutoAttackRange(this AttackableUnit unit, AttackableUnit target, int AutoAttackRange)
{
float result = AutoAttackRange + unit.BoundingRadius;
if (target.IsValidTarget())
return result + target.BoundingRadius;
return result;
}
private void AfterAttack(AttackableUnit unit, AttackableUnit target)
{
if (!unit.IsMe || !unit.IsValid<Obj_AI_Base>())
{
return;
}
if (Variables.Spells[SpellSlot.Q].IsEnabledAndReady(ModesMenuExtensions.Mode.Combo)
|| (Variables.Spells[SpellSlot.Q].IsEnabledAndReady(ModesMenuExtensions.Mode.Harrass)
&& ObjectManager.Player.ManaPercent >= Variables.AssemblyMenu.GetItemValue<Slider>("dzaio.champion.extra.mixed.mana").Value))
{
if (target.IsValid<Obj_AI_Hero>() && target.IsValidTarget())
{
Variables.Spells[SpellSlot.Q].CastIfHitchanceEquals(target as Obj_AI_Hero, HitChance.High);
}
}
if (Variables.Spells[SpellSlot.W].IsEnabledAndReady(ModesMenuExtensions.Mode.Combo)
|| (Variables.Spells[SpellSlot.W].IsEnabledAndReady(ModesMenuExtensions.Mode.Harrass)
&& ObjectManager.Player.ManaPercent >= Variables.AssemblyMenu.GetItemValue<Slider>("dzaio.champion.extra.mixed.mana").Value))
{
if (target.IsValid<Obj_AI_Hero>() && target.IsValidTarget())
{
Variables.Spells[SpellSlot.W].CastIfHitchanceEquals(target as Obj_AI_Hero, HitChance.High);
}
}
}
private static void OrbwalkingOnAfterAttack(AttackableUnit unit, AttackableUnit target)
{
if (!unit.IsMe)
{
return;
}
if (!(target is Obj_AI_Hero))
{
return;
}
if (!target.IsValidTarget())
{
return;
}
if (Hydra.IsReady())
{
Hydra.Cast();
}
else if (Tiamat.IsReady())
{
Tiamat.Cast();
}
}
public int CustomInAutoattackRange(AttackableUnit target)
{
if (Orbwalking.InAutoAttackRange(target))
{
return 1;
}
if (!target.IsValidTarget())
{
return 0;
}
//Azir's soldiers can't attack structures.
if (!(target is Obj_AI_Base))
{
return 0;
}
var soldierAArange = _soldierAARange + 65 + target.BoundingRadius;
soldierAArange *= soldierAArange;
foreach (var soldier in SoldiersManager.ActiveSoldiers)
{
if (soldier.Distance(target, true) <= soldierAArange)
{
return 2;
}
}
return 0;
}
protected override void OnAfterAttack(AttackableUnit unit, AttackableUnit target)
{
if (!unit.IsMe) return;
if (unit.IsMe )
{
if (target is Obj_AI_Hero && target.IsValid<Obj_AI_Hero>() && target.IsValidTarget())
{
if (myOrbwalker.ActiveMode == myOrbwalker.OrbwalkingMode.Combo)
{
if (config.Item("UseItemCombo").GetValue<bool>() && !Player.IsWindingUp)
{
myUtility.UseItems(2, null);
}
if (config.Item("UseQCombo").GetValue<bool>() && !Player.IsWindingUp && Orbwalking.InAutoAttackRange(target) && Q.IsReady())
{
Q.Cast();
}
}
}
if (myOrbwalker.ActiveMode == myOrbwalker.OrbwalkingMode.LaneClear)
{
if (target is Obj_AI_Turret && target.Team != Player.Team &&
config.Item("UseQMisc").GetValue<bool>() &&
!Player.IsWindingUp && Orbwalking.InAutoAttackRange(target) && Q.IsReady())
{
Q.Cast();
}
}
}
}
protected override void OnAfterAttack(AttackableUnit unit, AttackableUnit target)
{
if (!unit.IsMe) return;
if (unit.IsMe && !Player.IsWindingUp && E.IsReady() && target.IsValidTarget())
{
if (myOrbwalker.ActiveMode == myOrbwalker.OrbwalkingMode.Combo && target is Obj_AI_Hero)
{
if (config.Item("UseECombo").GetValue<bool>()) E.Cast();
}
if (myOrbwalker.ActiveMode == myOrbwalker.OrbwalkingMode.Harass && target is Obj_AI_Hero)
{
if (config.Item("UseEHarass").GetValue<bool>()) E.Cast();
}
if (myOrbwalker.ActiveMode == myOrbwalker.OrbwalkingMode.LaneClear && target is Obj_AI_Minion)
{
if (config.Item("UseEFarm").GetValue<bool>() && (myUtility.PlayerManaPercentage > config.Item("FarmMana").GetValue<Slider>().Value)) E.Cast();
}
if (myOrbwalker.ActiveMode == myOrbwalker.OrbwalkingMode.LaneClear)
{
if (target is Obj_AI_Turret && target.Team != Player.Team &&
config.Item("UseEMisc").GetValue<bool>() &&
!Player.IsWindingUp && Orbwalking.InAutoAttackRange(target))
{
E.Cast();
}
}
}
}
internal static void AfterAttack(AttackableUnit unit, AttackableUnit target)
{
if (target.IsValidTarget() && unit.IsValid<Obj_AI_Hero>() && unit.IsMe)
{
LastTarget = target;
}
}
private static void AfterAttack(AttackableUnit unit, AttackableUnit target)
{
if (GravesMenu.Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo && Helper.Enabled("graves.e.combo") && GravesSpells.E.IsReady()
&& target.IsValidTarget(GravesSpells.Q.Range))
{
GravesSpells.E.Cast(Game.CursorPos);
}
}
private static void AfterAttack(AttackableUnit unit, AttackableUnit target)
{
if (SivirMenu.Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo && Helper.SEnabled("sivir.w.combo") && SivirSpells.W.IsReady()
&& target.IsValidTarget(SivirSpells.W.Range))
{
SivirSpells.W.Cast();
}
}
private static void CorkiAfterAttack(AttackableUnit unit, AttackableUnit target)
{
if (CorkiMenu.Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo && Helper.CEnabled("corki.e.combo") && CorkiSpells.E.IsReady()
&& target.IsValidTarget(CorkiSpells.E.Range-100))
{
CorkiSpells.E.Cast(target.Position);
}
}
public static void Tumble(this Vector3 to, AttackableUnit afterTumbleTarget)
{
Player.CastSpell(SpellSlot.Q, to);
if (afterTumbleTarget != null && afterTumbleTarget.IsValidTarget(Player.Instance.GetAutoAttackRange()))
{
Player.IssueOrder(GameObjectOrder.AttackUnit, afterTumbleTarget);
}
}
public static void OnAttackJungleClear(AttackableUnit unit, AttackableUnit target)
{
if (target.IsValidTarget() && target.Team != GameObjectTeam.Neutral)
return;
if (WJungleClear && W.IsReady())
{
W.Cast();
}
}
public static float GetRealAutoAttackRange(Obj_AI_Hero attacker, AttackableUnit target)
{
var result = attacker.AttackRange + attacker.BoundingRadius;
if (target.IsValidTarget())
{
return result + target.BoundingRadius;
}
return result;
}
public static void CheckNonKillables(AttackableUnit minion)
{
if (!SMenu.Item(Handlers.RendHandler._MenuItemBase + "Boolean.RendNonKillables").GetValue<bool>()) return;
if (!Limiter.CheckDelay($"{Humanizer.DelayItemBase}Slider.NonKillableDelay")) return;
if (!(minion.Health <= Damage.DamageCalc.CalculateRendDamage((Obj_AI_Base)minion)) || minion.Health > 60) return;
if (!minion.IsValidTarget(Champion.E.Range))return;
Limiter.UseTick($"{Humanizer.DelayItemBase}Slider.NonKillableDelay");
Champion.E.Cast();
}
private static void OnPreAttack(AttackableUnit target, Orbwalker.PreAttackArgs args)
{
if (!Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo)) return;
if (Q.IsReady() && target.IsValidTarget(Q.Range) && !target.IsZombie)
{
Q.Cast(target.Position);
}
}
/// <summary>
/// Checks if target is in unit's auto attack range
/// </summary>
/// <param name="target">Target</param>
/// <param name="_unit">Unit to check range</param>
/// <returns>true if in auto attack range</returns>
public static bool InAARange(AttackableUnit target, Obj_AI_Base _unit = null)
{
if (!target.IsValidTarget())
return false;
Obj_AI_Base unit = CorrectUnit(_unit);
float range = GetRealAARange(target, _unit);
return Vector2.DistanceSquared(target.Position.To2D(), unit.ServerPosition.To2D()) <= range * range;
}
protected override void OnAfterAttack(AttackableUnit unit, AttackableUnit target)
{
if (!unit.IsMe) return;
if (unit.IsMe && W.IsReady() && !WBuff)
{
if (target is Obj_AI_Hero && target.IsValidTarget())
{
if (myOrbwalker.ActiveMode == myOrbwalker.OrbwalkingMode.Combo)
{
if (config.Item("UseItemCombo").GetValue<bool>() && !Player.IsWindingUp)
{
myUtility.UseItems(2, null);
}
if (config.Item("UseWCombo").GetValue<bool>() && !Player.IsWindingUp && Fury)
{
W.Cast();
}
}
}
if (target is Obj_AI_Minion && target.IsValidTarget())
{
if (myOrbwalker.ActiveMode == myOrbwalker.OrbwalkingMode.LaneClear)
{
if (config.Item("UseWFarm").GetValue<bool>())
{
if (W.IsKillable((Obj_AI_Minion)target))
{
W.Cast();
}
}
}
if (myOrbwalker.ActiveMode == myOrbwalker.OrbwalkingMode.JungleClear)
{
if (config.Item("UseWJFarm").GetValue<bool>())
{
if (W.IsKillable((Obj_AI_Minion)target))
{
W.Cast();
}
}
}
}
}
}
protected override void OnAfterAttack(AttackableUnit unit, AttackableUnit target)
{
if (!unit.IsMe) return;
if (unit.IsMe && Q.IsReady())
{
if (target.Name.ToLower().Contains("ward"))
{
Q.Cast();
Player.IssueOrder(GameObjectOrder.AttackUnit, target);
}
if (target is Obj_AI_Minion && target.IsValidTarget() && !Player.IsWindingUp)
{
if (myOrbwalker.ActiveMode == myOrbwalker.OrbwalkingMode.LaneClear && config.Item("UseQFarm").GetValue<bool>())
{
if (myUtility.PlayerManaPercentage < config.Item("FarmMana").GetValue<Slider>().Value) return;
if (Q.IsKillable((Obj_AI_Minion)target) ||
(Player.GetAutoAttackDamage((Obj_AI_Minion)target) + Player.GetSpellDamage((Obj_AI_Minion)target, SpellSlot.Q)) >= target.Health)
{
Q.Cast();
Player.IssueOrder(GameObjectOrder.AttackUnit, target);
}
}
}
if (target is Obj_AI_Hero && target.IsValidTarget() && !Player.IsWindingUp)
{
if (myOrbwalker.ActiveMode == myOrbwalker.OrbwalkingMode.Combo && config.Item("UseQCombo").GetValue<bool>() )
{
if (myUtility.ImmuneToCC((Obj_AI_Hero)target) || myUtility.ImmuneToMagic((Obj_AI_Hero)target)) return;
Q.Cast();
Player.IssueOrder(GameObjectOrder.AttackUnit, target);
}
if (myOrbwalker.ActiveMode == myOrbwalker.OrbwalkingMode.Harass && config.Item("UseQHarass").GetValue<bool>())
{
Q.Cast();
Player.IssueOrder(GameObjectOrder.AttackUnit, target);
}
}
}
}
public static void Orbwalker_OnPreAttack(AttackableUnit target, Orbwalker.PreAttackArgs args)
{
if (Program.ComboMenu["useRCombo"].Cast<CheckBox>().CurrentValue && target.IsValidTarget() && target is AIHeroClient)
{
if (Program.ComboMenu["noRUnderTurret"].Cast<CheckBox>().CurrentValue &&
((AIHeroClient)target).IsUnderAlliedTurret())
{
return;
}
Program.R.Cast();
}
}
public override bool InAutoAttackRange(AttackableUnit target)
{
if (!target.IsValidTarget())
return false;
if (Orbwalking.InAutoAttackRange(target))
return true;
if (!(target is Obj_AI_Base))
return false;
if (InSoldierAttackRange(target))
{
return true;
}
return false;
}
private static void AfterAttack(AttackableUnit unit, AttackableUnit target)
{
if (Ferocity == 5 && Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo)
{
if (unit.IsMe && spells[Spells.Q].IsReady() && target is Obj_AI_Hero && target.IsValidTarget())
{
spells[Spells.Q].Cast();
if (RengarQ || RengarE)
{
Orbwalking.ResetAutoAttackTimer();
}
}
}
}
/*
Before Attack
*/
private static void OnBeforeAttack(AttackableUnit target, EventArgs args)
{
if (target is AIHeroClient &&
target.IsValidTarget() && Misc.getSliderValue(ComboMenu, "cPrio") == 1)
{
if (Ferocity <= 4 && _Player.IsInAutoAttackRange(target))
Q.Cast();
if (Ferocity == 5 && Orbwalker.ActiveModesFlags == Orbwalker.ActiveModes.Combo &&
_Player.IsInAutoAttackRange(target))
Q.Cast();
if (Ferocity == 5 && Q.IsReady() && Passive())
Q.Cast();
}
}
protected override void OnAfterAttack(AttackableUnit unit, AttackableUnit target)
{
if (!unit.IsMe) return;
if (unit.IsMe)
{
if (myOrbwalker.ActiveMode == myOrbwalker.OrbwalkingMode.Combo)
{
if (config.Item("UseWCombo").GetValue<bool>() &&
!Player.IsWindingUp &&
W.IsReady() &&
target.IsValidTarget()) W.Cast();
}
}
}
public static void OnPostAttack(AttackableUnit unit, EventArgs args)
{
var tentaclesNear = TentacleList.FindAll(x => x.Distance(unit) <= Spells.Q.Range).Count;
switch (Orbwalker.ActiveModesFlags)
{
case Orbwalker.ActiveModes.Combo:
{
if (unit.Type == GameObjectType.AIHeroClient)
{
if (Init.ComboMenu["useW"].Cast<CheckBox>().CurrentValue)
if (Spells.W.IsReady())
{
if (unit.IsValidTarget(450))
{
Spells.W.Cast();
}
}
}
break;
}
case Orbwalker.ActiveModes.Harass:
{
if (unit.Type == GameObjectType.AIHeroClient)
{
if (Init.ComboMenu["useW"].Cast<CheckBox>().CurrentValue)
if (Spells.W.IsReady() && tentaclesNear > 0)
{
if (unit.IsValidTarget(450))
{
Spells.W.Cast();
}
}
}
break;
}
}
}
protected override void OnAfterAttack(AttackableUnit unit, AttackableUnit target)
{
if (!unit.IsMe) return;
if (unit.IsMe && W.IsReady() && target.IsValidTarget())
{
if (myOrbwalker.ActiveMode == myOrbwalker.OrbwalkingMode.Combo && target is Obj_AI_Hero)
{
if (config.Item("UseWCombo").GetValue<bool>()) W.Cast();
}
if (myOrbwalker.ActiveMode == myOrbwalker.OrbwalkingMode.Harass && target is Obj_AI_Hero)
{
if (config.Item("UseWHarass").GetValue<bool>()) W.Cast();
}
}
}
private static void Orbwalker_OnPostAttack(AttackableUnit target, EventArgs args)
{
if (!loaded)
{
return;
}
if (!target.IsEnemy || !(target is AIHeroClient))
{
return;
}
var useHydra = OffMenu["Hydra"].Cast<CheckBox>().CurrentValue
&& ((Hydra.IsOwned(Player.Instance) && Hydra.IsReady()) || (Timat.IsOwned(Player.Instance) && Timat.IsReady())
|| (Titanic.IsOwned(Player.Instance) && Titanic.IsReady()));
var flags = Orbwalker.ActiveModesFlags;
if (flags.HasFlag(Orbwalker.ActiveModes.Combo))
{
if (Youmuu.IsReady() && Youmuu.IsOwned(Player.Instance) && target.IsValidTarget(500) && OffMenu.GetCheckbox("useGhostblade"))
{
Youmuu.Cast();
}
if (useHydra)
{
if (Hydra.IsOwned() && Hydra.IsReady() && Hydra != null)
{
if (Hydra.Cast())
{
Orbwalker.ResetAutoAttack();
}
}
if (Timat.IsOwned() && Timat.IsReady() && Timat != null)
{
if (Timat.Cast())
{
Orbwalker.ResetAutoAttack();
}
}
if (Titanic.IsOwned() && Titanic.IsReady() && Titanic != null)
{
if (Titanic.Cast())
{
Orbwalker.ResetAutoAttack();
}
}
}
}
}
private static void AfterAttack(AttackableUnit unit, AttackableUnit target)
{
if (Ferocity == 5 && Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo)
{
if (unit.IsMe && spells[Spells.Q].IsReady() && target is Obj_AI_Hero && target.IsValidTarget())
{
spells[Spells.Q].Cast();
if (RengarQ || RengarE)
{
Orbwalking.ResetAutoAttackTimer();
Player.IssueOrder(GameObjectOrder.AttackUnit, target);
Console.WriteLine("Orbwalker Reset in AfterAttack");
}
}
}
}
private static void After_Attack(AttackableUnit unit, AttackableUnit target)
{
var targets = TargetSelector.GetTarget(Q.Range, TargetSelector.DamageType.Magical);
var usew = Config.Item("comboMenu.usew").GetValue<bool>();
if (targets == null)
return;
if (Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo
|| Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LaneClear
|| Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Mixed)
{
if (usew && target.IsValidTarget(Player.AttackRange) && W.IsReady())
{
W.Cast();
}
}
}
/// <summary>
/// Returns if our hero is currently able to perform the orbwalking process on another <see cref="AttackableUnit" />
/// </summary>
/// <param name="target">Type of <see cref="AttackableUnit" /></param>
/// <returns></returns>
public static bool CanGetOrbwalked(this AttackableUnit target)
{
return(target != null && target.IsValidTarget() && target.InAutoAttackRange());
}
private void OnAfterAa(AttackableUnit target, EventArgs args)
{
if (MenuManager.Modes.Misc.WaitAAForQ)
{
if (target != null && Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo) && target.IsValidTarget(Player.Instance.GetAutoAttackRange() + SpellManager.Q.Range))
{
var enemy = ObjectManager.GetUnitByNetworkId <Obj_AI_Base>((uint)target.NetworkId);
actionManager.EnqueueAction(
comboQueue,
() => CanCastQ(Orbwalker.ActiveModes.Combo),
() => SpellManager.Q.Cast(Game.CursorPos),
() => !CanCastQ(Orbwalker.ActiveModes.Combo));
}
}
if (target != null && Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Harass) && target.IsValidTarget(Player.Instance.GetAutoAttackRange() + SpellManager.Q.Range))
{
var enemy = ObjectManager.GetUnitByNetworkId <Obj_AI_Base>((uint)target.NetworkId);
actionManager.EnqueueAction(
harassQueue,
() => CanCastQ(Orbwalker.ActiveModes.Harass),
() => SpellManager.Q.Cast(ExtensionsHelpers.BestTumblePost(enemy)),
() => !CanCastQ(Orbwalker.ActiveModes.Harass));
}
else if (target != null && Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.LastHit) && target.IsValidTarget(Player.Instance.GetAutoAttackRange() + SpellManager.Q.Range) && Orbwalker.LastTarget != target)
{
var enemy = ObjectManager.GetUnitByNetworkId <Obj_AI_Base>((uint)target.NetworkId);
actionManager.EnqueueAction(
lastHitQueue,
() => CanCastQ(Orbwalker.ActiveModes.LastHit),
() => SpellManager.Q.Cast(ExtensionsHelpers.BestTumblePost(enemy)),
() => !CanCastQ(Orbwalker.ActiveModes.LastHit));
}
else if (target != null && Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.LaneClear) && target.IsValidTarget(Player.Instance.GetAutoAttackRange() + SpellManager.Q.Range))
{
var enemy = ObjectManager.GetUnitByNetworkId <Obj_AI_Base>((uint)target.NetworkId);
actionManager.EnqueueAction(
laneQueue,
() => CanCastQ(Orbwalker.ActiveModes.LaneClear),
() => SpellManager.Q.Cast(ExtensionsHelpers.BestTumblePost(enemy)),
() => !CanCastQ(Orbwalker.ActiveModes.LaneClear));
}
else if (target != null && Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.JungleClear) && target.IsValidTarget(Player.Instance.GetAutoAttackRange() + SpellManager.Q.Range))
{
var enemy = ObjectManager.GetUnitByNetworkId <Obj_AI_Base>((uint)target.NetworkId);
actionManager.EnqueueAction(
jungleQueue,
() => CanCastQ(Orbwalker.ActiveModes.JungleClear),
() => SpellManager.Q.Cast(ExtensionsHelpers.BestTumblePost(enemy)),
() => !CanCastQ(Orbwalker.ActiveModes.JungleClear));
}
}
internal static void Orbwalking_AfterAttack(AttackableUnit unit, AttackableUnit target)
{
if (!unit.IsMe || target == null || target.IsDead || unit.IsDead || (target.Type != GameObjectType.obj_AI_Minion && target.Type != GameObjectType.obj_AI_Hero))
{
return;
}
var itemone = AfterAttack.itemsList.FirstOrDefault(x => Items.CanUseItem((int)x.Id) && target.IsValidTarget(x.Range) && Menu.Item("AfterAttack.Use " + x.Id.ToString()).GetValue <bool>());
if (itemone != null)
{
var Minions = MinionManager.GetMinions(Orbwalking.GetRealAutoAttackRange(Player), MinionTypes.All, MinionTeam.Enemy);
var Mobs = MinionManager.GetMinions(Orbwalking.GetRealAutoAttackRange(Player), MinionTypes.All, MinionTeam.Neutral);
if ((Menu.Item("Misc.Cb").GetValue <bool>() && Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo ||
Menu.Item("Misc.Hr").GetValue <bool>() && Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Mixed) && !AIO ||
Menu.Item("Misc.Jc").GetValue <bool>() && Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LaneClear && Mobs.Count > 0 ||
Menu.Item("Misc.Lc").GetValue <bool>() && Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LaneClear && Minions.Count > 0)
{
if (Menu.Item("AfterAttack.SF").GetValue <bool>())
{
if (SkillCasted)
{
if (itemone.isTargeted)
{
Items.UseItem(itemone.Id, (Obj_AI_Hero)target);
}
else
{
Items.UseItem(itemone.Id);
}
}
}
else
{
if (itemone.isTargeted)
{
Items.UseItem(itemone.Id, (Obj_AI_Base)target);
}
else
{
Items.UseItem(itemone.Id);
}
}
}
}
}
internal static bool IsMinion(this AttackableUnit target)
{
return(target != null && target.IsValidTarget() && target.Type == GameObjectType.obj_AI_Minion &&
!target.Name.ToLower().Contains("plant") && target.Team != GameObjectTeam.Neutral);
}
/// <summary>
/// Returns true if the target is in auto-attack range.
/// </summary>
/// <param name="target">
/// The target.
/// </param>
/// <returns>
/// The <see cref="bool" />.
/// </returns>
public static bool InAutoAttackRange(this AttackableUnit target)
{
return(target.IsValidTarget() && target.Distance(GameObjects.Player) < target.GetRealAutoAttackRange());
}
private static float GetAutoAttackRange(Obj_AI_Base source, AttackableUnit target)
{
return(source.AttackRange + source.BoundingRadius + (target.IsValidTarget() ? target.BoundingRadius : 0));
}
private void Orbwalking_AfterAttack(AttackableUnit unit, AttackableUnit argsTarget)
{
if (!unit.IsMe || unit.IsDead || argsTarget == null || argsTarget.IsDead || !argsTarget.IsValidTarget() ||
argsTarget.ObjectType != GameObjectType.AIHeroClient)
{
return;
}
if (Main.Get <MenuCheckbox>("CQ").Checked&& Q.IsReady() &&
MyOrb.ActiveMode == Orbwalker.OrbwalkingMode.Combo)
{
Q.Cast();
}
}
private static void Orbwalking_AfterAttack(AttackableUnit unit, AttackableUnit target)
{
if (unit.IsMe)
{
switch (MenuProvider.Orbwalker.ActiveMode)
{
case Orbwalking.OrbwalkingMode.Combo:
var Item = ActiveItemList.FirstOrDefault(x => Menu.Item("Offensive.Use" + x.ID).GetValue <bool>() && x.When.Contains(When.AfterAttack) && Items.CanUseItem((int)x.ID) && target.IsValidTarget(x.Range) && ObjectManager.Player.ManaPercent <= x.MinMyHP && target.ManaPercent <= x.MinTargetHP);
if (Item != null)
{
Items.UseItem((int)Item.ID, Item.isTargeted ? target as Obj_AI_Base : null);
}
break;
}
}
}
public static bool InAutoAttackRange(AttackableUnit target, float extraRange = 0, Vector3 from = new Vector3())
{
return(target.IsValidTarget(GetAutoAttackRange(target) + extraRange, true, from));
}
private static AttackableUnit GetPossibleTarget()
{
AttackableUnit Target = null;
if (Config.Item("OW_Misc_PriorityUnit").GetValue <StringList>().SelectedIndex == 1 && (CurrentMode == Mode.Harass || CurrentMode == Mode.LaneClear))
{
Target = GetBestHeroTarget();
if (Target.IsValidTarget())
{
return(Target);
}
}
if (CurrentMode == Mode.Harass || CurrentMode == Mode.LaneClear || CurrentMode == Mode.LastHit)
{
foreach (var Obj in ObjectManager.Get <Obj_AI_Minion>().Where(i => InAutoAttackRange(i) && i.Team != GameObjectTeam.Neutral && MinionManager.IsMinion(i, true)))
{
var Time = (int)(Player.AttackCastDelay * 1000 - 100 + Game.Ping / 2 + 1000 * Player.Distance((AttackableUnit)Obj) / (Player.IsMelee() ? float.MaxValue : Player.BasicAttack.MissileSpeed));
var HpPred = HealthPrediction.GetHealthPrediction(Obj, Time, GetCurrentFarmDelay);
if (HpPred <= 0)
{
FireOnNonKillableMinion(Obj);
}
if (HpPred > 0 && HpPred <= (Player.ChampionName == "Azir" ? GetAzirWDamage(Obj) : Player.GetAutoAttackDamage(Obj, true)))
{
return(Obj);
}
}
}
if (InAutoAttackRange(ForcedTarget))
{
return(ForcedTarget);
}
if (CurrentMode == Mode.LaneClear)
{
foreach (var Obj in ObjectManager.Get <Obj_AI_Turret>().Where(i => InAutoAttackRange(i)))
{
return(Obj);
}
foreach (var Obj in ObjectManager.Get <Obj_BarracksDampener>().Where(i => InAutoAttackRange(i)))
{
return(Obj);
}
foreach (var Obj in ObjectManager.Get <Obj_HQ>().Where(i => InAutoAttackRange(i)))
{
return(Obj);
}
}
if (CurrentMode != Mode.LastHit)
{
Target = GetBestHeroTarget();
if (Target.IsValidTarget())
{
return(Target);
}
}
if (CurrentMode == Mode.Harass || CurrentMode == Mode.LaneClear)
{
Target = ObjectManager.Get <Obj_AI_Minion>().Where(i => InAutoAttackRange(i) && i.Team == GameObjectTeam.Neutral).MaxOrDefault(i => i.MaxHealth);
if (Target != null)
{
return(Target);
}
}
if (CurrentMode == Mode.LaneClear && !ShouldWait())
{
if (InAutoAttackRange(PrevMinion))
{
var HpPred = HealthPrediction.LaneClearHealthPrediction(PrevMinion, (int)(Player.AttackDelay * 1000 * ClearWaitTime), GetCurrentFarmDelay);
if (HpPred >= 2 * (Player.ChampionName == "Azir" ? GetAzirWDamage(PrevMinion) : Player.GetAutoAttackDamage(PrevMinion, true)) || Math.Abs(HpPred - PrevMinion.Health) < float.Epsilon)
{
return(PrevMinion);
}
}
Target = (from Obj in ObjectManager.Get <Obj_AI_Minion>().Where(i => InAutoAttackRange(i))
let HpPred = HealthPrediction.LaneClearHealthPrediction(Obj, (int)(Player.AttackDelay * 1000 * ClearWaitTime), GetCurrentFarmDelay)
where HpPred >= 2 * (Player.ChampionName == "Azir" ? GetAzirWDamage(Obj) : Player.GetAutoAttackDamage(Obj, true)) || Math.Abs(HpPred - Obj.Health) < float.Epsilon
select Obj).MaxOrDefault(i => i.Health);
if (Target != null)
{
PrevMinion = (Obj_AI_Minion)Target;
}
}
return(Target);
}
/// <summary>
/// Orbwalk a target while moving to Position.
/// </summary>
public static void Orbwalk(AttackableUnit target,
Vector3 position,
float extraWindup = 90,
float holdAreaRadius = 0,
bool useFixedDistance = true,
bool randomizeMinDistance = true,
bool autoWindup = false,
bool meleePrediction = true,
OrbwalkingMode mode = OrbwalkingMode.None,
bool comboMovement = true,
bool clearMovement = true)
{
try
{
if (autoWindup)
{
extraWindup = 25 + Game.Ping * (1.4f + Player.AttackCastDelay * 2);
}
if (target.IsValidTarget() && CanAttack())
{
DisableNextAttack = false;
FireBeforeAttack(target);
if (!DisableNextAttack)
{
if (!NoCancelChamps.Contains(Player.ChampionName))
{
LastAATick = Utils.GameTimeTickCount + Game.Ping + 100 -
(int) (ObjectManager.Player.AttackCastDelay * 1000f);
_missileLaunched = false;
var d = GetRealAutoAttackRange(target) - 65;
if (Player.Distance(target, true) > d * d && !Player.IsMelee)
{
LastAATick = Utils.GameTimeTickCount + Game.Ping + 400 -
(int) (ObjectManager.Player.AttackCastDelay * 1000f);
}
}
Player.IssueOrder(GameObjectOrder.AttackUnit, target);
_lastTarget = target;
return;
}
}
if ((!comboMovement && mode == OrbwalkingMode.Combo) ||
(!clearMovement && mode == OrbwalkingMode.LaneClear))
{
return;
}
if (CanMove(extraWindup))
{
if (player.IsMelee() && meleePrediction && target != null &&
target.Position.Distance(player.Position) < GetAutoAttackRange(player, target) &&
target is Obj_AI_Hero && Game.CursorPos.Distance(target.Position) < 150)
{
Obj_AI_Hero tar = (Obj_AI_Hero) target;
var prediction = AutoAttack.GetPrediction((Obj_AI_Base) target);
var pos = prediction.UnitPosition;
if (player.Distance(target) > target.BoundingRadius &&
!CombatHelper.IsFacing((Obj_AI_Base) target, player.Position, 120f) && tar.IsMoving)
{
AutoAttack.Delay = player.BasicAttack.SpellCastTime;
AutoAttack.Speed = player.BasicAttack.MissileSpeed;
MoveTo(pos, holdAreaRadius, false, useFixedDistance, randomizeMinDistance);
}
}
else
{
MoveTo(position, holdAreaRadius, false, useFixedDistance, randomizeMinDistance);
}
}
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
private void Orbwalking_AfterAttack(AttackableUnit unit, AttackableUnit target)
{
if (unit.IsMe)
{
switch (MenuProvider.Orbwalker.ActiveMode)
{
case Orbwalking.OrbwalkingMode.Combo:
{
if (target.Type == GameObjectType.AIHeroClient)
{
if (MenuProvider.Champion.Combo.UseW)
{
if (_w.IsReadyPerfectly())
{
if (target.IsValidTarget(_w.Range))
{
_w.Cast();
}
}
}
}
break;
}
case Orbwalking.OrbwalkingMode.Mixed:
{
if (target.Type == GameObjectType.AIHeroClient)
{
if (MenuProvider.Champion.Harass.UseW)
{
if (_w.IsReadyPerfectly())
{
if (target.IsValidTarget(_w.Range))
{
_w.Cast();
}
}
}
}
break;
}
case Orbwalking.OrbwalkingMode.LaneClear:
{
if (MinionManager.GetMinions(float.MaxValue).Any(x => x.NetworkId == target.NetworkId))
{
if (MenuProvider.Champion.Laneclear.UseW)
{
if (_w.IsReadyPerfectly())
{
if (target.IsValidTarget(_w.Range))
{
_w.Cast();
}
}
}
}
if (
MinionManager.GetMinions(float.MaxValue, MinionTypes.All, MinionTeam.Neutral)
.Any(x => x.NetworkId == target.NetworkId))
{
if (MenuProvider.Champion.Jungleclear.UseW)
{
if (_w.IsReadyPerfectly())
{
if (target.IsValidTarget(_w.Range))
{
_w.Cast();
}
}
}
}
break;
}
default:
break;
}
}
}
public static void Orbwalking_AfterAttack(AttackableUnit unit, AttackableUnit target)
{
#region Combo
if (SkyLv_Tristana.Menu.Item("Tristana.AfterAttackModeCombo").GetValue <bool>() && SkyLv_Tristana.Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo)
{
var PacketCast = SkyLv_Tristana.Menu.Item("Tristana.UsePacketCastCombo").GetValue <bool>();
if (target is AIHeroClient)
{
var t = (AIHeroClient)target;
if (t.IsValidTarget())
{
if (SkyLv_Tristana.Menu.Item("Tristana.UseQCombo").GetValue <bool>() && Q.IsReady() && t.IsValidTarget(Orbwalking.GetRealAutoAttackRange(Player)))
{
Q.Cast(PacketCast);
}
if (SkyLv_Tristana.Menu.Item("Tristana.UseECombo").GetValue <bool>() && E.IsReady() && t.IsValidTarget(E.Range))
{
E.CastOnUnit(t, PacketCast);
}
}
}
}
#endregion
#region Harass
if (SkyLv_Tristana.Menu.Item("Tristana.AfterAttackModeHarass").GetValue <bool>() && (SkyLv_Tristana.Menu.Item("Tristana.HarassActive").GetValue <KeyBind>().Active || SkyLv_Tristana.Menu.Item("Tristana.HarassActive2").GetValue <KeyBind>().Active || SkyLv_Tristana.Menu.Item("Tristana.HarassActiveT").GetValue <KeyBind>().Active))
{
var PacketCast = SkyLv_Tristana.Menu.Item("Tristana.UsePacketCastHarass").GetValue <bool>();
var useQ = SkyLv_Tristana.Menu.Item("Tristana.UseQHarass").GetValue <bool>();
var MiniManaQ = SkyLv_Tristana.Menu.Item("Tristana.QMiniManaHarass").GetValue <Slider>().Value;
var useE = SkyLv_Tristana.Menu.Item("Tristana.UseEHarass").GetValue <bool>();
var MiniManaE = SkyLv_Tristana.Menu.Item("Tristana.EMiniManaHarass").GetValue <Slider>().Value;
if (target is AIHeroClient)
{
var t = (AIHeroClient)target;
if (t.IsValidTarget())
{
if (useE && E.IsReady() && target.IsValidTarget(E.Range) && Player.ManaPercent > MiniManaE)
{
E.CastOnUnit(t, PacketCast);
}
if (useQ && Q.IsReady() && target.IsValidTarget(Orbwalking.GetRealAutoAttackRange(Player)) && Player.ManaPercent > MiniManaQ)
{
Q.Cast(PacketCast);
}
}
}
}
#endregion
#region LaneClear
if (SkyLv_Tristana.Menu.Item("Tristana.AfterAttackModeLaneClear").GetValue <bool>() && SkyLv_Tristana.Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LaneClear)
{
var PacketCast = SkyLv_Tristana.Menu.Item("Tristana.UsePacketCastLaneClear").GetValue <bool>();
var useQ = SkyLv_Tristana.Menu.Item("Tristana.UseQLaneClear").GetValue <bool>();
var useE = SkyLv_Tristana.Menu.Item("Tristana.UseELaneClear").GetValue <bool>();
var MiniManaQ = SkyLv_Tristana.Menu.Item("Tristana.QMiniManaLaneClear").GetValue <Slider>().Value;
var MiniManaE = SkyLv_Tristana.Menu.Item("Tristana.EMiniManaLaneClear").GetValue <Slider>().Value;
var MiniCountQ = SkyLv_Tristana.Menu.Item("Tristana.QLaneClearCount").GetValue <Slider>().Value;
var MiniCountE = SkyLv_Tristana.Menu.Item("Tristana.ELaneClearCount").GetValue <Slider>().Value;
var Minion = MinionManager.GetMinions(E.Range, MinionTypes.All, MinionTeam.Enemy).FirstOrDefault();
if (Minion.IsValidTarget() && SkyLv_Tristana.Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LaneClear)
{
if (SkyLv_Tristana.Menu.Item("Tristana.SafeLaneClear").GetValue <bool>() && Player.CountEnemiesInRange(1500) > 0)
{
return;
}
if (useE && Player.ManaPercent > MiniManaE && E.IsReady())
{
foreach (var minion in ObjectManager.Get <Obj_AI_Minion>().Where(m => m.Team != ObjectManager.Player.Team && !m.IsDead && Player.Distance(m) <= E.Range))
{
if (CustomLib.EnemyMinionInMinionRange(minion, 300) >= MiniCountE)
{
if (Player.GetAutoAttackDamage(minion) * 2 > minion.Health && SkyLv_Tristana.Menu.Item("Tristana.UseELaneClearOnlyLastHitable").GetValue <bool>())
{
E.CastOnUnit(minion, PacketCast);
}
if (!SkyLv_Tristana.Menu.Item("Tristana.UseELaneClearOnlyLastHitable").GetValue <bool>())
{
E.CastOnUnit(minion, PacketCast);
}
}
}
}
if (useQ && Player.ManaPercent > MiniManaQ && Q.IsReady())
{
if (CustomLib.EnemyMinionInPlayerRange(Orbwalking.GetRealAutoAttackRange(Player)) >= MiniCountQ)
{
Q.Cast(PacketCast);
}
}
}
}
#endregion
#region JungleClear
if (SkyLv_Tristana.Menu.Item("Tristana.AfterAttackModeJungleClear").GetValue <bool>() && SkyLv_Tristana.Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LaneClear)
{
var PacketCast = SkyLv_Tristana.Menu.Item("Tristana.UsePacketCastJungleClear").GetValue <bool>();
var useQ = SkyLv_Tristana.Menu.Item("Tristana.UseQJungleClear").GetValue <bool>();
var useE = SkyLv_Tristana.Menu.Item("Tristana.UseEJungleClear").GetValue <bool>();
var MiniManaQ = SkyLv_Tristana.Menu.Item("Tristana.QMiniManaJungleClear").GetValue <Slider>().Value;
var MiniManaE = SkyLv_Tristana.Menu.Item("Tristana.EMiniManaJungleClear").GetValue <Slider>().Value;
var MinionN = MinionManager.GetMinions(E.Range + 200, MinionTypes.All, MinionTeam.Neutral, MinionOrderTypes.MaxHealth).FirstOrDefault();
if (MinionN.IsValidTarget() && SkyLv_Tristana.Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LaneClear)
{
if (SkyLv_Tristana.Menu.Item("Tristana.SafeJungleClear").GetValue <bool>() && Player.CountEnemiesInRange(1500) > 0)
{
return;
}
if (useE && Player.ManaPercent > MiniManaE && E.IsReady())
{
if (SkyLv_Tristana.Menu.Item("Tristana.SpellOnlyBigMonster").GetValue <bool>())
{
foreach (var monster in ObjectManager.Get <Obj_AI_Base>().Where(monster => SkyLv_Tristana.Monsters.Contains(monster.BaseSkinName) && !monster.IsDead))
{
E.CastOnUnit(monster, PacketCast);
}
}
else if (!SkyLv_Tristana.Menu.Item("Tristana.SpellOnlyBigMonster").GetValue <bool>())
{
E.CastOnUnit(MinionN, PacketCast);
}
}
if (useQ && Q.IsReady() && Player.ManaPercent > MiniManaQ)
{
if (SkyLv_Tristana.Menu.Item("Tristana.SpellOnlyBigMonster").GetValue <bool>())
{
foreach (var monster in ObjectManager.Get <Obj_AI_Base>().Where(monster => SkyLv_Tristana.Monsters.Contains(monster.BaseSkinName) && !monster.IsDead))
{
Q.Cast(PacketCast);
}
}
else if (!SkyLv_Tristana.Menu.Item("Tristana.SpellOnlyBigMonster").GetValue <bool>())
{
Q.Cast(PacketCast);
}
}
}
}
#endregion
}
/// <summary>
/// Gets orbwalker target
/// </summary>
/// <returns></returns>
public AttackableUnit GetTarget()
{
bool wait = false;
if (ActiveMode == Mode.LaneClear)
{
wait = ShouldWait();
}
if (ActiveMode == Mode.LaneClear || ActiveMode == Mode.LastHit || ActiveMode == Mode.Mixed)
{
//turret farming
if (m_towerTarget != null && m_sourceTower != null && m_sourceTower.IsValidTarget(float.MaxValue, false) && m_towerTarget.IsValidTarget() && CanOrbwalkTarget(m_towerTarget, ObjectManager.Player.AttackRange + 150f))
{
float health = m_towerTarget.Health - Damage.Prediction.GetPrediction(m_towerTarget, (m_towerTarget.Distance(m_sourceTower.ServerPosition) / m_sourceTower.BasicAttack.MissileSpeed + m_sourceTower.AttackCastDelay) * 1000f);
if (Damage.Prediction.IsLastHitable(m_towerTarget))
{
return(m_towerTarget);
}
if (m_towerTarget.Health - m_sourceTower.GetAutoAttackDamage(m_towerTarget) * 2f > 0)
{
return(null);
}
else if (m_towerTarget.Health - m_sourceTower.GetAutoAttackDamage(m_towerTarget) > 0)
{
if (m_towerTarget.Health - m_sourceTower.GetAutoAttackDamage(m_towerTarget) - Damage.AutoAttack.GetDamage(m_towerTarget) <= 0)
{
return(null);
}
else if (health - m_sourceTower.GetAutoAttackDamage(m_towerTarget) - Damage.AutoAttack.GetDamage(m_towerTarget) * 2f <= 0)
{
return(m_towerTarget);
}
}
if (m_Configuration.FocusNormalWhileTurret)
{
return(FindKillableMinion());
}
if (m_towerTarget.Health - Damage.AutoAttack.GetDamage(m_towerTarget) * 2f <= 0)
{
float twoAaTime = ObjectManager.Player.AttackDelay + ObjectManager.Player.AttackCastDelay + 2 * (ObjectManager.Player.Distance(m_towerTarget.ServerPosition) / Utility.GetProjectileSpeed());
float towerAaTime = m_sourceTower.AttackCastDelay + m_sourceTower.Distance(m_towerTarget.ServerPosition) / m_sourceTower.BasicAttack.MissileSpeed;
if (twoAaTime <= towerAaTime)
{
return(m_towerTarget);
}
}
return(null);
}
var killableMinion = FindKillableMinion();
if (killableMinion != null && !killableMinion.IsDead && killableMinion.IsVisible && killableMinion.IsHPBarRendered && killableMinion.IsTargetable)
{
return(killableMinion);
}
}
if (m_forcedTarget != null && m_forcedTarget.IsValidTarget() && Utility.InAARange(m_forcedTarget) && !m_forcedTarget.IsDead && m_forcedTarget.IsVisible && m_forcedTarget.IsTargetable)
{
return(m_forcedTarget);
}
//buildings
if (ActiveMode == Mode.LaneClear && m_Configuration.AttackStructures && !wait)
{
/* turrets */
foreach (var turret in
ObjectManager.Get <Obj_AI_Turret>().Where(t => t.IsValidTarget() && Utility.InAARange(t)))
{
return(turret);
}
/* inhibitor */
foreach (var turret in
ObjectManager.Get <Obj_BarracksDampener>().Where(t => t.IsValidTarget() && Utility.InAARange(t)))
{
return(turret);
}
/* nexus */
foreach (var nexus in
ObjectManager.Get <Obj_HQ>().Where(t => t.IsValidTarget() && Utility.InAARange(t)))
{
return(nexus);
}
}
//champions
if (ActiveMode != Mode.LastHit)
{
if (ActiveMode == Mode.LaneClear && wait)
{
return(null);
}
if ((ActiveMode == Mode.LaneClear && !m_Configuration.DontAttackChampWhileLaneClear) || ActiveMode == Mode.Combo || ActiveMode == Mode.Mixed)
{
float range = -1;
range = (ObjectManager.Player.IsMelee && m_Configuration.MagnetMelee && m_Configuration.StickRange > ObjectManager.Player.AttackRange) ? m_Configuration.StickRange : -1;
if (ObjectManager.Player.CharData.BaseSkinName == "Azir")
{
range = 1000f;
}
var target = TargetSelector.GetTarget(range, LeagueSharp.Common.TargetSelector.DamageType.Physical);
if (target != null)
{
if (!target.IsDead && target.IsVisible && target.IsHPBarRendered && target.IsTargetable && target.IsValidTarget() && (Utility.InAARange(target) || (ActiveMode != Mode.LaneClear && ObjectManager.Player.IsMelee && m_Configuration.MagnetMelee && target.IsValidTarget(m_Configuration.StickRange))))
{
return(target);
}
}
}
}
if (!wait)
{
if (ActiveMode == Mode.LaneClear)
{
var minion = GetLaneClearTarget();
if (minion != null && minion.IsValidTarget() && Utility.InAARange(minion) && !minion.IsDead && minion.IsVisible && minion.IsTargetable)
{
return(minion);
}
}
}
return(null);
}
internal static void Orbwalking_AfterAttack(AttackableUnit unit, AttackableUnit target)
{
if (!unit.IsMe || target == null || target.IsDead || unit.IsDead || (target.Type != GameObjectType.obj_AI_Minion && target.Type != GameObjectType.obj_AI_Hero))
{
return;
}
var itemone = AfterAttack.itemsList.FirstOrDefault(x => Items.CanUseItem((int)x.Id) && target.IsValidTarget(x.Range) && Menu.Item("AfterAttack.Use " + x.Id.ToString()).GetValue <bool>());
if (itemone != null)
{
var Minions = MinionManager.GetMinions(Orbwalking.GetRealAutoAttackRange(Player), MinionTypes.All, MinionTeam.Enemy);
var Mobs = MinionManager.GetMinions(Orbwalking.GetRealAutoAttackRange(Player), MinionTypes.All, MinionTeam.Neutral);
if ((Menu.Item("Misc.Cb").GetValue <bool>() && Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo) || (Menu.Item("Misc.Hr").GetValue <bool>() && Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Mixed) || (Menu.Item("Misc.Jc").GetValue <bool>() && Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LaneClear && Mobs.Count > 0) || (Menu.Item("Misc.Lc").GetValue <bool>() && Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LaneClear && Minions.Count > 0))
{
var orderdata = OrderDataList.Find(x => x.ChampionName == ObjectManager.Player.ChampionName);
if (orderdata != null)
{
switch (orderdata.CastingOrder)
{
case CastingOrder.SpellFirst:
if (!Player.Spellbook.GetSpell(orderdata.SpellSlot).IsReady() ||
(Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo && (!Menu.Item("Combo.Use " + Player.Spellbook.GetSpell(orderdata.SpellSlot).Slot.ToString(), true).GetValue <bool>() || Menu.Item("Combo.Use " + Player.Spellbook.GetSpell(orderdata.SpellSlot).Slot.ToString(), true) == null) ||
Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Mixed && (!Menu.Item("Harass.Use " + Player.Spellbook.GetSpell(orderdata.SpellSlot).Slot.ToString(), true).GetValue <bool>() || Menu.Item("Harass.Use " + Player.Spellbook.GetSpell(orderdata.SpellSlot).Slot.ToString(), true) == null) ||
Minions.Count() > 0 && Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LaneClear && (!Menu.Item("Laneclear.Use " + Player.Spellbook.GetSpell(orderdata.SpellSlot).Slot.ToString(), true).GetValue <bool>() || Menu.Item("Laneclear.Use " + Player.Spellbook.GetSpell(orderdata.SpellSlot).Slot.ToString(), true) == null) ||
Mobs.Count() > 0 && Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LaneClear && (!Menu.Item("Jungleclear.Use " + Player.Spellbook.GetSpell(orderdata.SpellSlot).Slot.ToString(), true).GetValue <bool>() || Menu.Item("Jungleclear.Use " + Player.Spellbook.GetSpell(orderdata.SpellSlot).Slot.ToString(), true) == null)))
{
if (itemone.isTargeted)
{
Items.UseItem(itemone.Id, (Obj_AI_Base)target);
}
else
{
Items.UseItem(itemone.Id);
}
}
break;
case CastingOrder.ItemFirst:
if (itemone.isTargeted)
{
Items.UseItem(itemone.Id, (Obj_AI_Base)target);
}
else
{
Items.UseItem(itemone.Id);
}
break;
}
}
else
{
if (itemone.isTargeted)
{
Items.UseItem(itemone.Id, (Obj_AI_Base)target);
}
else
{
Items.UseItem(itemone.Id);
}
}
}
}
}
private static void ClearFarmAfterAttackEvent(AttackableUnit target)
{
try
{
if (!MyManaManager.SpellFarm)
{
return;
}
if (target.IsBuilding())
{
if (ClearMenu["FlowersRiven.ClearMenu.LaneClearQTurret"].Enabled && Q.Ready && Me.CountEnemyHeroesInRange(800) == 0)
{
Q.Cast(target.ServerPosition);
}
}
else if (target.Type == GameObjectType.obj_AI_Minion)
{
if (target.IsMinion())
{
if (ClearMenu["FlowersRiven.ClearMenu.LaneClearQ"].Enabled && Q.Ready)
{
var minions =
GameObjects.EnemyMinions.Where(x => x.IsValidTarget(400, false, false, target.ServerPosition) && x.IsMinion()).ToArray();
if (minions.Length >= 2)
{
Q.Cast(target.ServerPosition);
}
}
}
else if (target.IsMob())
{
var mob = target as Obj_AI_Minion;
if (mob != null && mob.IsValidTarget() && target.Health > Me.GetAutoAttackDamage(mob) * 2)
{
if (ClearMenu["FlowersRiven.ClearMenu.JungleClearQ"].Enabled && Q.Ready)
{
Q.Cast(mob.ServerPosition);
}
else if (ClearMenu["FlowersRiven.ClearMenu.JungleClearW"].Enabled && W.Ready && target.IsValidTarget(W.Range))
{
W.Cast();
}
else if (ClearMenu["FlowersRiven.ClearMenu.JungleClearE"].Enabled && E.Ready)
{
E.Cast(mob.ServerPosition);
}
}
}
}
}
catch (Exception ex)
{
Console.WriteLine("Error in MyEventManager.ClearFarmAfterAttackEvent." + ex);
}
}
/// <summary>
/// Called Before Attack
/// </summary>
/// <param name="target">The Target</param>
/// <param name="args">The Args</param>
private static void Orbwalker_OnPreAttack(AttackableUnit target, Orbwalker.PreAttackArgs args)
{
#region Combo
if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo))
{
var useQ = Config.ComboMenu["useQ"].Cast <CheckBox>().CurrentValue;
// If the player has the rocket
if (useQ && Program.Q.IsReady() && Essentials.FishBones())
{
//var target = TargetSelector.GetTarget(Essentials.FishBonesRange(), DamageType.Physical);
if (target != null && target.IsValidTarget())
{
if (Player.Instance.Distance(target) <= Essentials.MinigunRange &&
target.CountEnemiesInRange(100) <
Config.ComboMenu["qCountC"].Cast <Slider>().CurrentValue)
{
Program.Q.Cast();
Orbwalker.ForcedTarget = target;
}
}
}
}
#endregion
#region LastHit
if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.LastHit))
{
var useQ = Config.LastHitMenu["useQ"].Cast <CheckBox>().CurrentValue;
var manaQ = Config.LastHitMenu["manaQ"].Cast <Slider>().CurrentValue;
var qCountM = Config.LastHitMenu["qCountM"].Cast <Slider>().CurrentValue;
// Force Minigun if there is a lasthittable minion in minigun range and there is no targets more than the setting amount.
var kM = Orbwalker.LastHitMinionsList.Where(
t => t.IsEnemy &&
t.Health <= (Player.Instance.GetAutoAttackDamage(t) * 0.9) && t.IsValidTarget() &&
t.Distance(Player.Instance) <= Essentials.MinigunRange);
if (useQ && Essentials.FishBones() && kM.Count() < qCountM)
{
Program.Q.Cast();
}
}
#endregion
#region Lane Clear
if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.LaneClear))
{
var minion = EntityManager.MinionsAndMonsters.GetLaneMinions(
EntityManager.UnitTeam.Enemy,
Player.Instance.ServerPosition,
Essentials.FishBonesRange()).OrderByDescending(t => t.Health);
if (Essentials.FishBones())
{
foreach (var m in minion)
{
var minionsAoe =
EntityManager.MinionsAndMonsters.EnemyMinions.Count(
t => t.IsValidTarget() && t.Distance(m) <= 100);
if (m.Distance(Player.Instance) <= Essentials.MinigunRange && m.IsValidTarget() &&
(minionsAoe < Config.LaneClearMenu["qCountM"].Cast <Slider>().CurrentValue ||
m.Health > (Player.Instance.GetAutoAttackDamage(m))))
{
Q.Cast();
Orbwalker.ForcedTarget = m;
}
else if (m.Distance(Player.Instance) <= Essentials.MinigunRange &&
!Orbwalker.LastHitMinionsList.Contains(m))
{
Q.Cast();
Orbwalker.ForcedTarget = m;
}
else
{
foreach (
var kM in
Orbwalker.LastHitMinionsList.Where(
kM =>
kM.IsValidTarget() &&
kM.Health <= (Player.Instance.GetAutoAttackDamage(kM) * 0.9) &&
kM.Distance(Player.Instance) <= Essentials.MinigunRange))
{
Q.Cast();
Orbwalker.ForcedTarget = kM;
}
}
}
}
}
#endregion
if (Essentials.FishBones() && target.IsStructure() &&
target.Distance(Player.Instance) <= Essentials.MinigunRange)
{
Q.Cast();
}
}
private static void Orbwalker_OnPostAttack(AttackableUnit Target, EventArgs args)
{
if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo) && Target is AIHeroClient && Target.IsValidTarget())
{
if (Hero.Level <= EBeforeLevel.CurrentValue && E.CastMinimumHitchance((AIHeroClient)Target, 90) && E.GetPrediction((AIHeroClient)Target).HitChance != HitChance.Collision)
{
UseNetCombo = true;
ComboTarget = (AIHeroClient)Target;
return;
}
}
}
private AttackableUnit GetTarget()
{
bool wait = ShouldWait();
if (ActiveMode == Mode.LaneClear || ActiveMode == Mode.LastHit || ActiveMode == Mode.Mixed)
{
if (m_towerTarget != null && m_towerTarget.IsValidTarget() && CanOrbwalkTarget(m_towerTarget, ObjectManager.Player.AttackRange + 150f))
{
int x = GetTowerMinion();
if (x == -1)
{
return(FindKillableMinion());
}
if (x == 0)
{
return(m_towerTarget);
}
}
var killableMinion = FindKillableMinion();
if (killableMinion != null)
{
return(killableMinion);
}
}
if (m_forcedTarget != null && m_forcedTarget.IsValidTarget() && Utility.InAARange(m_forcedTarget))
{
return(m_forcedTarget);
}
//buildings
if (ActiveMode == Mode.LaneClear && m_Configuration.AttackStructures && !wait)
{
/* turrets */
foreach (var turret in
ObjectManager.Get <Obj_AI_Turret>().Where(t => t.IsValidTarget() && Utility.InAARange(t)))
{
return(turret);
}
/* inhibitor */
foreach (var turret in
ObjectManager.Get <Obj_BarracksDampener>().Where(t => t.IsValidTarget() && Utility.InAARange(t)))
{
return(turret);
}
/* nexus */
foreach (var nexus in
ObjectManager.Get <Obj_HQ>().Where(t => t.IsValidTarget() && Utility.InAARange(t)))
{
return(nexus);
}
}
//champions
if (ActiveMode != Mode.LastHit)
{
if (ActiveMode == Mode.LaneClear && wait)
{
return(null);
}
if ((ActiveMode == Mode.LaneClear && !m_Configuration.DontAttackChampWhileLaneClear) || ActiveMode == Mode.Combo || ActiveMode == Mode.Mixed)
{
float range = -1;
range = (ObjectManager.Player.IsMelee && m_Configuration.MagnetMelee && m_Configuration.StickRange > ObjectManager.Player.AttackRange) ? m_Configuration.StickRange : -1;
if (ObjectManager.Player.CharData.BaseSkinName == "Azir")
{
range = 950f;
}
var target = LeagueSharp.Common.TargetSelector.GetTarget(range, LeagueSharp.Common.TargetSelector.DamageType.Physical);
if (target.IsValidTarget() && (Utility.InAARange(target) || (ActiveMode != Mode.LaneClear && ObjectManager.Player.IsMelee && m_Configuration.MagnetMelee && target.IsValidTarget(m_Configuration.StickRange))))
{
return(target);
}
}
}
if (!wait)
{
if (ActiveMode == Mode.LaneClear)
{
var minion = GetLaneClearTarget();
if (minion != null)
{
return(minion);
}
}
}
return(null);
}
private static void OnAfterAttack(AttackableUnit target, EventArgs args)
{
if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo))
{
if (target == null || !(target is AIHeroClient) || target.IsDead || target.IsInvulnerable ||
!target.IsEnemy || target.IsPhysicalImmune || target.IsZombie)
{
return;
}
}
var enemy = target as AIHeroClient;
if (enemy == null)
{
return;
}
if (LucianTheTrollMenu.ComboEStart())
{
if (LucianTheTrollMenu.Eside())
{
if (E.IsReady() && target.IsValidTarget(Q1.Range) &&
!UnderEnemyTower((Vector2)Player.Position) &&
!HasPassive())
{
E.Cast(Side(Player.Position.To2D(), target.Position.To2D(), 65).To3D());
}
}
if (LucianTheTrollMenu.Ecursor())
{
if (E.IsReady() && target.IsValidTarget(Q1.Range) &&
!UnderEnemyTower((Vector2)Player.Position) &&
!HasPassive())
{
EloBuddy.Player.CastSpell(SpellSlot.E, Game.CursorPos);
}
}
if (LucianTheTrollMenu.Eauto())
{
if (Game.CursorPos.Distance(Player.Position) > Player.AttackRange + Player.BoundingRadius * 2 &&
!Player.Position.Extend(Game.CursorPos, E.Range).IsUnderTurret() && !HasPassive())
{
E.Cast(Player.Position.Extend(Game.CursorPos, E.Range).To3D());
}
else
{
E.Cast(Side(Player.Position.To2D(), target.Position.To2D(), 65).To3D());
}
}
}
if (LucianTheTrollMenu.AArange())
{
if (!E.IsReady() && Q.IsReady())
{
Q.Cast(enemy);
Core.DelayAction(() => W.Cast(enemy), 325);
}
if (!E.IsReady() && W.IsReady())
{
// W.Cast(enemy.Position);
Core.DelayAction(() => W.Cast(enemy), 370);
}
}
}
private static bool CanUse(Spell spell, AttackableUnit target)
{
return(spell.IsReady() && Player.Mana >= spell.ManaCost && target.IsValidTarget(spell.Range));
}
private static void AfterAttack(AttackableUnit unit, AttackableUnit ArgsTarget)
{
if (!unit.IsMe || Me.IsDead || ArgsTarget == null || ArgsTarget.IsDead || !ArgsTarget.IsValidTarget())
{
return;
}
if (isComboMode && ArgsTarget.ObjectType == GameObjectType.AIHeroClient)
{
if (ComboOption.UseQ && Q.IsReady())
{
var target = (AIHeroClient)ArgsTarget;
if (!target.IsDead && !target.IsZombie)
{
if (Me.HasBuff("asheqcastready"))
{
Q.Cast(true);
Orbwalker.ResetAutoAttackTimer();
}
}
}
}
else if (isJungleClearMode && ArgsTarget.ObjectType == GameObjectType.obj_AI_Minion)
{
if (JungleClearOption.HasEnouguMana && JungleClearOption.UseQ && Q.IsReady())
{
var mobs = MinionManager.GetMinions(Me.Position, Orbwalker.GetRealAutoAttackRange(Me), MinionTypes.All, MinionTeam.Neutral, MinionOrderTypes.MaxHealth);
if (mobs.Any())
{
foreach (var mob in mobs)
{
if (!mob.IsValidTarget(Orbwalker.GetRealAutoAttackRange(Me)) || !(mob.Health > Me.GetAutoAttackDamage(mob) * 2))
{
continue;
}
if (Me.HasBuff("asheqcastready"))
{
Q.Cast(true);
Orbwalker.ResetAutoAttackTimer();
}
}
}
}
}
}
/// <summary>
/// Returns true if the target is in auto-attack range.
/// </summary>
/// <param name="target">
/// The target.
/// </param>
/// <returns>
/// The <see cref="bool" />.
/// </returns>
public static bool InAutoAttackRange(this AttackableUnit target)
{
return(target.IsValidTarget(target.GetRealAutoAttackRange()));
}
