private void afterAttack(AttackableUnit unit, AttackableUnit target)
{
if (!unit.IsMe)
return;
if(Config.Item("autoE", true).GetValue<bool>())
LogicE();
}
private void Orbwalking_AfterAttack(AttackableUnit unit, AttackableUnit target)
{
switch (orbwalker.ActiveMode)
{
case Orbwalking.OrbwalkingMode.Combo:
if (config.Item("useq", true).GetValue<bool>() && Q.IsReady() && target is Obj_AI_Hero)
{
Q.Cast(config.Item("packets").GetValue<bool>());
player.IssueOrder(GameObjectOrder.AutoAttack, target);
}
break;
case Orbwalking.OrbwalkingMode.Mixed:
if (config.Item("useqH", true).GetValue<bool>() && Q.IsReady() && target is Obj_AI_Hero &&
config.Item("minmanaH", true).GetValue<Slider>().Value < player.ManaPercent)
{
Q.Cast(config.Item("packets").GetValue<bool>());
player.IssueOrder(GameObjectOrder.AutoAttack, target);
}
break;
case Orbwalking.OrbwalkingMode.LaneClear:
if (config.Item("useqLC", true).GetValue<bool>() && Q.IsReady() &&
config.Item("minmana", true).GetValue<Slider>().Value < player.ManaPercent &&
target.Health <
player.GetAutoAttackDamage((Obj_AI_Base) target) + Q.GetDamage((Obj_AI_Base) target))
{
Q.Cast(config.Item("packets").GetValue<bool>());
player.IssueOrder(GameObjectOrder.AutoAttack, target);
}
break;
default:
break;
}
}
private void afterAttack(AttackableUnit unit, AttackableUnit target)
{
if(Config.Item("afterAA", true).GetValue<bool>() && R.IsReady() && target is Obj_AI_Hero )
{
R.Cast();
}
}
internal static void AfterAttack(AttackableUnit unit, AttackableUnit target)
{
if (target.IsValidTarget() && unit.IsValid<Obj_AI_Hero>() && unit.IsMe)
{
LastTarget = target;
}
}
private void Orbwalking_AfterAttack(AttackableUnit unit, AttackableUnit target)
{
if (Player.ChampionName == "Riven")
return;
if (!Menu.Item("use" + Name).GetValue<bool>() || !IsReady())
return;
var hero = target as Obj_AI_Hero;
if (hero.IsValidTarget(Range))
{
if (!Parent.Item(Parent.Name + "useon" + hero.NetworkId).GetValue<bool>())
return;
if (hero.Health / hero.MaxHealth * 100 <= Menu.Item("enemylowhp" + Name + "pct").GetValue<Slider>().Value)
{
UseItem(Tar.Player, true);
}
if (Player.Health / Player.MaxHealth * 100 <= Menu.Item("selflowhp" + Name + "pct").GetValue<Slider>().Value)
{
UseItem(Tar.Player, true);
}
}
}
private void Orbwalking_AfterAttack(AttackableUnit target, EventArgs args)
{
if (Player.ChampionName == "Riven")
return;
if (!Menu["use" + Name].Cast<CheckBox>().CurrentValue || !IsReady())
return;
var hero = target as AIHeroClient;
if (hero.LSIsValidTarget(Range))
{
if (Activator.omenu[Activator.omenu.UniqueMenuId + "useon" + hero.NetworkId] == null)
{
return;
}
if (!Activator.omenu[Activator.omenu.UniqueMenuId + "useon" + hero.NetworkId].Cast<CheckBox>().CurrentValue)
return;
if (hero.Health / hero.MaxHealth * 100 <= Menu["enemylowhp" + Name + "pct"].Cast<Slider>().CurrentValue)
{
UseItem(Tar.Player, true);
}
if (Player.Health / Player.MaxHealth * 100 <= Menu["selflowhp" + Name + "pct"].Cast<Slider>().CurrentValue)
{
UseItem(Tar.Player, true);
}
}
}
private static void OrbwalkingAfterAttack(AttackableUnit unit, AttackableUnit target)
{
if (!unit.IsMe) return;
if (passiveStacks > 0)
passiveStacks = passiveStacks - 1;
}
/// <summary>
/// Called on orbwalker action.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="target">The target.</param>
public static void Weaving(AttackableUnit sender, AttackableUnit target)
{
var tg = (Obj_AI_Hero)target;
if (TargetSelector.IsInvulnerable(tg, TargetSelector.DamageType.Physical))
{
return;
}
/// <summary>
/// The W Weaving Logic.
/// </summary>
if (Variables.W.IsReady() && Variables.WMenu.Item("combo").IsActive())
{
Variables.W.Cast();
}
/// <summary>
/// The Q Combo Logic.
/// </summary>
if (Variables.Q.IsReady() && Targets.Target.IsValidTarget(Variables.Q.Range)
&& !ObjectManager.Player.HasBuff("RenektonPreExecute") && Variables.QMenu.Item("combo").IsActive())
{
Variables.Q.Cast();
}
}
private static void Orbwalker_OnPostAttack(AttackableUnit target, EventArgs args)
{
bool newtarget = false;
if (Settings.useHarrier && (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo) || Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Harass)))
{
foreach (var e in EntityManager.Heroes.Enemies.Where(t => !t.IsDead && t.IsTargetable && !t.IsZombie && !t.IsInvulnerable && Player.Instance.IsInRange(t, 525)).OrderBy(t => t.MaxHealth))
{
if (e.HasBuff("quinnw"))
{
Orbwalker.ForcedTarget = e;
newtarget = true;
break;
}
}
}
else if (Settings.useHarrier)
{
foreach (var e in EntityManager.MinionsAndMonsters.CombinedAttackable)
{
if (e.HasBuff("quinnw"))
{
Orbwalker.ForcedTarget = e;
newtarget = true;
break;
}
}
}
if (!newtarget)
{
Orbwalker.ForcedTarget = null;
//Orbwalker.ResetAutoAttack();
}
}
protected override void OnAfterAttack(AttackableUnit unit, AttackableUnit target)
{
if (!unit.IsMe) return;
if (unit.IsMe)
{
if (myOrbwalker.ActiveMode == myOrbwalker.OrbwalkingMode.Combo)
{
if (!Player.IsWindingUp && config.Item("UseItemCombo").GetValue<bool>() && Orbwalking.InAutoAttackRange(target))
{
myUtility.UseItems(2, null);
}
}
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))
{
myUtility.UseItems(2, null);
}
}
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.Cast();
}
}
}
}
public static float getLaneClearPred(AttackableUnit unit, int msTime, bool ignoreAlmostDead = true)
{
float predictedDamage = 0;
var damageDoneTill = now + msTime;
foreach (var damager in damagerSources.Values)
{
if(!damager.isValidDamager())
continue;
var target = damager.getTarget();
if(target == null || target.NetworkId != unit.NetworkId || (ignoreAlmostDead && almostDead(damager.source)))
continue;
if (damager.firstHitAt > damageDoneTill)
continue;
predictedDamage += damager.damage;
//Console.WriteLine(damager.damage);
//Can be optimized??
var nextAA = damager.firstHitAt + damager.cycle;
while (damageDoneTill > nextAA)
{
predictedDamage += damager.damage;
nextAA += damager.cycle;
}
}
//if (predictedDamage > 0)
// Console.WriteLine("dmg: " + predictedDamage);
return unit.Health - predictedDamage;
}
private void AfterAttack(AttackableUnit unit, AttackableUnit target)
{
if (ShouldRun())
{
if (!(target is Obj_AI_Hero))
{
return;
}
var TargetHero = (Obj_AI_Hero) target;
var currentMenuItem =
Variables.Menu.Item(
string.Format("dz191.vhr.activator.offensive.youmuu.{0}", Variables.Orbwalker.ActiveMode.ToString().ToLower()));
var currentValue = currentMenuItem != null ? currentMenuItem.GetValue<bool>() : false;
if (currentValue || MenuExtensions.GetItemValue<bool>("dz191.vhr.activator.offensive.youmuu.always"))
{
if (TargetHero.IsValidTarget(ObjectManager.Player.AttackRange + 65f + 65f + 150f))
{
LeagueSharp.Common.Items.UseItem(3142);
}
}
}
}
/// <summary>
/// Called on orbwalker action.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="target">The target.</param>
public static void BuildingClear(AttackableUnit sender, AttackableUnit target)
{
if (!(target is Obj_HQ) && !(target is Obj_AI_Turret) && !(target is Obj_BarracksDampener))
{
return;
}
/// <summary>
/// The E BuildingClear Logic.
/// </summary>
if (Variables.E.IsReady()
&& ObjectManager.Player.ManaPercent
> ManaManager.GetNeededMana(Variables.E.Slot, Variables.EMenu.Item("buildings"))
&& Variables.EMenu.Item("buildings").GetValue<SliderButton>().Value.Item2)
{
Variables.E.Cast(ObjectManager.Player.ServerPosition.Extend(Game.CursorPos, 25));
return;
}
/// <summary>
/// The W BuildingClear Logic.
/// </summary>
if (Variables.W.IsReady()
&& ObjectManager.Player.ManaPercent
> ManaManager.GetNeededMana(Variables.W.Slot, Variables.WMenu.Item("buildings"))
&& Variables.WMenu.Item("buildings").GetValue<SliderButton>().Value.Item2)
{
Variables.W.Cast(Game.CursorPos);
}
}
public static void OnAfterAttack(AttackableUnit target, EventArgs args)
{
if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo) && target.IsValid &&
E.IsReady() &&
GravesTheTrollMeNu.ComboMenu["useEcombo"].Cast<ComboBox>().CurrentValue == 0)
{
E.Cast(Side(Player.Position.To2D(), target.Position.To2D(), 65).To3D());
Orbwalker.ResetAutoAttack();
}
if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo) && E.IsReady() && target.IsValid &&
GravesTheTrollMeNu.ComboMenu["useEcombo"].Cast<ComboBox>().CurrentValue == 1)
{
EloBuddy.Player.CastSpell(SpellSlot.E, Game.CursorPos);
Orbwalker.ResetAutoAttack();
}
if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo) && E.IsReady() && target.IsValid &&
GravesTheTrollMeNu.ComboMenu["useEcombo"].Cast<ComboBox>().CurrentValue == 2)
if (Player.Position.Extend(Game.CursorPos, 700).CountEnemiesInRange(700) <= 1)
{
EloBuddy.Player.CastSpell(SpellSlot.E, Game.CursorPos);
Orbwalker.ResetAutoAttack();
}
if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.JungleClear) && E.IsReady() && target.IsValid && GravesTheTrollMeNu.JungleE())
{
EloBuddy.Player.CastSpell(SpellSlot.E, Game.CursorPos);
Orbwalker.ResetAutoAttack();
}
}
/// <summary>
/// Called on orbwalker action.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="target">The target.</param>
public static void Weaving(AttackableUnit sender, AttackableUnit target)
{
var tg = (Obj_AI_Hero)target;
if (TargetSelector.IsInvulnerable(tg, TargetSelector.DamageType.Physical))
{
return;
}
/// <summary>
/// The Q Weaving Logic.
/// </summary>
if (Variables.Q.IsReady() && Variables.QMenu.Item("combo").IsActive())
{
if (!Variables.Q.GetPrediction(tg).CollisionObjects.Any())
{
Variables.Q.Cast(Variables.Q.GetPrediction(tg).UnitPosition);
return;
}
}
/// <summary>
/// The W Weaving Logic.
/// </summary>
if (Variables.W.IsReady() && Variables.WMenu.Item("combo").IsActive())
{
Variables.W.Cast(Variables.W.GetPrediction(tg).UnitPosition);
}
}
/// <summary>
/// Called on orbwalker action.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="args">The <see cref="OrbwalkingActionArgs" /> instance containing the event data.</param>
public static void OnAction(AttackableUnit target, Orbwalker.PreAttackArgs args)
{
if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo))
{
/// <summary>
/// The 'No AA in Combo' Logic.
/// </summary>
if (Vars.getCheckBoxItem(Vars.MiscMenu, "noaacombo"))
{
if (Vars.Q.IsReady() ||
Vars.W.IsReady() ||
Vars.E.IsReady() ||
!Bools.HasSheenBuff() ||
GameObjects.Player.ManaPercent > 10)
{
args.Process = false;
}
}
}
if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Harass) || Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.LastHit) || Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.LaneClear) || Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.JungleClear))
{
/// <summary>
/// The 'Support Mode' Logic.
/// </summary>
if (Vars.getCheckBoxItem(Vars.MiscMenu, "support"))
{
if (args.Target is Obj_AI_Minion &&
GameObjects.AllyHeroes.Any(a => a.Distance(GameObjects.Player) < 2500))
{
args.Process = false;
}
}
}
}
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();
}
}
}
}
public static void Orbwalker_OnPostAttack(AttackableUnit target, EventArgs args)
{
try
{
if (!Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.JungleClear))
return;
if (Player.Instance.Mana < 5 || ((int) Player.Instance.Mana == 5 && !MenuChecker.JungleClearSaveStacks))
{
if (MenuChecker.JungleClearUseQ && Standarts.Q.IsReady())
{
Standarts.Q.Cast();
}
else
{
if (ItemUsage.CanUse())
ItemUsage.UseItem();
}
}
else
{
if (ItemUsage.CanUse())
ItemUsage.UseItem();
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
protected override void AfterAttack(AttackableUnit unit, AttackableUnit target)
{
var useWCombo = menu.Item("UseWCombo", true).GetValue<bool>();
var useWHarass = menu.Item("UseWHarass", true).GetValue<bool>();
if (unit.IsMe && !HammerTime)
{
if (menu.Item("ComboActive", true).GetValue<KeyBind>().Active)
{
if (_canWcd == 0 && Player.Distance(target.Position) < 600 && !HammerTime && W.Level > 0 && W.IsReady())
if (useWCombo)
{
OrbwalkManager.ResetAutoAttackTimer();
W.Cast();
}
}
if (menu.Item("HarassActive", true).GetValue<KeyBind>().Active || menu.Item("HarassActiveT", true).GetValue<KeyBind>().Active)
{
if (_canWcd == 0 && Player.Distance(target.Position) < 600 && !HammerTime && W.Level > 0 && W.IsReady() && target is Obj_AI_Hero)
if (useWHarass)
{
OrbwalkManager.ResetAutoAttackTimer();
W.Cast();
}
}
}
}
private static void After_Attack(AttackableUnit unit, AttackableUnit target)
{
#region Hydra/Tiamat
var minion = MinionManager.GetMinions(Player.Position, 800, MinionTypes.All, MinionTeam.Enemy,
MinionOrderTypes.MaxHealth);
if (minion != null)
{
if (ItemReady(Hydra) || ItemReady(Tiamat))
{
if (GetBool("offensive.hydraminions", typeof(bool)) &&
(Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LaneClear
|| Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LastHit
|| Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Mixed))
{
if (minion.Count < GetValue("offensive.hydraminonss"))
{
SelfCast(HasItem(Hydra) ? Hydra : Tiamat);
}
}
}
}
var targets = TargetSelector.GetTarget(550, TargetSelector.DamageType.Physical);
if (targets == null) return;
if (ItemReady(Hydra) || ItemReady(Tiamat))
{
if (GetBool("offensive.hydracombo", typeof(bool)) && Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo)
{
SelfCast(HasItem(Hydra) ? Hydra : Tiamat);
}
}
#endregion
}
private static void BeforeAuto(AttackableUnit target, Orbwalker.PreAttackArgs args)
{
if (!CassioUtils.getCheckBoxItem(CassiopeiaMenu.Combo, "Combo.Useauto") && Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo))
{
args.Process = false;
return;
}
if (CassioUtils.getCheckBoxItem(CassiopeiaMenu.Combo, "Combo.Disableautoifspellsready") && Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo))
{
if (SpellSlot.Q.IsReady() || SpellSlot.W.IsReady() || SpellSlot.E.IsReady() || SpellSlot.R.IsReady())
{
args.Process = false;
return;
}
}
if (!CassioUtils.getCheckBoxItem(CassiopeiaMenu.Waveclear, "Waveclear.Useauto") && Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.LaneClear) || Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.JungleClear))
{
args.Process = false;
return;
}
if (!CassioUtils.getCheckBoxItem(CassiopeiaMenu.Farm, "Farm.Useauto") && (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Harass) || Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.LastHit)))
{
args.Process = false;
return;
}
}
private void AfterAttack(AttackableUnit unit, AttackableUnit attackableunit)
{
if (!CheckGuardians()
|| Menu.Item("WMana").GetValue<Slider>().Value > ObjectManager.Player.ManaPercent)
{
return;
}
var heroes = HeroManager.Enemies.Where(x => x.IsValidTarget(Orbwalking.GetRealAutoAttackRange(ObjectManager.Player)));
foreach (var target in heroes as Obj_AI_Hero[] ?? heroes.ToArray())
{
if (Menu.Item("WPred").GetValue<bool>())
{
wSpell.Spell.Cast(target.Position);
}
else
{
var wPred = wSpell.Spell.GetPrediction(target, true);
if (wPred.Hitchance > HitChance.Medium)
{
wSpell.Spell.Cast(wPred.CastPosition);
}
}
}
}
private void afterAttack(AttackableUnit unit, AttackableUnit target)
{
if (!unit.IsMe)
return;
var t = target as Obj_AI_Hero;
var dashPosition = Player.Position.Extend(Game.CursorPos, Q.Range);
if (Q.IsReady() && t.IsValidTarget() && GetWStacks(t) == 1 && t.Position.Distance(Game.CursorPos) < t.Position.Distance(Player.Position) && dashPosition.CountEnemiesInRange(800) < 3)
{
Q.Cast(dashPosition, true);
Program.debug("" + t.Name + GetWStacks(t));
}
else if (Q.IsReady() && Program.Farm && Config.Item("farmQ").GetValue<bool>())
{
var minions = MinionManager.GetMinions(dashPosition, Player.AttackRange, MinionTypes.All);
if (minions == null || minions.Count == 0)
return;
int countMinions = 0;
foreach (var minion in minions.Where(minion => minion.Health < Player.GetAutoAttackDamage(minion) + Q.GetDamage(minion)))
{
countMinions++;
}
if (countMinions > 1)
Q.Cast(dashPosition, true);
}
}
/// <summary>
/// Called on orbwalker action.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="target">The target.</param>
public static void JungleClear(AttackableUnit sender, AttackableUnit target)
{
var tg = (Obj_AI_Minion)target;
if (!Targets.JungleMinions.Contains(tg))
{
return;
}
/// <summary>
/// The W JungleClear Logic.
/// </summary>
if (Variables.W.IsReady() && Variables.WMenu.Item("jungleclear").IsActive())
{
Variables.W.Cast();
return;
}
/// <summary>
/// The Q JungleClear Logic.
/// </summary>
if (Variables.Q.IsReady() && Variables.QMenu.Item("jungleclear").IsActive())
{
Variables.Q.Cast();
}
}
private static void OnAfterAttack(AttackableUnit target, EventArgs args)
{
if (Settings.UsarQ.CurrentValue)
if (Orbwalker.ActiveModesFlags.Equals(Orbwalker.ActiveModes.Combo))
{
var starget = target as AIHeroClient;
if (starget != null)
{
if (Settings.FixQ.CurrentValue)
{
if (starget.IsInRange(Player.Instance, Player.Instance.GetAutoAttackRange()))
if (Spells.Q.IsReady()) Spells.Q.Cast();
}
else if (Settings.FixQ.CurrentValue == false)
{
if (starget.IsInAutoAttackRange(Player.Instance))
if (Spells.Q.IsReady()) Spells.Q.Cast();
}
}
}
if (Settings.JusarQ.CurrentValue)
if (Orbwalker.ActiveModesFlags.Equals(Orbwalker.ActiveModes.JungleClear))
{
var monster = target as Obj_AI_Minion;
if (monster != null)
{
if (monster.IsInRange(Player.Instance, Player.Instance.GetAutoAttackRange()))
if (Spells.Q.IsReady()) Spells.Q.Cast();
}
}
}
private void afterAttack(AttackableUnit unit, AttackableUnit target)
{
if (Player.Mana < RMANA + WMANA || !W.IsReady() || !unit.IsMe)
return;
var t = target as Obj_AI_Hero;
if (t.IsValidTarget())
W.Cast();
else if (Config.Item("farmW", true).GetValue<bool>())
{
var minions = MinionManager.GetMinions(Player.Position, Player.AttackRange, MinionTypes.All);
if (minions == null || minions.Count == 0)
return;
int countMinions = 0;
foreach (var minion in minions.Where(minion => minion.Health < W.GetDamage(minion)))
{
countMinions++;
}
if (countMinions > 0)
W.Cast();
}
}
private void OrbwalkerOnOnPostAttack(AttackableUnit target, EventArgs args)
{
var unit = target as AIHeroClient;
if (unit == null)
{
Orbwalker.OnPostAttack -= OrbwalkerOnOnPostAttack;
return;
}
if (Settings.UseQ && Q.IsReady() && unit.GetSilverStacks() >= 0)
{
var sidePolygon = Helpers.GetSidePolygons();
var positions = new List<Vector2>();
for (var i = 0; i < 2; i++)
{
positions.Add(sidePolygon[i].Points.Where(index => index.ToVector3().ExtendPlayerVector().IsInRange(unit, Player.Instance.GetAutoAttackRange())).OrderByDescending(
index => index.Distance(unit.ServerPosition)).FirstOrDefault());
}
Q.Cast(positions.OrderByDescending(index => index.Distance(unit)).FirstOrDefault().ToVector3().ExtendPlayerVector(200));
}
if (Settings.UseE && E.IsReady() && unit.GetSilverStacks() == 1 && unit.IsECastableOnEnemy())
{
SpellManager.E.Cast(unit);
}
Orbwalker.OnPostAttack -= OrbwalkerOnOnPostAttack;
}
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;
}
public static void UseHydraNot(AttackableUnit target)
{
if (!Tiamat.IsOwned() && !Hydra.IsOwned()) return;
if (!Tiamat.IsReady() && !Hydra.IsReady()) return;
Tiamat.Cast();
Hydra.Cast();
}
public static void PostAttack(AttackableUnit target, EventArgs args)
{
var qtarget = TargetSelector.GetTarget(Spells.Q.Range, DamageType.True);
var hero = target as AIHeroClient;
var useQ = Menu.ComboMenu["Q"].Cast<CheckBox>().CurrentValue && Spells.Q.IsReady();
var qmode = Menu.ComboMenu["Qmode"].Cast<ComboBox>().CurrentValue;
if (qtarget == null || hero == null || hero.Type != GameObjectType.AIHeroClient || qtarget.HasBuff("kindredrnodeathbuff"))
{
return;
}
var flags = Orbwalker.ActiveModesFlags;
if (flags.HasFlag(Orbwalker.ActiveModes.Combo) && useQ)
{
if (qmode == 0)
{
if (Spells.Q.Cast(qtarget.Position))
{
Orbwalker.ResetAutoAttack();
Player.IssueOrder(GameObjectOrder.AttackUnit, qtarget);
}
}
else
{
if (Spells.Q.Cast(Game.CursorPos))
{
Orbwalker.ResetAutoAttack();
Player.IssueOrder(GameObjectOrder.AttackUnit, qtarget);
}
}
}
}
private static void Obj_BarracksDampener_OnDamage(AttackableUnit sender, AttackableUnitDamageEventArgs args)
{
logEvent("Obj_BarracksDampener_OnDamage", "sender", sender.Name, "sender_id", sender.Index, "network_id", sender.NetworkId);
}
public virtual bool InAutoAttackRange(AttackableUnit target)
{
return(Orbwalking.InAutoAttackRange(target));
}
private static void BeforeAttack(AttackableUnit target, Orbwalker.PreAttackArgs args)
{
LogicQ();
}
internal static void OnAfterAttack(AttackableUnit unit, EventArgs args)
{
if (!(unit is AIHeroClient))
{
return;
}
var target = TargetSelector.GetTarget(W.Range, DamageType.True);
var hero = (AIHeroClient)unit;
var Wcombo = WMenu["Combo"].Cast <CheckBox>().CurrentValue;
if (hero == null || !hero.IsValid || hero.Type != GameObjectType.AIHeroClient)
{
return;
}
var flags = Orbwalker.ActiveModesFlags;
if (target != null)
{
if (flags.HasFlag(Orbwalker.ActiveModes.Combo))
{
if (Wcombo)
{
if (WMenu["AAr"].Cast <CheckBox>().CurrentValue)
{
if (W.Cast())
{
Orbwalker.ResetAutoAttack();
Player.IssueOrder(GameObjectOrder.AttackUnit, target);
}
}
}
if (ItemsMenu["Hydra"].Cast <CheckBox>().CurrentValue&& Hydra.IsReady() && Hydra.IsOwned(Player.Instance) &&
target.IsKillable(Hydra.Range))
{
Hydra.Cast();
}
if (ItemsMenu["Hydra"].Cast <CheckBox>().CurrentValue&& Timat.IsReady() && Timat.IsOwned(Player.Instance) &&
target.IsKillable(Timat.Range))
{
Timat.Cast();
}
if (ItemsMenu["Hydra"].Cast <CheckBox>().CurrentValue&& Titanic.IsReady() && Titanic.IsOwned(Player.Instance) &&
target.IsKillable(Titanic.Range))
{
if (Titanic.Cast())
{
Orbwalker.ResetAutoAttack();
Player.IssueOrder(GameObjectOrder.AttackUnit, target);
}
}
if (QMenu["Combo"].Cast <CheckBox>().CurrentValue&& (QMenu["QAA"].Cast <CheckBox>().CurrentValue&& Q.IsReady()) && !W.IsReady())
{
Q.Cast();
}
}
}
}
/// <summary>
/// Action after Attack
/// </summary>
/// <param name="unit">Unit Attacked</param>
/// <param name="target">Target Attacked</param>
private static void OrbwalkingAfterAttack(AttackableUnit unit, AttackableUnit target)
{
var useQCombo = Essentials.Config.SubMenu("Combo").Item("qcombo").GetValue <bool>();
var useQHarass = Essentials.Config.SubMenu("Harass").Item("qharass").GetValue <bool>();
var targetAdc = Essentials.Config.SubMenu("Combo").Item("useqADC").GetValue <bool>();
var checkAa = Essentials.Config.SubMenu("Misc").Item("checkAA").GetValue <bool>();
var checkaaRange = (float)Essentials.Config.SubMenu("Misc").Item("checkaaRange").GetValue <Slider>().Value;
var t = target as AIHeroClient;
if (t != null && Essentials.Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo)
{
if (checkAa)
{
if (targetAdc)
{
if (Essentials.Marksman.Contains(t.CharData.BaseSkinName) && useQCombo && Essentials.Q.IsReady() && Essentials.Q.IsInRange(t, -checkaaRange))
{
Essentials.Q.Cast(t);
}
}
else
{
if (useQCombo && Essentials.Q.IsReady() && Essentials.Q.IsInRange(t, -checkaaRange))
{
Essentials.Q.Cast(t);
}
}
}
else
{
if (targetAdc)
{
if (Essentials.Marksman.Contains(t.CharData.BaseSkinName) && useQCombo && Essentials.Q.IsReady() && Essentials.Q.IsInRange(t))
{
Essentials.Q.Cast(t);
}
}
else
{
if (useQCombo && Essentials.Q.IsReady() && Essentials.Q.IsInRange(t))
{
Essentials.Q.Cast(t);
}
}
}
}
if (t != null && Essentials.Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Mixed)
{
if (checkAa)
{
if (useQHarass && Essentials.Q.IsReady() && Essentials.Q.IsInRange(t, -checkaaRange))
{
Essentials.Q.Cast(t);
}
}
else
{
if (useQHarass && Essentials.Q.IsReady() && Essentials.Q.IsInRange(t))
{
Essentials.Q.Cast(t);
}
}
}
}
public virtual AttackableUnit GetTarget()
{
AttackableUnit result = null;
if ((ActiveMode == OrbwalkingMode.Mixed || ActiveMode == OrbwalkingMode.LaneClear) &&
!_config.Item("PriorizeFarm").GetValue <bool>())
{
var target = TargetSelector.GetTarget(-1, TargetSelector.DamageType.Physical);
if (target != null && InAutoAttackRange(target))
{
return(target);
}
}
/*Killable Minion*/
if (ActiveMode == OrbwalkingMode.LaneClear || ActiveMode == OrbwalkingMode.Mixed && _config.Item("Harass.MLH").GetValue <bool>() ||
ActiveMode == OrbwalkingMode.LastHit)
{
var MinionList =
ObjectManager.Get <Obj_AI_Minion>()
.Where(
minion =>
minion.IsValidTarget() && InAutoAttackRange(minion))
.OrderByDescending(minion => minion.CharData.BaseSkinName.Contains("Siege"))
.ThenBy(minion => minion.CharData.BaseSkinName.Contains("Super"))
.ThenBy(minion => minion.Health)
.ThenByDescending(minion => minion.MaxHealth);
foreach (var minion in MinionList)
{
var t = (int)(Player.AttackCastDelay * 1000) - 100 +
1000 * (int)Math.Max(0, Player.Distance(minion) - Player.BoundingRadius) / int.MaxValue;
var predHealth = HealthPrediction.GetHealthPrediction(minion, t, 0);
if (minion.Team != GameObjectTeam.Neutral && (_config.Item("AttackPetsnTraps").GetValue <bool>() || MinionManager.IsMinion(minion, _config.Item("AttackWards").GetValue <bool>())))
{
if (predHealth <= 0)
{
FireOnNonKillableMinion(minion);
}
if (predHealth > 0 && predHealth <= Player.GetAutoAttackDamage(minion, true))
{
return(minion);
}
}
}
}
//Forced target
if (_forcedTarget.IsValidTarget() && InAutoAttackRange(_forcedTarget))
{
return(_forcedTarget);
}
/* turrets / inhibitors / nexus */
if (ActiveMode == OrbwalkingMode.LaneClear)
{
/* turrets */
foreach (var turret in
ObjectManager.Get <Obj_AI_Turret>().Where(t => t.IsValidTarget() && InAutoAttackRange(t)))
{
return(turret);
}
/* inhibitor */
foreach (var turret in
ObjectManager.Get <Obj_BarracksDampener>().Where(t => t.IsValidTarget() && InAutoAttackRange(t)))
{
return(turret);
}
/* nexus */
foreach (var nexus in
ObjectManager.Get <Obj_HQ>().Where(t => t.IsValidTarget() && InAutoAttackRange(t)))
{
return(nexus);
}
}
/*Champions*/
if (ActiveMode != OrbwalkingMode.LastHit)
{
var target = TargetSelector.GetTarget(-1, TargetSelector.DamageType.Physical);
if (target.IsValidTarget() && InAutoAttackRange(target))
{
return(target);
}
}
/*Jungle minions*/
if (ActiveMode == OrbwalkingMode.LaneClear || ActiveMode == OrbwalkingMode.Mixed)
{
var jminions =
ObjectManager.Get <Obj_AI_Minion>()
.Where(
mob =>
mob.IsValidTarget() && mob.Team == GameObjectTeam.Neutral && InAutoAttackRange(mob) &&
mob.CharData.BaseSkinName != "gangplankbarrel");
result = _config.Item("Smallminionsprio").GetValue <bool>() ? jminions.MinOrDefault(mob => mob.MaxHealth) : jminions.MaxOrDefault(mob => mob.MaxHealth);
if (result != null)
{
return(result);
}
}
/*Lane Clear minions*/
if (ActiveMode == OrbwalkingMode.LaneClear)
{
if (!ShouldWait())
{
if (_prevMinion.IsValidTarget() && InAutoAttackRange(_prevMinion))
{
var predHealth = HealthPrediction.LaneClearHealthPrediction(
_prevMinion, (int)((Player.AttackDelay * 1000) * LaneClearWaitTimeMod), 0);
if (predHealth >= 2 * Player.GetAutoAttackDamage(_prevMinion) ||
Math.Abs(predHealth - _prevMinion.Health) < float.Epsilon)
{
return(_prevMinion);
}
}
result = (from minion in
ObjectManager.Get <Obj_AI_Minion>()
.Where(minion => minion.IsValidTarget() && InAutoAttackRange(minion) &&
(_config.Item("AttackWards").GetValue <bool>() || !MinionManager.IsWard(minion)) &&
(_config.Item("AttackPetsnTraps").GetValue <bool>() && minion.CharData.BaseSkinName != "jarvanivstandard" || MinionManager.IsMinion(minion, _config.Item("AttackWards").GetValue <bool>())) &&
minion.CharData.BaseSkinName != "gangplankbarrel")
let predHealth =
HealthPrediction.LaneClearHealthPrediction(
minion, (int)((Player.AttackDelay * 1000) * LaneClearWaitTimeMod), 0)
where
predHealth >= 2 * Player.GetAutoAttackDamage(minion) ||
Math.Abs(predHealth - minion.Health) < float.Epsilon
select minion).MaxOrDefault(m => !MinionManager.IsMinion(m, true) ? float.MaxValue : m.Health);
if (result != null)
{
_prevMinion = (Obj_AI_Minion)result;
}
}
}
return(result);
}
private static void AttackableUnit_OnDamage(AttackableUnit sender, AttackableUnitDamageEventArgs args)
{
logEvent("AttackableUnit_OnDamage", "sender", sender.Name, "sender_id", sender.Index, "sender_health", sender.Health, "target_health", args.Target.Health, "target_network_id", args.Target.NetworkId);
}
private static void afterAttack(AttackableUnit target, EventArgs args)
{
//if (!target.IsMe)
//return;
}
public static float misslesHeadedOnDamage(AttackableUnit unit)
{
return(activeDamageMakers.Where(un => un.Value.target.NetworkId == unit.NetworkId).Sum(un => un.Value.dealDamage));
}
private static void Orbwalking_AfterAttack(AttackableUnit unit, AttackableUnit target)
{
if (BadaoMainVariables.Orbwalker.ActiveMode != Orbwalking.OrbwalkingMode.Combo)
{
return;
}
if (Utils.GameTimeTickCount - BadaoMissFortuneVariables.Rcount <= 500)
{
return;
}
if (BadaoMissFortuneHelper.UseRCombo() && unit.IsMe &&
target.BadaoIsValidTarget() &&
target is Obj_AI_Hero && BadaoMissFortuneHelper.Rdamepior() &&
target.Health <= 0.6f * BadaoMissFortuneHelper.RDamage(target as Obj_AI_Base))
{
float reactiontime = 0.5f;
var PredTarget = Prediction.GetPrediction(target as Obj_AI_Base, 0.25f + Game.Ping / 1000f);
Vector2 x1 = new Vector2();
Vector2 x2 = new Vector2();
Vector2 CenterPolar = new Vector2();
Vector2 CenterEnd = new Vector2();
BadaoMissFortuneHelper.RPrediction(PredTarget.UnitPosition.To2D(), target as Obj_AI_Base,
out CenterPolar, out CenterEnd, out x1, out x2);
float dis1 = PredTarget.UnitPosition.To2D().Distance(x1);
float dis2 = PredTarget.UnitPosition.To2D().Distance(x2);
Obj_AI_Hero Target = target as Obj_AI_Hero;
if (PredTarget.UnitPosition.To2D().Distance(ObjectManager.Player.Position.To2D()) >= 250 &&
(Target.HasBuffOfType(BuffType.Stun) || Target.HasBuffOfType(BuffType.Snare) ||
(dis1 >= dis2 && (dis2 / Target.MoveSpeed >= 0.6f * 3f - reactiontime ||
BadaoMissFortuneHelper.RDamage(Target) * (dis2 / Target.MoveSpeed + reactiontime) / 3f >= Target.Health
- BadaoMissFortuneHelper.GetAADamage(Target)))))
{
BadaoMainVariables.R.Cast(PredTarget.UnitPosition.To2D());
BadaoMissFortuneVariables.TargetRChanneling = target as Obj_AI_Hero;
BadaoMissFortuneVariables.CenterPolar = CenterPolar;
BadaoMissFortuneVariables.CenterEnd = CenterEnd;
BadaoMissFortuneVariables.Rcount = Utils.GameTimeTickCount;
}
else if (PredTarget.UnitPosition.To2D().Distance(ObjectManager.Player.Position.To2D()) >= 250 &&
(Target.HasBuffOfType(BuffType.Stun) || Target.HasBuffOfType(BuffType.Snare) ||
(dis2 >= dis1 && (dis1 / Target.MoveSpeed >= 0.6f * 3f - reactiontime ||
BadaoMissFortuneHelper.RDamage(Target) * (dis1 / Target.MoveSpeed + reactiontime) / 3f >= Target.Health
- BadaoMissFortuneHelper.GetAADamage(Target)))))
{
BadaoMainVariables.R.Cast(PredTarget.UnitPosition.To2D());
BadaoMissFortuneVariables.TargetRChanneling = target as Obj_AI_Hero;
BadaoMissFortuneVariables.CenterPolar = CenterPolar;
BadaoMissFortuneVariables.CenterEnd = CenterEnd;
BadaoMissFortuneVariables.Rcount = Utils.GameTimeTickCount;
}
}
if (BadaoMissFortuneHelper.UseRComboWise() && unit.IsMe &&
target.BadaoIsValidTarget() &&
target is Obj_AI_Hero && BadaoMissFortuneHelper.Rdamepior() &&
target.Health <= 0.8f * BadaoMissFortuneHelper.RDamage(target as Obj_AI_Base))
{
float reactiontime = 1f;
var PredTarget = Prediction.GetPrediction(target as Obj_AI_Base, 0.25f + Game.Ping / 1000f);
Vector2 x1 = new Vector2();
Vector2 x2 = new Vector2();
Vector2 CenterPolar = new Vector2();
Vector2 CenterEnd = new Vector2();
BadaoMissFortuneHelper.RPrediction(PredTarget.UnitPosition.To2D(), target as Obj_AI_Base,
out CenterPolar, out CenterEnd, out x1, out x2);
float dis1 = PredTarget.UnitPosition.To2D().Distance(x1);
float dis2 = PredTarget.UnitPosition.To2D().Distance(x2);
Obj_AI_Hero Target = target as Obj_AI_Hero;
if (PredTarget.UnitPosition.To2D().Distance(ObjectManager.Player.Position.To2D()) >= 250 &&
(Target.HasBuffOfType(BuffType.Stun) || Target.HasBuffOfType(BuffType.Snare) ||
(dis1 >= dis2 && (dis2 / Target.MoveSpeed >= 0.8f * 3f - reactiontime ||
BadaoMissFortuneHelper.RDamage(Target) * (dis2 / Target.MoveSpeed + reactiontime) / 3f >= Target.Health
- BadaoMissFortuneHelper.GetAADamage(Target)))))
{
BadaoMainVariables.R.Cast(PredTarget.UnitPosition.To2D());
BadaoMissFortuneVariables.TargetRChanneling = target as Obj_AI_Hero;
BadaoMissFortuneVariables.CenterPolar = CenterPolar;
BadaoMissFortuneVariables.CenterEnd = CenterEnd;
BadaoMissFortuneVariables.Rcount = Utils.GameTimeTickCount;
}
else if (PredTarget.UnitPosition.To2D().Distance(ObjectManager.Player.Position.To2D()) >= 250 &&
(Target.HasBuffOfType(BuffType.Stun) || Target.HasBuffOfType(BuffType.Snare) ||
(dis2 >= dis1 && (dis1 / Target.MoveSpeed >= 0.8f * 3f - reactiontime ||
BadaoMissFortuneHelper.RDamage(Target) * (dis1 / Target.MoveSpeed + reactiontime) / 3f >= Target.Health
- BadaoMissFortuneHelper.GetAADamage(Target)))))
{
BadaoMainVariables.R.Cast(PredTarget.UnitPosition.To2D());
BadaoMissFortuneVariables.TargetRChanneling = target as Obj_AI_Hero;
BadaoMissFortuneVariables.CenterPolar = CenterPolar;
BadaoMissFortuneVariables.CenterEnd = CenterEnd;
BadaoMissFortuneVariables.Rcount = Utils.GameTimeTickCount;
}
}
}
//Maybe later change so would return data about missile
public static DamageMaker attackedByTurret(AttackableUnit unit)
{
return(activeTowerTargets.Values.Where(v => v.target.NetworkId == unit.NetworkId).FirstOrDefault(attack => attack.source is Obj_AI_Turret));
}
public UpdateStats(AttackableUnit u, bool partial = true)
: base(PacketCmd.PKT_S2C_CharStats)
{
var stats = new Dictionary <MasterMask, Dictionary <FieldMask, float> >();
if (partial)
{
stats = u.GetStats().GetUpdatedStats();
}
else
{
stats = u.GetStats().GetAllStats();
}
var orderedStats = stats.OrderBy(x => x.Key);
buffer.Write(Environment.TickCount); // syncID
buffer.Write((byte)1); // updating 1 unit
byte masterMask = 0;
foreach (var p in orderedStats)
{
masterMask |= (byte)p.Key;
}
buffer.Write((byte)masterMask);
buffer.Write((uint)u.NetId);
foreach (var group in orderedStats)
{
var orderedGroup = group.Value.OrderBy(x => x.Key);
uint fieldMask = 0;
byte size = 0;
foreach (var stat in orderedGroup)
{
fieldMask |= (uint)stat.Key;
size += u.GetStats().getSize(group.Key, stat.Key);
}
buffer.Write((uint)fieldMask);
buffer.Write((byte)size);
foreach (var stat in orderedGroup)
{
size = u.GetStats().getSize(group.Key, stat.Key);
switch (size)
{
case 1:
buffer.Write((byte)Convert.ToByte(stat.Value));
break;
case 2:
buffer.Write((short)Convert.ToInt16(stat.Value));
break;
case 4:
var bytes = BitConverter.GetBytes(stat.Value);
if (bytes[0] >= 0xFE)
{
bytes[0] = 0xFD;
}
buffer.Write((float)BitConverter.ToSingle(bytes, 0));
break;
}
}
}
}
public abstract void OnFinishCasting(Vector2 position, Vector2 endPosition, AttackableUnit target);
public static int misslesHeadedOn(AttackableUnit unit)
{
return(activeDamageMakers.Count(un => un.Value.target.NetworkId == unit.NetworkId));
}
/// <inheritdoc cref="IOrbwalker" /> public abstract bool Attack(AttackableUnit target);
public abstract void ApplyEffects(AttackableUnit target, IMissile projectile);
private void Game_OnEnterVisiblity(AttackableUnit sender, EventArgs args)
{
Console.WriteLine(sender.Name);
}
/// <inheritdoc cref="IOrbwalker" /> public abstract void ForceTarget(AttackableUnit unit);
public static void Orbwalking_AfterAttack(AttackableUnit unit, AttackableUnit target)
{
if (!unit.IsMe)
{
return;
}
if (!(target is Obj_AI_Hero))
{
return;
}
tar = (Obj_AI_Hero)target;
if (menu.Item("aaqaa").GetValue <KeyBind>().Active)
{
if (Q.IsReady())
{
Q.Cast(Game.CursorPos);
}
Orbwalking.Orbwalk(TargetSelector.GetTarget(625, TargetSelector.DamageType.Physical), Game.CursorPos);
}
if (Itemsmenu.Item("BOTRK").GetValue <bool>() && ((tar.Health / tar.MaxHealth) < botrk.Item("theirhp").GetValue <Slider>().Value) && ((ObjectManager.Player.Health / ObjectManager.Player.MaxHealth) < botrk.Item("myhp").GetValue <Slider>().Value))
{
//Game.PrintChat("in");
if (Items.CanUseItem(3153))
{
Items.UseItem(3153, tar);
}
}
if (Itemsmenu.Item("Ghostblade").GetValue <bool>())
{
if (Items.CanUseItem(3142))
{
Items.UseItem(3142);
}
}
if (menu.Item("UseEaa").GetValue <KeyBind>().Active)
{
E.Cast((Obj_AI_Base)target);
menu.Item("UseEaa").SetValue <KeyBind>(new KeyBind("G".ToCharArray()[0], KeyBindType.Toggle));
}
if (((orbwalker.ActiveMode.ToString() != "Combo" || !menu.Item("UseQC").GetValue <bool>()) &&
((orbwalker.ActiveMode.ToString() != "Mixed" || !menu.Item("hq").GetValue <bool>()) || !Q.IsReady())))
{
return;
}
if (menu.Item("restrictq").GetValue <bool>())
{
var after = ObjectManager.Player.Position +
Normalize(Game.CursorPos - ObjectManager.Player.Position) * 300;
//Game.PrintChat("After: {0}", after);
var disafter = Vector3.DistanceSquared(after, tar.Position);
//Game.PrintChat("DisAfter: {0}", disafter);
//Game.PrintChat("first calc: {0}", (disafter) - (630*630));
if ((disafter < 630 * 630) && disafter > 150 * 150)
{
Q.Cast(Game.CursorPos);
}
if (Vector3.DistanceSquared(tar.Position, ObjectManager.Player.Position) > 630 * 630 &&
disafter < 630 * 630)
{
Q.Cast(Game.CursorPos);
}
}
else
{
Q.Cast(Game.CursorPos);
}
//Q.Cast(Game.CursorPos);
}
public void OnFinishCasting(Champion owner, Spell spell, AttackableUnit target)
{
spell.AddProjectileTarget("DetonatingShot", target, false);
}
/// <summary>
/// Initializes a new instance of the <see cref="BeforeOrbwalkerAttack"/> class
/// </summary>
/// <param name="target">The target</param>
public BeforeOrbwalkerAttack(AttackableUnit target)
{
this.Target = target;
}
public static void ForceQ(AttackableUnit target)
{
forceQ = true;
QTarget = target;
}
public void OnStartCasting(Champion owner, Spell spell, AttackableUnit target)
{
ApiFunctionManager.AddParticleTarget(owner, "Ezreal_bow_huge.troy", owner, 1, "L_HAND");
}
private static void Obj_AI_Base_OnDamage(AttackableUnit sender, AttackableUnitDamageEventArgs args)
{
IncomingDamages.RemoveAll(x => (x.Sender.NetworkId == args.Source.NetworkId) &&
(x.Target.NetworkId == args.Target.NetworkId));
}
private static void After_Attack(AttackableUnit unit, AttackableUnit target)
{
}
private void Orbwalking_BeforeAttack(AttackableUnit target, Orbwalker.PreAttackArgs args)
{
_recentFarmTarget = args.Target.Type == GameObjectType.obj_AI_Base
? (Obj_AI_Base)args.Target
: _recentFarmTarget;
}
protected virtual void OnNonKillableMinion(AttackableUnit minion)
{
}
public virtual AttackableUnit GetTarget()
{
AttackableUnit result = null;
if ((ActiveMode == OrbwalkingMode.Mixed || ActiveMode == OrbwalkingMode.LaneClear) &&
!_config.Item("PriorizeFarm").GetValue <bool>())
{
var target = TargetSelector.GetTarget(-1, TargetSelector.DamageType.Physical);
if (target != null)
{
return(target);
}
}
/*Killable Minion*/
if (ActiveMode == OrbwalkingMode.LaneClear || ActiveMode == OrbwalkingMode.Mixed ||
ActiveMode == OrbwalkingMode.LastHit)
{
var MinionList =
ObjectManager.Get <Obj_AI_Minion>()
.Where(
minion =>
minion.IsValidTarget() && InAutoAttackRange(minion) &&
minion.Health <
2 *
(ObjectManager.Player.BaseAttackDamage + ObjectManager.Player.FlatPhysicalDamageMod)).OrderByDescending(minion => minion.MaxHealth);
foreach (var minion in MinionList)
{
var t = (int)(Player.AttackCastDelay * 1000) - 100 + Game.Ping / 2 +
1000 * (int)Player.ServerPosition.Distance(minion.ServerPosition) / (int)GetMyProjectileSpeed();
var predHealth = HealthPrediction.GetHealthPrediction(minion, t, FarmDelay);
if (minion.Team != GameObjectTeam.Neutral && MinionManager.IsMinion(minion, true))
{
if (predHealth <= 0)
{
FireOnNonKillableMinion(minion);
}
if (predHealth > 0 && predHealth <= Player.GetAutoAttackDamage(minion, true))
{
return(minion);
}
}
}
}
//Forced target
if (_forcedTarget.IsValidTarget() && InAutoAttackRange(_forcedTarget))
{
return(_forcedTarget);
}
/* turrets / inhibitors / nexus */
if (ActiveMode == OrbwalkingMode.LaneClear)
{
/* turrets */
foreach (var turret in
ObjectManager.Get <Obj_AI_Turret>().Where(t => t.IsValidTarget() && InAutoAttackRange(t)))
{
return(turret);
}
/* inhibitor */
foreach (var turret in
ObjectManager.Get <Obj_BarracksDampener>().Where(t => t.IsValidTarget() && InAutoAttackRange(t)))
{
return(turret);
}
/* nexus */
foreach (var nexus in
ObjectManager.Get <Obj_HQ>().Where(t => t.IsValidTarget() && InAutoAttackRange(t)))
{
return(nexus);
}
}
/*Champions*/
if (ActiveMode != OrbwalkingMode.LastHit)
{
var target = TargetSelector.GetTarget(-1, TargetSelector.DamageType.Physical);
if (target.IsValidTarget())
{
return(target);
}
}
/*Jungle minions*/
if (ActiveMode == OrbwalkingMode.LaneClear || ActiveMode == OrbwalkingMode.Mixed)
{
result =
ObjectManager.Get <Obj_AI_Minion>()
.Where(
mob =>
mob.IsValidTarget() && mob.Team == GameObjectTeam.Neutral && InAutoAttackRange(mob) && mob.CharData.BaseSkinName != "gangplankbarrel")
.MaxOrDefault(mob => mob.MaxHealth);
if (result != null)
{
return(result);
}
}
/*Lane Clear minions*/
if (ActiveMode == OrbwalkingMode.LaneClear)
{
if (!ShouldWait())
{
if (_prevMinion.IsValidTarget() && InAutoAttackRange(_prevMinion))
{
var predHealth = HealthPrediction.LaneClearHealthPrediction(
_prevMinion, (int)((Player.AttackDelay * 1000) * LaneClearWaitTimeMod), FarmDelay);
if (predHealth >= 2 * Player.GetAutoAttackDamage(_prevMinion) ||
Math.Abs(predHealth - _prevMinion.Health) < float.Epsilon)
{
return(_prevMinion);
}
}
result = (from minion in
ObjectManager.Get <Obj_AI_Minion>()
.Where(minion => minion.IsValidTarget() && InAutoAttackRange(minion) && minion.CharData.BaseSkinName != "gangplankbarrel")
let predHealth =
HealthPrediction.LaneClearHealthPrediction(
minion, (int)((Player.AttackDelay * 1000) * LaneClearWaitTimeMod), FarmDelay)
where
predHealth >= 2 * Player.GetAutoAttackDamage(minion) ||
Math.Abs(predHealth - minion.Health) < float.Epsilon
select minion).MaxOrDefault(m => m.Health);
if (result != null)
{
_prevMinion = (Obj_AI_Minion)result;
}
}
}
return(result);
}
protected virtual void AfterAttack(AttackableUnit unit, AttackableUnit target)
{
}
public static void Orbwalking_AfterAttack(AttackableUnit target, EventArgs args)
{
if ((Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.LaneClear) || Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.JungleClear)) && 100 * (Player.Mana / Player.MaxMana) > getSliderItem(qmenu, "Junglemana"))
{
var mob =
MinionManager.GetMinions(
Player.ServerPosition,
E.Range,
MinionTypes.All,
MinionTeam.Neutral,
MinionOrderTypes.MaxHealth).FirstOrDefault();
var Minions = MinionManager.GetMinions(
Player.Position.LSExtend(Game.CursorPos, Q.Range),
Player.AttackRange,
MinionTypes.All);
var useQ = getCheckBoxItem(qmenu, "UseQJ");
int countMinions = 0;
foreach (var minions in
Minions.Where(
minion =>
minion.Health < Player.LSGetAutoAttackDamage(minion) ||
minion.Health < Q.GetDamage(minion) + Player.LSGetAutoAttackDamage(minion) || minion.Health < Q.GetDamage(minion)))
{
countMinions++;
}
if (countMinions >= 2 && useQ && Q.IsReady() && Minions != null)
{
Q.Cast(Player.Position.LSExtend(Game.CursorPos, Q.Range / 2));
}
if (useQ && Q.IsReady() && Orbwalking.InAutoAttackRange(mob) && mob != null)
{
Q.Cast(Game.CursorPos);
}
}
if (!(target is AIHeroClient))
{
return;
}
tar = (AIHeroClient)target;
if (getKeyBindItem(menu, "aaqaa"))
{
if (Q.IsReady())
{
Q.Cast(Game.CursorPos);
}
Orbwalker.OrbwalkTo(Game.CursorPos);
}
if (getKeyBindItem(emenu, "UseEaa"))
{
E.Cast((Obj_AI_Base)target);
emenu["UseEaa"].Cast <KeyBind>().CurrentValue = !getCheckBoxItem(emenu, "UseEaa");
}
if (Q.IsReady() &&
((Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo) && getCheckBoxItem(qmenu, "UseQC")) || (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Harass) && getCheckBoxItem(qmenu, "hq"))))
{
if (getCheckBoxItem(qmenu, "restrictq"))
{
var after = ObjectManager.Player.Position
+ Normalize(Game.CursorPos - ObjectManager.Player.Position) * 300;
//Game.PrintChat("After: {0}", after);
var disafter = Vector3.DistanceSquared(after, tar.Position);
//Game.PrintChat("DisAfter: {0}", disafter);
//Game.PrintChat("first calc: {0}", (disafter) - (630*630));
if ((disafter < 630 * 630) && disafter > 150 * 150)
{
Q.Cast(Game.CursorPos);
}
if (Vector3.DistanceSquared(tar.Position, ObjectManager.Player.Position) > 630 * 630 &&
disafter < 630 * 630)
{
Q.Cast(Game.CursorPos);
}
}
else
{
Q.Cast(Game.CursorPos);
}
//Q.Cast(Game.CursorPos);
}
}
