private static void BeforeAttack(BeforeAttackEventArgs Args)
{
if (!Args.Unit.IsMe || Me.IsDead || Args.Target == null || Args.Target.ObjectType != GameObjectType.AIHeroClient)
{
return;
}
if (isComboMode)
{
if (ComboOption.UseQ && Q.IsReady() && AxeCount < ComboOption.GetSlider("MaxAxeCount"))
{
var target = Args.Target as AIHeroClient;
if (target.IsValidTarget())
{
Q.Cast();
}
}
}
else if (isHarassMode || isFarmMode && MyManaManager.SpellHarass)
{
if (HarassOption.HasEnouguMana)
{
if (HarassOption.UseQ && Q.IsReady() && AxeCount < 2)
{
var target = Args.Target as AIHeroClient;
if (target.IsValidTarget())
{
Q.Cast();
}
}
}
}
}
private static void Orbwalker_OnBeforeAttack(object sender, BeforeAttackEventArgs e)
{
if (Player.HavePassive() && Variables.TickCount - Last_E >= 1000)
{
CanUseQNow = true;
}
}
private static void BeforeAttack(BeforeAttackEventArgs Args)
{
if (!Args.Unit.IsMe)
{
return;
}
if (MiscOption.GetBool("Forcus"))
{
if (isComboMode || isHarassMode)
{
foreach (var enemy in ObjectManager.Heroes.Enemies.Where(x => !x.IsDead && !x.IsZombie && HavePassive(x)))
{
myOrbwalker.ForceTarget(enemy);
}
}
if (isLaneClearMode || isJungleClearMode)
{
var all = MinionManager.GetMinions(Me.Position, Orbwalker.GetRealAutoAttackRange(Me),
MinionTypes.All, MinionTeam.NotAlly).Where(HavePassive).ToArray();
if (all.Any())
{
myOrbwalker.ForceTarget(all.FirstOrDefault());
}
}
}
}
private static void BeforeAttack(BeforeAttackEventArgs Args)
{
if (MiscOption.GetBool("Forcus"))
{
if (isComboMode || isHarassMode)
{
foreach (var target in ObjectManager.Heroes.Enemies.Where(x => !x.IsDead && !x.IsZombie &&
Orbwalker.InAutoAttackRange(x) &&
x.HasBuff("kalistacoopstrikemarkally"))
)
{
if (!target.IsDead && target.IsValidTarget(Orbwalker.GetRealAutoAttackRange(target)))
{
myOrbwalker.ForceTarget(target);
}
}
}
else if (isLaneClearMode || isJungleClearMode)
{
var minion = MinionManager
.GetMinions(Me.Position, Orbwalker.GetRealAutoAttackRange(Me),
MinionTypes.All, MinionTeam.NotAlly)
.FirstOrDefault(x => Orbwalker.InAutoAttackRange(x) && x.HasBuff("kalistacoopstrikemarkally"));
if (minion != null && minion.IsValidTarget(Orbwalker.GetRealAutoAttackRange(minion)))
{
myOrbwalker.ForceTarget(minion);
}
}
}
}
private static void OnBeforeAttack(object sender, BeforeAttackEventArgs args)
{
if (Orbwalker.ActiveMode == OrbwalkerMode.Combo)
{
Combo.CastQ(args);
}
}
protected static bool ProcessBeforeAttack(IAttackable target)
{
var args = new BeforeAttackEventArgs(target);
BeforeAttack.SafeInvoke(args);
return(!args.IsBlocked);
}
public bool Attack(BattleUnitsStack target)
{
if (_state != BattleState.InGame)
{
return(false);
}
var source = GetCurrentStack();
if (source.GetArmy() == target.GetArmy())
{
return(false);
}
var hitPoints = DamageUtils.CalcDamageHitPoints(source, target);
// Fire before attack event
var beforeAttackEventArgs = new BeforeAttackEventArgs(source, target, hitPoints);
EventBus.OnBeforeAttack(this, beforeAttackEventArgs);
if (beforeAttackEventArgs.Cancel)
{
return(false);
}
hitPoints = beforeAttackEventArgs.HitPoints;
target.Damage(hitPoints);
// Fire after attack event
EventBus.OnAfterAttack(this, new AfterAttackEventArgs(source, target, hitPoints));
if (target.IsAlive() && !target.IsAnswered())
{
var answerHitPoints = DamageUtils.CalcDamageHitPoints(target, source);
// Fire before answer event
var beforeAnswerEventArgs = new BeforeAnswerEventArgs(source, target, answerHitPoints);
EventBus.OnBeforeAnswer(this, beforeAnswerEventArgs);
if (!beforeAnswerEventArgs.Cancel)
{
answerHitPoints = beforeAnswerEventArgs.HitPoints;
source.Damage(answerHitPoints);
target.SetAnswered(beforeAnswerEventArgs.IsAnswered);
// Fire after answer event
EventBus.OnAfterAnswer(this,
new AfterAnswerEventArgs(source, target, hitPoints, beforeAnswerEventArgs.IsAnswered));
}
}
NextTurn();
return(true);
}
public static void CastW(BeforeAttackEventArgs args)
{
if (!ComboMenu.WBool.Enabled)
{
return;
}
W.Cast();
}
private static void BeforeAttack(BeforeAttackEventArgs Args)
{
if (Me.IsDead)
{
return;
}
Args.Process = !Q.IsCharging;
}
public static void CastQ(BeforeAttackEventArgs args)
{
if (ComboMenu.QList.Index != 0 || !Q.IsReady())
{
return;
}
Q.Cast();
}
private static void OnBeforeAttack(object sender, BeforeAttackEventArgs e)
{
if (e.Target.GetType() != typeof(AIHeroClient) || Orbwalker.ActiveMode != OrbwalkerMode.Combo || !mainMenu.GetValue <MenuBool>("useQCombo").Enabled)
{
return;
}
if (Q.IsReady())
{
Q.Cast();
}
}
public static void CastE(BeforeAttackEventArgs args)
{
var target = args.Target as AIHeroClient;
if (target == null)
{
return;
}
if (ComboMenu.EBool.Enabled)
{
E.CastOnUnit(target);
}
}
public static void CastQ(BeforeAttackEventArgs args)
{
var target = args.Target as AIHeroClient;
if (target == null)
{
return;
}
if (ComboMenu.QBool.Enabled)
{
Q.Cast();
}
}
private static void CastE(BeforeAttackEventArgs args)
{
if (!StructureclearMenu.ESliderButton.Enabled)
{
return;
}
if (StructureclearMenu.ESliderButton.Value >= Player.ManaPercent)
{
return;
}
E.CastOnUnit(args.Target);
}
public static void CastQ(BeforeAttackEventArgs args)
{
if (!JungleclearMenu.QSliderButton.Enabled)
{
return;
}
if (JungleclearMenu.QSliderButton.Value >= Player.ManaPercent)
{
return;
}
Q.CastOnUnit(args.Target);
}
private static void Orbwalker_OnBeforeAttack(object sender, BeforeAttackEventArgs e)
{
if (aaa == true)
{
aaa = false;
}
if (baa == false)
{
baa = true;
}
if (oaa == true)
{
oaa = false;
}
}
public static void CastQ(BeforeAttackEventArgs args)
{
var target = args.Target as AIBaseClient;
if (!Extension.Has4Shot() || target.Health <= Player.GetAutoAttackDamage(target))
{
return;
}
if (!ComboMenu.QBool.Enabled)
{
return;
}
Q.CastOnUnit(target);
}
private static void OnBeforeAttack(object sender, BeforeAttackEventArgs args)
{
Laneclear.CastQAOE();
if (!Extension.ActivatedRockets)
{
return;
}
switch (args.Target)
{
case AITurretClient _:
case AIMinionClient _ when Orbwalker.ActiveMode == OrbwalkerMode.Harass:
Q.Cast();
break;
}
}
private static void OnBeforeAttack(object sender, BeforeAttackEventArgs args)
{
if (Extension.IsUltShooting())
{
args.Process = true;
}
switch (Orbwalker.ActiveMode)
{
case OrbwalkerMode.Combo:
if (Q.IsReady())
{
Extra.CastQ(args);
}
break;
}
}
private static void OnBeforeAA(object sender, BeforeAttackEventArgs args)
{
var target = TargetSelector.GetTarget(1000f);
if (target != null)
{
if (Orbwalker.ActiveMode == OrbwalkerMode.Combo && (Q.IsReady() || W.IsReady()) && myhero.IsFacing(target) && myhero.InAutoAttackRange(target))
{
args.Process = false;
}
if (Orbwalker.ActiveMode == OrbwalkerMode.LaneClear && Q.IsReady() && comb(laneclear, "lq") == 2)
{
args.Process = false;
}
}
}
public static void Cast(BeforeAttackEventArgs args)
{
if (StructureclearMenu.NoEnemiesRange.Enabled &&
(Player.CountEnemyHeroesInRange(Player.GetRealAutoAttackRange()) >=
StructureclearMenu.NoEnemiesRange.Value))
{
return;
}
var turret = GameObjects.EnemyTurrets.FirstOrDefault(x => x.IsValidTarget(Player.GetRealAutoAttackRange()));
if (turret == null)
{
return;
}
CastQ();
CastE(args);
}
public static void Before_Attack(BeforeAttackEventArgs ArgsTarget)
{
if (Orb.ActiveMode.Equals(Orbwalker.OrbwalkingMode.Combo) && ComboMenu.GetCheckbox("useW"))
{
W.Cast();
}
if (Orb.ActiveMode.Equals(Orbwalker.OrbwalkingMode.Harass) && HarassMenu.GetCheckbox("useW"))
{
W.Cast();
}
if (Orb.ActiveMode.Equals(Orbwalker.OrbwalkingMode.LaneClear) && LaneclearMenu.GetCheckbox("useW"))
{
W.Cast();
}
if (Orb.ActiveMode.Equals(Orbwalker.OrbwalkingMode.JungleClear) && JungleclearMenu.GetCheckbox("useW"))
{
W.Cast();
}
}
public static void CastQ(BeforeAttackEventArgs args)
{
if (!HarassMenu.QSliderButton.Enabled)
{
return;
}
if (HarassMenu.QSliderButton.Value >= Player.ManaPercent)
{
return;
}
var target = args.Target as AIHeroClient;
if (target == null)
{
return;
}
Q.Cast();
}
private static void BeforeAttack(BeforeAttackEventArgs Args)
{
if (!Args.Unit.IsMe)
{
return;
}
if (isComboMode || isHarassMode)
{
var ForcusTarget = ObjectManager.Heroes.Enemies.FirstOrDefault(x => x.IsValidTarget(Me.AttackRange + Me.BoundingRadius) && Has2WStacks(x));
if (MiscOption.GetBool("ForcusAttack") && ForcusTarget != null && ForcusTarget.IsValidTarget(Me.AttackRange + Me.BoundingRadius - ForcusTarget.BoundingRadius + 15))
{
myOrbwalker.ForceTarget(ForcusTarget);
}
else
{
myOrbwalker.ForceTarget(null);
}
}
}
private static void OnBeforeAA(object sender, BeforeAttackEventArgs args)
{
var target = TargetSelector.GetTarget(1000f);
if (target != null)
{
if (Orbwalker.ActiveMode == OrbwalkerMode.Combo && (Q.IsReady() || W.IsReady()) && myhero.IsFacing(target) && target.InAARangeOf(myhero))
{
args.Process = false;
}
if (Orbwalker.ActiveMode == OrbwalkerMode.LaneClear && Q.IsReady() && comb(laneclear, "lq") == 2 && myhero.ManaPercent >= slider(laneclear, "manamin"))
{
args.Process = false;
}
}
if (Orbwalker.ActiveMode == OrbwalkerMode.Combo && combo.check("cnaa"))
{
args.Process = false;
}
}
private static void BeforeAttack(BeforeAttackEventArgs Args)
{
if (!Args.Unit.IsMe || Me.IsDead || Args.Target == null || !Args.Target.IsValidTarget() || !isLaneClearMode)
{
return;
}
if (LaneClearOption.HasEnouguMana)
{
if (LaneClearOption.UseW && W.IsReady() && Me.CountEnemiesInRange(850) == 0)
{
if (Args.Target.ObjectType == GameObjectType.obj_AI_Turret || Args.Target.ObjectType == GameObjectType.obj_Barracks ||
Args.Target.ObjectType == GameObjectType.obj_HQ || Args.Target.ObjectType == GameObjectType.obj_Turret ||
Args.Target.ObjectType == GameObjectType.obj_BarracksDampener)
{
if (W.IsReady() && Me.CountAlliesInRange(W.Range) >= 1)
{
W.Cast(ObjectManager.Heroes.Allies.Find(x => x.DistanceToPlayer() <= W.Range).Position, true);
}
}
}
}
}
private static void Orbwalker_OnBeforeAttack(object sender, BeforeAttackEventArgs e)
{
if (aaa == true)
{
aaa = false;
}
if (baa == false)
{
baa = true;
}
if (oaa == true)
{
oaa = false;
}
if (killminion == true)
{
killminion = false;
}
if (premove == true)
{
premove = false;
}
}
private static void BeforeAttack(BeforeAttackEventArgs Args)
{
if (!Args.Target.IsMe)
{
return;
}
if (isComboMode || isHarassMode)
{
var ForcusETarget =
ObjectManager.Heroes.Enemies.FirstOrDefault(
x =>
x.IsValidTarget(Orbwalker.GetRealAutoAttackRange(Me)) &&
x.HasBuff("kindredecharge"));
var ForcusTarget =
ObjectManager.Heroes.Enemies.FirstOrDefault(
x =>
x.IsValidTarget(Orbwalker.GetRealAutoAttackRange(Me)) &&
x.HasBuff("kindredhittracker"));
if (ForcusETarget.IsValidTarget(Orbwalker.GetRealAutoAttackRange(Me)) &&
MiscOption.GetBool("ForcusE"))
{
myOrbwalker.ForceTarget(ForcusETarget);
}
else if (MiscOption.GetBool("Forcus") &&
ForcusTarget.IsValidTarget(Orbwalker.GetRealAutoAttackRange(Me)))
{
myOrbwalker.ForceTarget(ForcusTarget);
}
else
{
myOrbwalker.ForceTarget(null);
}
}
}
public static void CastE(BeforeAttackEventArgs args)
{
if (!LaneclearMenu.ESliderButton.Enabled)
{
return;
}
if (LaneclearMenu.ESliderButton.Value >= Player.ManaPercent)
{
return;
}
var bestMinion = GameObjects.EnemyMinions.FirstOrDefault(x =>
x.IsValidTarget(Player.GetRealAutoAttackRange()) &&
CountInRange(x, 300, GameObjects.EnemyMinions) >=
LaneclearMenu.EMinionSlider.Value);
if (bestMinion == null)
{
return;
}
E.CastOnUnit(bestMinion);
}
private static void BeforeAttack(BeforeAttackEventArgs Args)
{
if (!Args.Unit.IsMe)
{
return;
}
if (isComboMode)
{
if (MiscOption.GetBool("Forcustarget"))
{
foreach (
var enemy in
ObjectManager.Heroes.Enemies.Where(
enemy => Orbwalker.InAutoAttackRange(enemy) && enemy.HasBuff("TristanaEChargeSound")))
{
myOrbwalker.ForceTarget(enemy);
}
}
if (ComboOption.UseQ && Q.IsReady())
{
if (ComboOption.GetBool("ComboQAlways"))
{
var Target = Args.Target.ObjectType == GameObjectType.AIHeroClient
? (AIHeroClient)Args.Target
: null;
if (Target != null &&
(Target.HasBuff("TristanaEChargeSound") || Target.HasBuff("TristanaECharge")))
{
Q.Cast();
}
}
else
{
Q.Cast();
}
}
}
else if (isHarassMode)
{
if (MiscOption.GetBool("Forcustarget"))
{
foreach (
var enemy in
ObjectManager.Heroes.Enemies.Where(
enemy => Orbwalker.InAutoAttackRange(enemy) && enemy.HasBuff("TristanaEChargeSound")))
{
myOrbwalker.ForceTarget(enemy);
}
}
}
else if (isJungleClearMode && JungleClearOption.HasEnouguMana)
{
if (JungleClearOption.UseQ && Q.IsReady())
{
var minion =
MinionManager.GetMinions(Orbwalker.GetRealAutoAttackRange(ObjectManager.Player),
MinionTypes.All, MinionTeam.Neutral, MinionOrderTypes.MaxHealth);
if (minion.Any(x => x.NetworkId == Args.Target.NetworkId))
{
Q.Cast();
}
}
}
}
private static void Orbwalking_BeforeAttack(BeforeAttackEventArgs args)
{
}