private static void AttackAction(object sender, OrbwalkerActionArgs attack)
{
var target = GetBestEnemyHeroTargetInRange(Gamer.GetRealAutoAttackRange() - 40);
if (!target.IsValidTarget(Gamer.GetRealAutoAttackRange() - 40))
{
return;
}
if (target == null)
{
return;
}
if (Main[Gamer.CharacterName]["combo"].GetValue <MenuList>("qBa").Index == 0 && attack.Type == OrbwalkerType.AfterAttack)
{
Q.Cast();
}
else if (Main[Gamer.CharacterName]["combo"].GetValue <MenuList>("qBa").Index == 1 && attack.Type == OrbwalkerType.BeforeAttack)
{
Q.Cast();
}
}
private static void OrbwalkerOnBeforeAttack(
Object sender,
OrbwalkerActionArgs args
)
{
if (args.Type == OrbwalkerType.BeforeAttack)
{
if (args.Target.Type == GameObjectType.AIHeroClient)
{
args.Process = AttacksEnabled;
}
else
{
args.Process = true;
}
}
if (args.Type == OrbwalkerType.NonKillableMinion)
{
QLastHit((AIBaseClient)args.Target);
}
}
private void OnAction(object sender, OrbwalkerActionArgs args)
{
if (args.Type == OrbwalkerType.AfterAttack)
{
if (Orbwalker.ActiveMode == OrbwalkerMode.Harass)
{
if (QAAH.Value == lastPunch && q.IsReady() && args.Target is AIHeroClient)
{
q.Cast();
Orbwalker.ResetAutoAttackTimer();
}
}
if (Orbwalker.ActiveMode == OrbwalkerMode.Combo)
{
if (lastPunch == QAA.Value && q.IsReady() && args.Target is AIHeroClient)
{
q.Cast();
Orbwalker.ResetAutoAttackTimer();
}
}
}
}
private static void OnBeforeAttack(object sender, OrbwalkerActionArgs args)
{
if (args.Type == OrbwalkerType.BeforeAttack && Orbwalker.ActiveMode == OrbwalkerMode.Combo)
{
if (MenuSettings.Combo.aaMaxRange.Enabled && objPlayer.Distance(args.Target) >= 550)
{
args.Process = false;
}
}
if (args.Type == OrbwalkerType.NonKillableMinion)
{
switch (args.Target.Type)
{
case GameObjectType.AIMinionClient:
if (Orbwalker.ActiveMode == OrbwalkerMode.LastHit || Orbwalker.ActiveMode == OrbwalkerMode.LaneClear)
{
var target = (AIMinionClient)args.Target;
if (target.IsValidTarget() && target.IsMinion())
{
if (target.Health > Q.GetDamage(target))
{
return;
}
if (Q.Instance.CooldownExpires - Game.Time > 0.3f)
{
return;
}
args.Process = false;
}
}
break;
case GameObjectType.AITurretClient:
break;
}
}
}
public static void ResetAttack(object e, OrbwalkerActionArgs args)
{
if (!(e is AIHeroClient))
{
return;
}
var target = TargetSelector.GetTarget(300, DamageType.Physical);
var champ = (AIHeroClient)e;
var useriu = ComboMenu["hydra"].GetValue <MenuBool>().Enabled;
var useQ = ComboMenu["ComboQ"].GetValue <MenuBool>().Enabled;
if (champ == null || champ.Type != GameObjectType.AIHeroClient || !champ.IsValid)
{
return;
}
if (target != null)
{
if (useQ && Q.IsReady() && !RActive && Orbwalker.ActiveMode.HasFlag(OrbwalkerMode.Combo))
{
Q.Cast();
Orbwalker.ResetAutoAttackTimer();
Player.IssueOrder(GameObjectOrder.AttackUnit, target);
}
if ((useriu && !RActive) && (Orbwalker.ActiveMode.HasFlag(OrbwalkerMode.Combo) || Orbwalker.ActiveMode.HasFlag(OrbwalkerMode.Harass)))
{
if (Hydra.IsInRange(Player.Instance) && Hydra.IsReady && target.IsValidTarget(250))
{
Hydra.Cast();
}
if (Tiamat.IsInRange(Player.Instance) && Tiamat.IsReady && target.IsValidTarget(250))
{
Tiamat.Cast();
}
}
}
}
private void OnActionDelegate(Object sender, OrbwalkerActionArgs args)
{
if (args.Type == OrbwalkerType.AfterAttack)
{
attackNow = true;
if (Program.LaneClear && W.IsReady() && Player.ManaPercent > Config["Farm"].GetValue <MenuSlider>("Mana").Value)
{
var minions = MinionManager.GetMinions(Player.Position, 650);
if (minions.Count >= Config["Farm"].GetValue <MenuSlider>("LCminions").Value)
{
if (Config["Farm"].GetValue <MenuBool>("farmW") && minions.Count > 1)
{
W.Cast();
}
}
}
}
if (args.Type == OrbwalkerType.BeforeAttack)
{
attackNow = false;
}
}
private static void OnAction(object sender, OrbwalkerActionArgs Args)
{
if (Args.Type != OrbwalkerType.BeforeAttack)
{
return;
}
if (Args.Target == null || Args.Target.IsDead || !Args.Target.IsValidTarget() || Args.Target.Health <= 0)
{
return;
}
if (Orbwalker.ActiveMode == OrbwalkerMode.Combo &&
ComboOption.GetBool("ComboDisableAA").Enabled&&
Args.Target.Type == GameObjectType.AIHeroClient)
{
if (HumanizerCardSelect.Status == HumanizerSelectStatus.Selecting &&
Variables.GameTimeTickCount - HumanizerCardSelect.LastWSent > 300)
{
Args.Process = false;
}
}
}
private static void OrbwalkingOnAfterAttack(Object unit, OrbwalkerActionArgs targeti)
{
var target = TargetSelector.GetTarget(400);
if (!(target is AIHeroClient))
{
return;
}
if (!target.IsValidTarget())
{
return;
}
if (Hydra.IsReady)
{
Hydra.Cast();
}
else if (Tiamat.IsReady)
{
Tiamat.Cast();
}
}
private static void Orbwalker_CantLasthit(object target, OrbwalkerActionArgs args)
{
var useCant = LaneClearMenu["CantLC"].GetValue <MenuBool>().Enabled;
var laneQMN = LaneClearMenu["ManaLC"].GetValue <MenuSlider>().Value;
var useAA = LastHitMenu["LhAA"].GetValue <MenuBool>().Enabled;
var LhM = LastHitMenu["LhMana"].GetValue <MenuSlider>().Value;
var unit = (useCant && Orbwalker.ActiveMode.HasFlag(OrbwalkerMode.LaneClear) && Player.Instance.ManaPercent >= laneQMN) ||
(useAA && Orbwalker.ActiveMode.HasFlag(OrbwalkerMode.LastHit) && Player.Instance.ManaPercent >= LhM);
var targe = TargetSelector.GetTarget(Q.Range);
if (target == null)
{
return;
}
if (unit && Q.IsReady() && targe.IsValidTarget(Q.Range))
{
/*if (Player.Instance.GetSpellDamage(target, SpellSlot.Q) >= HealthPrediction.Health.GetPrediction(target, Q.CastDelay))
* {
* Q.Cast(target);
* }*/
}
}
private static void Orbwalker_CantLasthit(object targetz, OrbwalkerActionArgs args)
{
var target = GameObjects.Jungle.Where(j => j.IsValidTarget(Q.Range)).FirstOrDefault(j => j.IsValidTarget(Q.Range));
// var target = GameObjects.EnemyMinions.Where(m => m.IsValidTarget(Q.Range)).OrderBy(m => m.Health).FirstOrDefault();
var useQ = LaneClearMenu["QLC"].GetValue <MenuBool>().Enabled;
var useQ2 = LaneClearMenu["QLH"].GetValue <MenuBool>().Enabled;
var mana = LaneClearMenu["ManaLC"].GetValue <MenuSlider>().Value;
var manaa = LaneClearMenu["LhMana"].GetValue <MenuSlider>().Value;
var unit = (LaneClearMenu["LCMode"].GetValue <MenuList>().Index == 1 && Orbwalker.ActiveMode.HasFlag(OrbwalkerMode.LaneClear) && useQ && _Player.ManaPercent >= mana) ||
(LaneClearMenu["LHMode"].GetValue <MenuList>().Index == 1 && Orbwalker.ActiveMode.HasFlag(OrbwalkerMode.LastHit) && useQ2 && _Player.ManaPercent >= manaa);
if (target == null)
{
return;
}
if (unit && Q.IsReady() && target.IsValidTarget(Q.Range))
{
if (_Player.GetSpellDamage(target, SpellSlot.Q) >= target.Health + target.AllShield)
{
Q.Cast(target.Position);
}
}
}
private static void WCombo(OrbwalkerActionArgs args)
{
if (MainMenu["Combo"]["comboW"].GetValue <MenuBool>().Enabled&& W.IsReady())
{
var target = TargetSelector.GetTarget(W.Range);
var inAaRange = target.IsValidTarget(ObjectManager.Player.GetRealAutoAttackRange(target));
var wPred = W.GetPrediction(target);
var lethalOn =
ObjectManager.Player.HasBuff("ASSETS/Perks/Styles/Precision/LethalTempo/LethalTempoEmpowered.lua");
if (!MainMenu["Combo"]["comboWonlyOutOfAA"].GetValue <MenuBool>().Enabled&& inAaRange && !lethalOn)
{
if (args.Type == OrbwalkerType.AfterAttack)
{
W.Cast(wPred.UnitPosition);
}
}
else if (target.IsValidTarget(W.Range) && !inAaRange && wPred.Hitchance >= HitChance.High)
{
W.Cast(wPred.UnitPosition);
}
}
}
/// <summary>
/// <c>Orbwalk</c> command, attempting to attack or move.
/// </summary>
/// <param name="target">
/// The target of choice
/// </param>
/// <param name="position">
/// The position of choice
/// </param>
public static void Orbwalk(AttackableUnit target = null, Vector3?position = null)
{
if (CanAttack)
{
var gTarget = target ?? GetTarget(ActiveMode);
if (gTarget.IsValidTarget())
{
var eventArgs = new OrbwalkerActionArgs
{
Target = gTarget,
Position = gTarget.Position,
Process = true,
Type = OrbwalkerType.BeforeAttack
};
InvokeAction(eventArgs);
if (eventArgs.Process)
{
if (GameObjects.Player.CanCancelAutoAttack())
{
//LastAutoAttackTick = Variables.TickCount + Game.Ping + 250
// - (int)(GameObjects.Player.AttackCastDelay * 1000);
MissileLaunched = false;
}
GameObjects.Player.IssueOrder(GameObjectOrder.AttackUnit, gTarget);
LastTarget = gTarget;
return;
}
}
}
if (CanMove)
{
MoveOrder(position.HasValue && position.Value.IsValid() ? position.Value : Game.CursorPos);
}
}
private static void Orbwalker_OnAction(object sender, OrbwalkerActionArgs args)
{
if (args.Type == OrbwalkerType.AfterAttack)
{
LastCasted = 0;
AfterAA = true;
OnAA = false;
BeforeAA = false;
}
else
{
AfterAA = false;
}
if (args.Type == OrbwalkerType.OnAttack)
{
LastCasted = 0;
AfterAA = false;
OnAA = true;
BeforeAA = false;
}
else
{
OnAA = false;
}
if (args.Type == OrbwalkerType.BeforeAttack)
{
AfterAA = false;
OnAA = false;
BeforeAA = true;
}
else
{
BeforeAA = false;
}
}
private static void OnOrbwalkerAction(object obj, OrbwalkerActionArgs args)
{
var jglW = Menu["Clear"].GetValue <MenuBool>("jungleclearW");
var UseW = Menu["Combo"].GetValue <MenuBool>("comboW");
var mobs = GameObjects.Jungle;
if (args.Type == OrbwalkerType.AfterAttack)
{
if (Orbwalker.ActiveMode == OrbwalkerMode.Combo)
{
if (w.IsReady() && UseW && args.Target != null && args.Target.Type == GameObjectType.AIHeroClient && args.Target.IsValidTarget(350))
{
w.Cast();
Orbwalker.ResetAutoAttackTimer();
}
}
else if (Orbwalker.ActiveMode == OrbwalkerMode.LaneClear)
{
if (mobs.Count() >= 1)
{
foreach (var mob in mobs)
{
if (!mob.IsValid)
{
return;
}
if (jglW && w.IsReady())
{
w.Cast();
Orbwalker.ResetAutoAttackTimer();
}
}
return;
}
}
}
}
public static void ResetAttack(object e, OrbwalkerActionArgs args)
{
if (!(e is AIHeroClient))
{
return;
}
var target = TargetSelector.GetTarget(325, DamageType.Physical);
var champ = (AIHeroClient)e;
var useriu = ComboMenu["hyd"].GetValue <MenuBool>().Enabled;
var useE = ComboMenu["ComboE"].GetValue <MenuBool>().Enabled;
if (champ == null || champ.Type != GameObjectType.AIHeroClient || !champ.IsValid)
{
return;
}
if (target != null)
{
if ((useriu) && (Orbwalker.ActiveMode.HasFlag(OrbwalkerMode.Combo) || Orbwalker.ActiveMode.HasFlag(OrbwalkerMode.Harass)))
{
if (Hydra.IsOwned() && Hydra.IsReady && target.IsValidTarget(250))
{
Hydra.Cast();
}
if (Tiamat.IsOwned() && Tiamat.IsReady && target.IsValidTarget(250))
{
Tiamat.Cast();
}
}
if ((useE && E.IsReady()) && Orbwalker.ActiveMode.HasFlag(OrbwalkerMode.Combo) && target.IsValidTarget(325) && _Player.Distance(target) < Player.Instance.GetRealAutoAttackRange(target))
{
E.Cast(target);
}
}
}
private static void OnAfterAttack(object sender, OrbwalkerActionArgs args)
{
if (args.Type != OrbwalkerType.AfterAttack)
{
return;
}
var target = TargetSelector.GetTarget(W.Range, DamageType.True);
var Wcombo = WMenu["Combo"].GetValue <MenuBool>().Enabled;
if (args.Target == null || args.Target.IsDead || !args.Target.IsValidTarget() ||
Orbwalker.ActiveMode == OrbwalkerMode.None || args.Target.Type != GameObjectType.AIHeroClient)
{
return;
}
if (target != null)
{
if (Orbwalker.ActiveMode == OrbwalkerMode.Combo)
{
if (Wcombo)
{
if (WMenu["AAr"].GetValue <MenuBool>().Enabled)
{
if (W.Cast())
{
Orbwalk.ResetAutoAttack();
ObjectManager.Player.IssueOrder(GameObjectOrder.AttackUnit, target);
}
}
}
if (QMenu["Combo"].GetValue <MenuBool>().Enabled&& (QMenu["QAA"].GetValue <MenuBool>().Enabled&& Q.IsReady()) && !W.IsReady())
{
Q.Cast();
}
}
}
}
private static void OnAction(object sender, OrbwalkerActionArgs Args)
{
if (Args.Type != OrbwalkerType.AfterAttack)
{
return;
}
if (Args.Target == null || Args.Target.IsDead || !Args.Target.IsValidTarget() ||
Args.Target.Health <= 0 || Orbwalker.ActiveMode == OrbwalkerMode.None)
{
return;
}
switch (Args.Target.Type)
{
case GameObjectType.AIHeroClient:
{
if (Orbwalker.ActiveMode == OrbwalkerMode.Combo)
{
if (ComboOption.UseW && W.IsReady())
{
var target = (AIHeroClient)Args.Target;
if (target != null && target.InAutoAttackRange())
{
var wPred = W.GetPrediction(target);
if (wPred.Hitchance >= HitChance.High)
{
W.Cast(wPred.UnitPosition);
}
}
}
}
}
break;
}
}
public static void OnAction(object sender, OrbwalkerActionArgs args)
{
if (MenuManager.MiscMenu["AASemiAllured"].GetValue <MenuBool>().Enabled&& args.Type == OrbwalkerType.BeforeAttack)
{
var OrbwalkerTarget = Orbwalker.GetTarget();
if (OrbwalkerTarget == null)
{
return;
}
var BaseTarget = OrbwalkerTarget as AIBaseClient;
if (BaseTarget == null)
{
return;
}
if (Misc.IsAllured(BaseTarget) && !Misc.IsFullyAllured(BaseTarget))
{
args.Process = false;
}
}
}
private static void OnAction(object sender, OrbwalkerActionArgs Args)
{
if (Args.Type == OrbwalkerType.BeforeAttack)
{
if (Orbwalker.ActiveMode == OrbwalkerMode.Combo || Orbwalker.ActiveMode == OrbwalkerMode.Harass)
{
var ForcusTarget =
GameObjects.EnemyHeroes.FirstOrDefault(
x => x.IsValidTarget(Me.AttackRange + Me.BoundingRadius + x.BoundingRadius + 50) && Has2WStacks(x));
if (MiscOption.GetBool("Forcus", "ForcusAttack").Enabled&& ForcusTarget != null &&
ForcusTarget.IsValidTarget(Me.AttackRange + Me.BoundingRadius - ForcusTarget.BoundingRadius + 15))
{
Orbwalker.ForceTarget = ForcusTarget;
LastForcusTime = Variables.GameTimeTickCount;
}
else
{
Orbwalker.ForceTarget = null;
}
}
}
if (Args.Type == OrbwalkerType.AfterAttack)
{
Orbwalker.ForceTarget = null;
if (Args.Target == null || Args.Target.IsDead || !Args.Target.IsValidTarget() ||
Args.Target.Health <= 0 || Orbwalker.ActiveMode == OrbwalkerMode.None)
{
return;
}
switch (Args.Target.Type)
{
case GameObjectType.AIHeroClient:
{
if (Orbwalker.ActiveMode == OrbwalkerMode.Combo)
{
if (ComboOption.GetBool("ComboAQA").Enabled)
{
var target = (AIHeroClient)Args.Target;
if (target != null && !target.IsDead && Q.IsReady())
{
AfterQLogic(target);
}
}
}
else if (Orbwalker.ActiveMode == OrbwalkerMode.Harass || Orbwalker.ActiveMode == OrbwalkerMode.LaneClear && MyManaManager.SpellHarass)
{
if (HarassOption.HasEnouguMana() && HarassOption.UseQ)
{
var target = (AIHeroClient)Args.Target;
if (target != null && !target.IsDead && Q.IsReady() &&
HarassOption.GetHarassTargetEnabled(target.CharacterName))
{
if (HarassOption.GetBool("HarassQ2Passive").Enabled&& !Has2WStacks(target))
{
return;
}
AfterQLogic(target);
}
}
}
}
break;
case GameObjectType.AIMinionClient:
{
if (Orbwalker.ActiveMode == OrbwalkerMode.LaneClear)
{
var m = (AIMinionClient)Args.Target;
if (m != null && m.IsValidTarget())
{
if (m.IsMinion())
{
if (LaneClearOption.HasEnouguMana() && LaneClearOption.UseQ)
{
var minions =
GameObjects.EnemyMinions.Where(x => x.IsValidTarget(Me.AttackRange + Me.BoundingRadius) && x.IsMinion())
.Where(x => x.Health <= Me.GetAutoAttackDamage(x) + Me.GetSpellDamage(x, SpellSlot.Q))
.ToList();
if (minions.Any() && minions.Count >= 1)
{
var minion = minions.OrderBy(x => x.Health).FirstOrDefault();
var afterQPosition = Me.PreviousPosition.Extend(Game.CursorPosRaw, Q.Range);
if (minion != null &&
afterQPosition.Distance(minion.PreviousPosition) <= Me.AttackRange + Me.BoundingRadius)
{
Q.Cast(Game.CursorPosRaw);
}
}
}
}
else if (m.GetJungleType() != JungleType.Unknown)
{
if (JungleClearOption.HasEnouguMana() && JungleClearOption.UseQ)
{
Q.Cast(Game.CursorPosRaw);
}
}
}
}
}
break;
case GameObjectType.AITurretClient:
case GameObjectType.HQClient:
case GameObjectType.Barracks:
case GameObjectType.BarracksDampenerClient:
case GameObjectType.BuildingClient:
{
if (Orbwalker.ActiveMode == OrbwalkerMode.LaneClear)
{
if (LaneClearOption.HasEnouguMana(true) && LaneClearOption.UseQ)
{
if (Me.CountEnemyHeroesInRange(850) == 0)
{
if (Me.CanMoveMent())
{
Q.Cast(Game.CursorPosRaw);
}
}
}
}
}
break;
}
}
}
internal static void MoveOrder(Vector3 position, bool overrideTimer = false)
{
var playerPosition = Program.Player.ServerPosition;
if (playerPosition.Distance(position)
> Program.Player.BoundingRadius + Program.MainMenu["Orbwalker"]["Advanced"]["ExtraHold"])
{
var point = position;
if (Program.Player.DistanceSquared(point) < 150 * 150)
{
point = playerPosition.Extend(position, (Random.NextFloat(0.6f, 1) + 0.2f) * 400);
}
var angle = 0f;
var currentPath = Program.Player.GetWaypoints();
if (currentPath.Count > 1 && currentPath.PathLength() > 100)
{
var movePath = Program.Player.GetPath(point);
if (movePath.Length > 1)
{
angle = (currentPath[1] - currentPath[0]).AngleBetween((movePath[1] - movePath[0]).ToVector2());
var distance = movePath.Last().ToVector2().DistanceSquared(currentPath.Last());
if ((angle < 10 && distance < 500 * 500) || distance < 50 * 50)
{
return;
}
}
}
if (Variables.TickCount - LastMovementOrderTick < 70 + Math.Min(60, Game.Ping) && !overrideTimer
&& angle < 60)
{
return;
}
if (angle >= 60 && Variables.TickCount - LastMovementOrderTick < 60)
{
return;
}
var eventArgs = new OrbwalkerActionArgs
{ Position = point, Process = true, Type = OrbwalkingType.Movement };
InvokeAction(eventArgs);
if (eventArgs.Process)
{
Program.Player.IssueOrder(GameObjectOrder.MoveTo, eventArgs.Position);
LastMovementOrderTick = Variables.TickCount;
}
}
}
internal virtual void OnAction(object sender, OrbwalkerActionArgs args)
{
}
private static void OnAction(object sender, OrbwalkerActionArgs Args)
{
if (Args.Type != OrbwalkerType.AfterAttack)
{
return;
}
havePassive = false;
if (Args.Target == null || Args.Target.IsDead || !Args.Target.IsValidTarget() || Args.Target.Health <= 0)
{
return;
}
switch (Args.Target.Type)
{
case GameObjectType.AIHeroClient:
{
if (Orbwalker.ActiveMode == OrbwalkerMode.Combo)
{
var target = Args.Target as AIHeroClient;
if (target != null && target.IsValidTarget())
{
if (ComboOption.GetBool("ComboEReset").Enabled&& E.IsReady())
{
ResetELogic(target);
}
else if (ComboOption.UseQ && Q.IsReady() && target.IsValidTarget(Q.Range))
{
Q.CastOnUnit(target);
}
else if (ComboOption.UseW && W.IsReady())
{
if (ComboOption.GetBool("ComboWLogic").Enabled)
{
W2.Cast(target.PreviousPosition);
}
else
{
var wPred = W.GetPrediction(target);
if (wPred.Hitchance >= HitChance.High)
{
W.Cast(wPred.UnitPosition);
}
}
}
}
}
}
break;
case GameObjectType.AIMinionClient:
{
if (Orbwalker.ActiveMode == OrbwalkerMode.LaneClear)
{
var mob = (AIMinionClient)Args.Target;
if (mob != null && mob.IsValidTarget() && mob.GetJungleType() != JungleType.Unknown && MyManaManager.SpellFarm && JungleClearOption.HasEnouguMana())
{
if (JungleClearOption.UseE && E.IsReady())
{
E.Cast(Me.PreviousPosition.Extend(Game.CursorPos, 130));
}
else if (JungleClearOption.UseQ && Q.IsReady())
{
Q.CastOnUnit(mob);
}
else if (JungleClearOption.UseW && W.IsReady())
{
W2.Cast(mob.PreviousPosition);
}
}
}
}
break;
case GameObjectType.AITurretClient:
case GameObjectType.HQClient:
case GameObjectType.Barracks:
case GameObjectType.BarracksDampenerClient:
case GameObjectType.BuildingClient:
{
if (Orbwalker.ActiveMode == OrbwalkerMode.LaneClear && MyManaManager.SpellFarm && LaneClearOption.HasEnouguMana(true))
{
if (Me.CountEnemyHeroesInRange(800) == 0)
{
if (LaneClearOption.UseE && E.IsReady())
{
E.Cast(Me.PreviousPosition.Extend(Game.CursorPos, 130));
}
else if (LaneClearOption.UseW && W.IsReady())
{
W.Cast(Game.CursorPos);
}
}
}
}
break;
}
}
private static void OnAction(object sender, OrbwalkerActionArgs Args)
{
if (Args.Type == OrbwalkerType.NonKillableMinion)
{
if (Me.IsDead || Me.IsRecalling() || !Me.CanMoveMent())
{
return;
}
if (Orbwalker.ActiveMode == OrbwalkerMode.Combo)
{
return;
}
if (LastHitOption.HasEnouguMana && LastHitOption.UseE && E.IsReady())
{
var minion = Args.Target as AIMinionClient;
if (minion != null && minion.IsValidTarget(E.Range) && Me.CountEnemyHeroesInRange(600) == 0 &&
minion.Health < E.GetKalistaRealDamage(minion))
{
E.Cast();
}
}
}
if (Args.Type == OrbwalkerType.BeforeAttack)
{
if (MiscOption.GetBool("Forcus", "ForcusAttack").Enabled&& Me.CanMoveMent() && Args.Target != null &&
!Args.Target.IsDead && Args.Target.Health > 0)
{
if (Orbwalker.ActiveMode == OrbwalkerMode.Combo || Orbwalker.ActiveMode == OrbwalkerMode.Harass)
{
foreach (var target in GameObjects.EnemyHeroes.Where(x => !x.IsDead &&
x.InAutoAttackRange() &&
x.Buffs.Any(
a =>
a.Name.ToLower()
.Contains(
"kalistacoopstrikemarkally"))))
{
if (!target.IsDead && target.IsValidTarget(Me.GetRealAutoAttackRange(target)))
{
Orbwalker.ForceTarget = target;
LastForcusTime = Variables.GameTimeTickCount;
}
}
}
else if (Orbwalker.ActiveMode == OrbwalkerMode.LaneClear)
{
foreach (var target in GameObjects.Minions.Where(x => !x.IsDead && x.IsEnemy &&
x.InAutoAttackRange() &&
x.Buffs.Any(
a =>
a.Name.ToLower()
.Contains(
"kalistacoopstrikemarkally"))))
{
if (!target.IsDead && target.IsValidTarget(Me.GetRealAutoAttackRange(target)))
{
Orbwalker.ForceTarget = target;
LastForcusTime = Variables.GameTimeTickCount;
}
}
}
}
}
if (Args.Type == OrbwalkerType.AfterAttack)
{
Orbwalker.ForceTarget = null;
if (Args.Target == null || Args.Target.IsDead || Args.Target.Health <= 0 || Me.IsDead || !Q.IsReady())
{
return;
}
switch (Args.Target.Type)
{
case GameObjectType.AIHeroClient:
{
var target = (AIHeroClient)Args.Target;
if (target != null && !target.IsDead && target.IsValidTarget(Q.Range))
{
if (Orbwalker.ActiveMode == OrbwalkerMode.Combo)
{
if (ComboOption.UseQ)
{
var qPred = Q.GetPrediction(target);
if (qPred.Hitchance >= HitChance.High)
{
Q.Cast(qPred.CastPosition);
}
}
}
else if (HarassOption.HasEnouguMana() &&
(Orbwalker.ActiveMode == OrbwalkerMode.Harass ||
Orbwalker.ActiveMode == OrbwalkerMode.LaneClear && MyManaManager.SpellHarass))
{
if (HarassOption.UseQ)
{
var qPred = Q.GetPrediction(target);
if (qPred.Hitchance >= HitChance.High)
{
Q.Cast(qPred.CastPosition);
}
}
}
}
}
break;
case GameObjectType.AIMinionClient:
{
if (MyManaManager.SpellFarm && Orbwalker.ActiveMode == OrbwalkerMode.LaneClear &&
JungleClearOption.HasEnouguMana())
{
var mob = (AIMinionClient)Args.Target;
if (mob != null && mob.IsValidTarget(Q.Range) && mob.GetJungleType() != JungleType.Unknown)
{
if (JungleClearOption.UseQ)
{
Q.Cast(mob);
}
}
}
}
break;
}
}
}
private static void OnAction(object sender, OrbwalkerActionArgs Args)
{
if (Args.Type == OrbwalkerType.BeforeAttack)
{
if (Args.Target == null || Args.Target.IsDead || !Args.Target.IsValidTarget() || Args.Target.Health <= 0)
{
return;
}
switch (Args.Target.Type)
{
case GameObjectType.AIHeroClient:
{
var target = (AIHeroClient)Args.Target;
if (target != null && target.IsValidTarget())
{
if (Orbwalker.ActiveMode == OrbwalkerMode.Combo)
{
if (ComboOption.UseW && W.IsReady())
{
W.Cast();
}
}
}
}
break;
case GameObjectType.AIMinionClient:
{
if (Orbwalker.ActiveMode == OrbwalkerMode.LaneClear)
{
var mob = (AIMinionClient)Args.Target;
if (mob != null && mob.IsValidTarget() && mob.GetJungleType() != JungleType.Unknown &&
mob.GetJungleType() != JungleType.Small)
{
if (JungleClearOption.HasEnouguMana() && GetPassiveCount < 3)
{
if (JungleClearOption.UseW && W.IsReady())
{
W.Cast();
}
}
}
}
}
break;
case GameObjectType.AITurretClient:
case GameObjectType.HQClient:
case GameObjectType.Barracks:
case GameObjectType.BarracksDampenerClient:
case GameObjectType.BuildingClient:
{
if (Orbwalker.ActiveMode == OrbwalkerMode.LaneClear && MyManaManager.SpellFarm && LaneClearOption.HasEnouguMana(true))
{
if (Me.CountEnemyHeroesInRange(800) == 0)
{
if (LaneClearOption.UseW && W.IsReady())
{
W.Cast();
}
}
}
}
break;
}
}
if (Args.Type == OrbwalkerType.AfterAttack)
{
if (Args.Target == null || Args.Target.IsDead || !Args.Target.IsValidTarget() || Args.Target.Health <= 0)
{
return;
}
switch (Args.Target.Type)
{
case GameObjectType.AIHeroClient:
{
var target = (AIHeroClient)Args.Target;
if (target != null && target.IsValidTarget())
{
if (Orbwalker.ActiveMode == OrbwalkerMode.Combo)
{
if (ComboOption.UseQ && Q.IsReady())
{
if (!isWActive)
{
var qPred = Q.GetPrediction(target);
if (qPred.Hitchance >= HitChance.High)
{
Q.Cast(qPred.CastPosition);
}
}
}
if (ComboOption.UseW && W.IsReady())
{
W.Cast();
}
}
else if (Orbwalker.ActiveMode == OrbwalkerMode.Harass ||
Orbwalker.ActiveMode == OrbwalkerMode.LaneClear && MyManaManager.SpellHarass)
{
if (HarassOption.HasEnouguMana() && HarassOption.GetHarassTargetEnabled(target.CharacterName))
{
if (HarassOption.UseQ && Q.IsReady())
{
var qPred = Q.GetPrediction(target);
if (qPred.Hitchance >= HitChance.High)
{
Q.Cast(qPred.CastPosition);
}
}
}
}
}
}
break;
}
}
}
private static void OnActionDelegate(Object sender, OrbwalkerActionArgs args)
{
if (args.Type == OrbwalkerType.AfterAttack)
{
if (
((Orbwalker.ActiveMode == OrbwalkerMode.Combo &&
checkFuryMode(SpellSlot.W, (AIBaseClient)args.Target)) ||
Orbwalker.ActiveMode == OrbwalkerMode.Harass))
{
//var time = Game.Time - W.Instance.CooldownExpires;
//if (W.Instance.Cooldown - Math.Abs(time) < 1 || time < -6 || player.HealthPercent < 50)
//{
castHydra(args.Target);
//}
}
if (args.Target is AIHeroClient && Orbwalker.ActiveMode == OrbwalkerMode.Combo &&
config["csettings"].GetValue <MenuBool>("usew") && checkFuryMode(SpellSlot.W, (AIBaseClient)args.Target))
{
if (W.Cast())
{
Orbwalker.ResetAutoAttackTimer();
}
return;
}
if (args.Target is AIHeroClient && Orbwalker.ActiveMode == OrbwalkerMode.Harass &&
config["Hsettings"].GetValue <MenuList>("useCH").SelectedValue == "Use harass combo")
{
if (W.IsReady())
{
if (W.Cast())
{
Orbwalker.ResetAutoAttackTimer();
}
return;
}
if (Q.IsReady())
{
Q.Cast();
return;
}
if (E.CanCast((AIBaseClient)args.Target))
{
E.Cast(args.Target.Position);
return;
}
}
return;
}
if (args.Type == OrbwalkerType.BeforeAttack)
{
if (W.IsReady() && Orbwalker.ActiveMode == OrbwalkerMode.Combo &&
args.Target is AIHeroClient && checkFuryMode(SpellSlot.W, (AIBaseClient)args.Target) &&
config["csettings"].GetValue <MenuBool>("usew") && player.Mana > 50)
{
//Game.Print("use w before go");
if ((player.Mana > 40 && !fury) || (Q.IsReady() && canBeOpWIthQ(player.Position)))
{
return;
}
W.Cast();
return;
}
if (W.IsReady() && Orbwalker.ActiveMode == OrbwalkerMode.Harass &&
config["Hsettings"].GetValue <MenuBool>("usewH") && args.Target is AIHeroClient &&
config["Hsettings"].GetValue <MenuList>("useCH").SelectedValue != "Use harass combo")
{
W.Cast();
}
}
}
internal static void Orbwalk(AttackableUnit target = null, Vector3? position = null)
{
if (CanAttack)
{
var gTarget = target ?? GetTarget(ActiveMode);
if (gTarget.IsValidTarget())
{
var eventArgs = new OrbwalkerActionArgs
{
Target = gTarget, Position = gTarget.Position, Process = true,
Type = OrbwalkingType.BeforeAttack
};
InvokeAction(eventArgs);
if (eventArgs.Process)
{
if (Program.Player.CanCancelAutoAttack())
{
LastAutoAttackTick = Variables.TickCount + Game.Ping + 100
- (int)(Program.Player.AttackCastDelay * 1000);
MissileLaunched = false;
var d = gTarget.GetRealAutoAttackRange() - 65;
if (Program.Player.DistanceSquared(gTarget) > d * d && !Program.Player.IsMelee)
{
LastAutoAttackTick = Variables.TickCount + Game.Ping + 400
- (int)(Program.Player.AttackCastDelay * 1000);
}
}
if (!Program.Player.IssueOrder(GameObjectOrder.AttackUnit, gTarget))
{
ResetAutoAttackTimer();
}
LastMovementOrderTick = 0;
LastTarget = gTarget;
return;
}
}
}
if (CanMove)
{
MoveOrder(position.HasValue && position.Value.IsValid() ? position.Value : Game.CursorPos);
}
}
/// <summary>
/// <c>Orbwalk</c> command, attempting to attack or move.
/// </summary>
/// <param name="target">
/// The target of choice
/// </param>
/// <param name="position">
/// The position of choice
/// </param>
public static void Orbwalk(AttackableUnit target = null, Vector3? position = null)
{
if (CanAttack)
{
var gTarget = target ?? GetTarget(ActiveMode);
if (gTarget != null && gTarget.IsValid)
{
var eventArgs = new OrbwalkerActionArgs
{
Target = gTarget, Position = gTarget.Position, Process = true,
Type = OrbwalkerType.BeforeAttack
};
InvokeAction(eventArgs);
if (eventArgs.Process && GameObjects.Player.IssueOrder(GameObjectOrder.AttackUnit, gTarget))
{
lastAutoAttackTick = Variables.TickCount + (Game.Ping / 2);
}
}
}
if (CanMove)
{
MoveOrder(position.HasValue && position.Value.IsValid() ? position.Value : Game.CursorPos);
}
}
private static void OnAction(object sender, OrbwalkerActionArgs Args)
{
if (Args.Type != OrbwalkerType.AfterAttack)
{
return;
}
if (Args.Target == null || Args.Target.IsDead || !Args.Target.IsValidTarget() || Args.Target.Health <= 0)
{
return;
}
switch (Args.Target.Type)
{
case GameObjectType.AIHeroClient:
{
if (Orbwalker.ActiveMode == OrbwalkerMode.Combo)
{
var target = (AIHeroClient)Args.Target;
if (target != null && target.IsValidTarget() && !target.IsUnKillable())
{
if (ComboOption.UseR && R.IsReady() &&
R.Ammo >= ComboOption.GetSlider("ComboRLimit").Value&&
target.IsValidTarget(R.Range) &&
target.HealthPercent <= ComboOption.GetSlider("ComboRHP").Value)
{
var rPred = R.GetPrediction(target);
if (rPred.Hitchance >= HitChance.High)
{
R.Cast(rPred.UnitPosition);
}
}
else if (ComboOption.UseQ && Q.IsReady() && target.IsValidTarget(Q.Range))
{
var qPred = Q.GetPrediction(target);
if (qPred.Hitchance >= HitChance.High)
{
Q.Cast(qPred.CastPosition);
}
}
else if (ComboOption.UseE && E.IsReady() && target.InAutoAttackRange())
{
E.Cast(Me.PreviousPosition);
}
}
}
}
break;
case GameObjectType.AIMinionClient:
{
if (Orbwalker.ActiveMode == OrbwalkerMode.LaneClear)
{
if (Args.Target is AIMinionClient)
{
var mob = (AIMinionClient)Args.Target;
if (mob != null && mob.IsValidTarget() && mob.GetJungleType() != JungleType.Unknown)
{
if (JungleClearOption.HasEnouguMana())
{
if (JungleClearOption.UseR && R.IsReady() &&
R.Ammo >=
JungleClearOption.GetSlider("JungleClearRLimit").Value)
{
R.CastIfHitchanceEquals(mob, HitChance.Medium);
}
else if (JungleClearOption.UseQ && Q.IsReady() && mob.IsValidTarget(Q.Range))
{
Q.CastIfHitchanceEquals(mob, HitChance.Medium);
}
else if (JungleClearOption.UseE && E.IsReady() && mob.InAutoAttackRange())
{
E.Cast(Me.PreviousPosition);
}
}
}
}
}
}
break;
}
}
private static void OnAction(object sender, OrbwalkerActionArgs Args)
{
if (Args.Type != OrbwalkerType.BeforeAttack)
{
return;
}
if (Args.Target == null || Args.Target.IsDead || !Args.Target.IsValidTarget() || Args.Target.Health <= 0)
{
return;
}
switch (Args.Target.Type)
{
case GameObjectType.AIHeroClient:
{
var target = (AIHeroClient)Args.Target;
if (target != null && target.IsValidTarget())
{
if (Orbwalker.ActiveMode == OrbwalkerMode.Combo)
{
if (ComboOption.UseQ && Q.IsReady())
{
if (Me.HasBuff("JinxQ"))
{
if (target.Health < Me.GetAutoAttackDamage(target) * 3 &&
target.DistanceToPlayer() <= Q.Range + 60)
{
Q.Cast();
}
else if (Me.Mana < (rCoolDown == -1 ? 100 : (rCoolDown > 10 ? 130 : 150)))
{
Q.Cast();
}
else if (target.IsValidTarget(Q.Range))
{
Q.Cast();
}
}
else
{
if (target.CountEnemyHeroesInRange(150) >= 2 &&
Me.Mana > R.Mana + Q.Mana * 2 + W.Mana &&
target.DistanceToPlayer() > Q.Range)
{
Q.Cast();
}
}
}
}
else if (Orbwalker.ActiveMode == OrbwalkerMode.Harass ||
Orbwalker.ActiveMode == OrbwalkerMode.LaneClear && MyManaManager.SpellHarass)
{
if (HarassOption.HasEnouguMana())
{
if (HarassOption.UseQ && Q.IsReady())
{
if (Me.HasBuff("JinxQ"))
{
if (target.DistanceToPlayer() >= bigGunRange)
{
Q.Cast();
}
}
else
{
if (target.CountEnemyHeroesInRange(150) >= 2 &&
Me.Mana > R.Mana + Q.Mana * 2 + W.Mana &&
target.DistanceToPlayer() > Q.Range)
{
Q.Cast();
}
}
}
}
else
{
if (Me.HasBuff("JinxQ") && Q.IsReady())
{
Q.Cast();
}
}
}
}
}
break;
case GameObjectType.AIMinionClient:
{
var minion = (AIMinionClient)Args.Target;
if (minion != null && minion.IsMinion())
{
if (LaneClearOption.HasEnouguMana() && Q.IsReady() && LaneClearOption.UseQ)
{
var min = (AIBaseClient)Args.Target;
var minions =
GameObjects.EnemyMinions.Where(x => x.IsValidTarget(bigGunRange) && x.IsMinion())
.ToList();
if (minions.Any() && min != null)
{
foreach (var m in minions.Where(x => x.NetworkId != min.NetworkId))
{
var count =
ObjectManager.Get <AIMinionClient>().Count(x => x.Distance(m) <= 150);
if (m.DistanceToPlayer() <= bigGunRange)
{
if (Me.HasBuff("JinxQ"))
{
if (LaneClearOption.GetSlider("LaneClearQCount").Value > count)
{
Q.Cast();
}
else if (min.Health > Me.GetAutoAttackDamage(min) * 1.1f)
{
Q.Cast();
}
}
else if (!Me.HasBuff("JinxQ"))
{
if (LaneClearOption.GetSlider("LaneClearQCount").Value <= count)
{
Q.Cast();
}
else if (min.Health < Me.GetAutoAttackDamage(min) * 1.1f &&
min.DistanceToPlayer() > Q.Range)
{
Q.Cast();
}
}
}
}
if (minions.Count <= 2 && Me.HasBuff("JinxQ"))
{
Q.Cast();
}
}
}
else
{
if (Me.HasBuff("JinxQ") && Q.IsReady())
{
Q.Cast();
}
}
}
}
break;
}
}
/// <summary>
/// <c>Orbwalk</c> command, attempting to attack or move.
/// </summary>
/// <param name="target">
/// The target of choice
/// </param>
/// <param name="position">
/// The position of choice
/// </param>
public static void Orbwalk(AttackableUnit target = null, Vector3? position = null)
{
if (CanAttack)
{
var gTarget = target ?? GetTarget(ActiveMode);
if (gTarget.IsValidTarget())
{
var eventArgs = new OrbwalkerActionArgs
{
Target = gTarget,
Position = gTarget.Position,
Process = true,
Type = OrbwalkerType.BeforeAttack
};
InvokeAction(eventArgs);
if (eventArgs.Process)
{
if (GameObjects.Player.CanCancelAutoAttack())
{
//LastAutoAttackTick = Variables.TickCount + Game.Ping + 250
// - (int)(GameObjects.Player.AttackCastDelay * 1000);
MissileLaunched = false;
}
GameObjects.Player.IssueOrder(GameObjectOrder.AttackUnit, gTarget);
LastTarget = gTarget;
return;
}
}
}
if (CanMove)
{
MoveOrder(position.HasValue && position.Value.IsValid() ? position.Value : Game.CursorPos);
}
}
private static void OnAction(object sender, OrbwalkerActionArgs args)
{
}
private static void InvokeAction(OrbwalkerActionArgs e)
{
OnAction?.Invoke(e);
}
private static void InvokeAction(OrbwalkerActionArgs e)
{
OnAction?.Invoke(e);
}
/// <summary>
/// Orders a move onto the player, with the <c>orbwalker</c> parameters.
/// </summary>
/// <param name="position">
/// The position to <c>orbwalk</c> to
/// </param>
public static void MoveOrder(Vector3 position)
{
if (position.Distance(GameObjects.Player.Position)
> GameObjects.Player.BoundingRadius + Menu["advanced"]["movementExtraHold"].GetValue<MenuSlider>().Value)
{
if (position.Distance(GameObjects.Player.Position)
> Menu["advanced"]["movementMaximumDistance"].GetValue<MenuSlider>().Value)
{
var menuItem = Menu["advanced"]["movementMaximumDistance"].GetValue<MenuSlider>();
var randomDistance = new Random(Variables.TickCount).Next(0, 50);
position = menuItem.Value - randomDistance <= GameObjects.Player.BoundingRadius
? GameObjects.Player.Position.Extend(
position,
GameObjects.Player.BoundingRadius + randomDistance)
: GameObjects.Player.Position.Extend(position, menuItem.Value - randomDistance);
}
if (Menu["advanced"]["movementScramble"].GetValue<MenuBool>().Value)
{
var random = new Random(Variables.TickCount);
var angle = 2D * System.Math.PI * random.NextDouble();
var radius = GameObjects.Player.Distance(Game.CursorPos) < 360
? 0F
: GameObjects.Player.BoundingRadius / 2f;
var x = (float)(position.X + radius * System.Math.Cos(angle));
var y = (float)(position.Y + radius * System.Math.Sin(angle));
position = new Vector3(x, y, NavMesh.GetHeightForPosition(x, y));
}
var eventArgs = new OrbwalkerActionArgs
{
Position = position, Process = true, Type = OrbwalkerType.Movement
};
InvokeAction(eventArgs);
if (eventArgs.Process && GameObjects.Player.IssueOrder(GameObjectOrder.MoveTo, eventArgs.Position))
{
lastMovementOrderTick = Variables.TickCount;
}
}
}
private static void OnAction(object sender, OrbwalkerActionArgs Args)
{
if (Args.Type != OrbwalkerType.AfterAttack)
{
return;
}
if (Args.Target == null || Args.Target.IsDead || !Args.Target.IsValidTarget() ||
Args.Target.Health <= 0 || Orbwalker.ActiveMode == OrbwalkerMode.None)
{
return;
}
switch (Args.Target.Type)
{
case GameObjectType.AIHeroClient:
{
if (Orbwalker.ActiveMode == OrbwalkerMode.Combo)
{
if (ComboOption.UseW && W.IsReady())
{
var target = (AIHeroClient)Args.Target;
if (target != null && target.InAutoAttackRange())
{
W.Cast();
}
}
}
}
break;
case GameObjectType.AIMinionClient:
{
if (Orbwalker.ActiveMode == OrbwalkerMode.LaneClear)
{
var minion = (AIMinionClient)Args.Target;
if (minion != null && minion.IsValidTarget())
{
if (minion.IsMinion())
{
if (LaneClearOption.HasEnouguMana() && LaneClearOption.UseW && W.IsReady())
{
var minions =
GameObjects.EnemyMinions.Count(
x =>
x.IsValidTarget(Me.AttackRange + Me.BoundingRadius + 200) &&
x.IsMinion());
if (minions >= 3)
{
W.Cast();
}
}
}
else if (minion.GetJungleType() != JungleType.Unknown)
{
if (JungleClearOption.HasEnouguMana() && JungleClearOption.UseW && W.IsReady())
{
if (!minion.InAutoAttackRange() ||
!(minion.Health > Me.GetAutoAttackDamage(minion) * 2) ||
minion.GetJungleType() == JungleType.Small)
{
return;
}
W.Cast();
}
}
}
}
}
break;
case GameObjectType.AITurretClient:
case GameObjectType.HQClient:
case GameObjectType.Barracks:
case GameObjectType.BarracksDampenerClient:
case GameObjectType.BuildingClient:
{
if (Orbwalker.ActiveMode == OrbwalkerMode.LaneClear)
{
if (LaneClearOption.HasEnouguMana(true) && LaneClearOption.UseW && W.IsReady())
{
if (Me.CountEnemyHeroesInRange(850) == 0)
{
W.Cast();
}
}
}
}
break;
}
}
/// <summary>
/// The <see cref="OnAction" /> invocator.
/// </summary>
/// <param name="e">
/// The event data.
/// </param>
protected static void InvokeAction(OrbwalkerActionArgs e)
{
if (OnAction != null)
{
OnAction(MethodBase.GetCurrentMethod().DeclaringType, e);
}
}
public static void OnAction(object sender, OrbwalkerActionArgs args)
{
switch (args.Type)
{
case OrbwalkerType.BeforeAttack:
if (Orbwalker.ActiveMode == OrbwalkerMode.Combo)
{
if (MenuSettings.Combo.AA.Enabled)
{
if (MenuSettings.Combo.AALackOfMana.Enabled && objPlayer.Mana <= 100)
{
return;
}
args.Process = false;
}
}
if (Orbwalker.ActiveMode == OrbwalkerMode.Harass)
{
if (MenuSettings.Harass.AA.Enabled)
{
args.Process = false;
}
}
else if (Orbwalker.ActiveMode == OrbwalkerMode.LaneClear)
{
if (MenuSettings.Keys.aaFarmToggle.Active)
{
return;
}
if (MenuSettings.Keys.farmToggle.Active && (args.Target.Type == GameObjectType.AIMinionClient || args.Target.Type == GameObjectType.NeutralMinionCampClient))
{
if (objPlayer.Mana < 200)
{
return;
}
args.Process = false;
}
}
else if (Orbwalker.ActiveMode == OrbwalkerMode.LastHit)
{
if (MenuSettings.LastHit.UseQ.Enabled && Q.IsReady())
{
if (objPlayer.ManaPercent < MenuSettings.LastHit.MinMana.Value)
{
return;
}
var target = (AIBaseClient)args.Target;
if (args.Target.Health > objPlayer.GetAutoAttackDamage(target) || MenuSettings.Keys.aaFarmToggle.Active)
{
return;
}
if (MenuSettings.Keys.aaFarmToggle.Active && (args.Target.Type == GameObjectType.AIMinionClient || args.Target.Type == GameObjectType.NeutralMinionCampClient))
{
if (objPlayer.Mana < 200)
{
return;
}
args.Process = false;
}
}
}
break;
}
}
