internal static int JsCalcDamage(Obj_AI_Minion mob)
{
var aa = ObjectManager.Player.GetAutoAttackDamage(mob, true) * 1.5;
var damage = aa;
if (Spells.Q.IsReady()
&& Program.JungleStealMenu[Player.Instance.ChampionName + "QJ"].Cast<CheckBox>().CurrentValue)
// Qdamage
{
damage += ObjectManager.Player.GetSpellDamage(mob, SpellSlot.Q);
}
if (Spells.W.IsReady()
&& Program.JungleStealMenu[Player.Instance.ChampionName + "WJ"].Cast<CheckBox>().CurrentValue)
// Wdamage
{
damage += ObjectManager.Player.GetSpellDamage(mob, SpellSlot.W);
}
if (Spells.E.IsReady()
&& Program.JungleStealMenu[Player.Instance.ChampionName + "EJ"].Cast<CheckBox>().CurrentValue)
// Edamage
{
damage += ObjectManager.Player.GetSpellDamage(mob, SpellSlot.E);
}
if (Spells.R.IsReady()
&& Program.JungleStealMenu[Player.Instance.ChampionName + "RJ"].Cast<CheckBox>().CurrentValue)
// Rdamage
{
damage += ObjectManager.Player.GetSpellDamage(mob, SpellSlot.R);
}
return (int)damage;
}
public static void Farm(Obj_AI_Minion minion)
{
if (Q.IsReady())
{
Q.Cast();
}
}
public static bool IsImportant(Obj_AI_Minion minion)
{
return minion.IsValidTarget()
&& (minion.Name.ToLower().Contains("baron")
|| minion.Name.ToLower().Contains("dragon")
|| minion.Name.ToLower().Contains("herald"));
}
/// <summary>
/// Return the Attacking turret.
/// </summary>
/// <param name="minion">
/// The minion.
/// </param>
/// <returns>
/// The <see cref="bool" />
/// </returns>
public static Obj_AI_Base GetAggroTurret(Obj_AI_Minion minion)
{
var activeTurret =
ActiveAttacks.Values.FirstOrDefault(
m => (m.Source is Obj_AI_Turret) && m.Target.NetworkId == minion.NetworkId);
return activeTurret?.Source;
}
public bool CastSpell(Obj_AI_Minion target)
{
if (!CanUseSpell(target))
return false;
ObjectManager.Player.Spellbook.CastSpell(Slot, target);
return true;
}
public static void Farm(Obj_AI_Minion minion)
{
if (Q.IsReady() && Q.GetDamage(minion) < minion.Health)
{
Q.Cast(minion);
}
}
public static void Farm(Obj_AI_Minion minion)
{
Q.SetSkillshot(0.26f, 50f, 1700f, true, SkillshotType.SkillshotLine);
if (Player.Level < 6)
{
if (Player.GetAutoAttackDamage(minion) > minion.Health && Player.Distance(minion.Position) < Player.AttackRange)
{
Player.IssueOrder(GameObjectOrder.AutoAttack, minion);
}
if (E.IsReady() && CountMinions(Player.Position, 500, ENEMY_TEAM) > 3)
{
E.Cast(minion);
}
}
if (W.IsReady() &&
W.GetDamage(minion) > minion.Health &&
W.IsInRange(minion) &&
Player.Mana > 50)
{
W.Cast(minion);
}
if (Player.Level >= 6 && Player.CountEnemiesInRange(1000) == 0 && Player.Mana > 150)
{
if (Q.IsReady() && Player.ManaPercent > 20)
{
Q.Cast(minion.Position);
}
else if (Q.IsReady() && Q.GetDamage(minion) > minion.Health && Q.GetPrediction(minion).Hitchance > HitChance.Low)
{
Q.Cast(minion.Position);
}
else
{
Q.Cast(minion.Position);
}
if (R.IsReady() && CountMinions(minion.Position, 500,ENEMY_TEAM) > 3)
{
R.Cast();
}
if (W.IsReady() &&W.IsInRange(minion))
{
W.Cast(minion);
}
if (E.IsReady() && E.IsInRange(minion))
{
E.Cast(minion);
}
}
//if (W.IsReady() && CountMinions(Player.Position, W.Range, ENEMY_TEAM) > 2)
//{
// W.Cast(minion.Position);
//}
}
private void Orbwalking_OnAttack(AttackableUnit unit, AttackableUnit target)
{
if (unit.IsMe && target is Obj_AI_Minion)
{
LastAttackedminiMinion = (Obj_AI_Minion) target;
LastAttackedminiMinionTime = Utils.GameTimeTickCount;
}
}
public override float getDPS(Obj_AI_Minion minion)
{
float dps = 0;
dps += (float)player.GetAutoAttackDamage(minion) * player.AttackSpeedMod;
dps += 30;
dpsFix = dps;
return dps;
}
public static bool CanCloneAttack(Obj_AI_Minion clone)
{
if (clone != null)
{
return Utils.GameTimeTickCount >= LastAATick + (clone.AttackDelay - clone.AttackCastDelay) * 1000;
}
return false;
}
public static bool CanCloneAttack(Obj_AI_Minion ghost)
{
if (ghost != null)
{
return Utils.GameTimeTickCount >= LastAATick + (ghost.AttackDelay - ghost.AttackCastDelay) * 1000;
}
return false;
}
public override void attackMinion(Obj_AI_Minion minion, bool onlyAA)
{
if (JungleOrbwalker.CanAttack())
{
UseW(minion);
UseE(minion);
UseR(minion);
}
JungleOrbwalker.attackMinion(minion, minion.Position.To2D().Extend(player.Position.To2D(), 150).To3D());
}
public Vector3 AvgPos(Obj_AI_Minion[] objects)
{
double x = 0, y = 0;
foreach (Obj_AI_Minion obj in objects)
{
x += obj.Position.X;
y += obj.Position.Y;
}
return new Vector2((float) (x/objects.Count()), (float) (y/objects.Count())).To3DWorld();
}
/// <summary>
/// This function will check if the given target is killable
/// </summary>
/// <param name="target">Must be a OBJAIMinion</param>
/// <param name="range">Must be a float value where to check the max range</param>
/// <param name="key">Must be a Spellslot key for assign the damage</param>
/// <returns></returns>
public static bool IsKillableMinion(Obj_AI_Minion target, float range, SpellSlot key)
{
var x = target;
if (x.IsValidTarget(range) && x.TotalShieldHealth() + 5 <= Player.Instance.GetSpellDamage(x, key))
{
return true;
}
return false;
}
public bool HasBuff(Obj_AI_Minion jungleBigMob)
{
foreach (JungleMob jungleMob in JungleMobs)
{
if (jungleBigMob.SkinName.Contains(jungleMob.Name))
{
return jungleMob.Buff;
}
}
return false;
}
public override float getDPS(Obj_AI_Minion minion)
{
float dps = 0;
if (Q.Level != 0)
dps += Q.GetDamage(minion) / Qdata.Cooldown;
if (E.Level != 0)
dps += E.GetDamage(minion) / (Qdata.Cooldown-2);
dps += (float)player.GetAutoAttackDamage(minion) * player.AttackSpeedMod;
dpsFix = dps;
return (dps == 0) ? 999 : dps;
}
public static void DragonSteal(Obj_AI_Minion dragon)
{
var time = (int)(ObjectManager.Player.Spellbook.GetSpell(SpellSlot.R).SData.SpellTotalTime * 1000) - 100 + Game.Ping / 2;
HealthPrediction.GetHealthPrediction(dragon, time, (int) Spells.R.Delay);
if (b)
{
}
}
protected override void LargeUpdate()
{
if (GameObject == null || GameObject.IsDead)
GameObject = ObjectManager.Get<Obj_AI_Minion>().FirstOrDefault(x => x.CampNumber > 0 && x.Name.Contains("Baron12.1.1") && x.IsVisible);
if (CanBeDone() && ObjectiveCommons.HasAnyoneNashorBuff())
{
_respawnTime = (int)Game.Time + 7 * 60 - Tolerance;
GameObject = null;
}
base.LargeUpdate();
}
static Heal()
{
Game.OnUpdate += Game_OnGameUpdate;
adCarry = ObjectManager.Get<Obj_AI_Base>().FirstOrDefault(x => x.IsMe);
jungleMobs = ObjectManager.Get<Obj_AI_Minion>().FirstOrDefault(x => x.IsValidTarget(Orbwalking.GetRealAutoAttackRange(ObjectManager.Player) + 100)
&& x.CharData.BaseSkinName.Contains("Dragon")
|| x.CharData.BaseSkinName.Contains("Baron")
|| x.CharData.BaseSkinName.Contains("SRU_Blue")
|| x.CharData.BaseSkinName.Contains("SRU_Red") && x.IsVisible && !x.IsDead);
if (adCarry != null)
{
Console.Write(adCarry.CharData.BaseSkinName);
}
}
public override void attackMinion(Obj_AI_Minion minion, bool onlyAA)
{
if (JungleOrbwalker.CanAttack())
{
UseE(minion);
UseR(minion);
}
// shouldUseSafe();
if (JungleClearer.focusedCamp.useSafe)
JungleOrbwalker.attackMinion(minion, JungleClearer.focusedCamp.safePosition);
else
JungleOrbwalker.attackMinion(minion, minion.Position.To2D().Extend(player.Position.To2D(), 100).To3D());
}
public override void attackMinion(Obj_AI_Minion minion, bool onlyAA)
{
// if (onlyAA)return;
if (JungleOrbwalker.CanAttack())
{
if (minion.Distance(player) > 400 && minion.Distance(player) <= Q.Range)
UseQ(minion);
UseW(minion);
UseE(minion);
UseR(minion);
}
JungleOrbwalker.attackMinion(minion, minion.Position.To2D().Extend(player.Position.To2D(), 100).To3D());
}
public Camp(int campId, string name, Vector2 position, int respawnTime)
{
_respawnDuration = respawnTime * 60 * 1000;
_isMajor = IsMajorCamp(name);
Name = name;
Sprite = GetMapSprite(Name, position);
RenderText = GetRenderText(position, _isMajor);
RespawnTime = 0;
foreach (var obj in ObjectManager.Get<Obj_AI_Minion>().Where(obj => obj.CampNumber == campId))
CampObject = obj;
Game.OnGameUpdate += Game_OnGameUpdate;
}
private void Game_OnUpdate(System.EventArgs args)
{
if (targetUnderTurret != null && targetUnderTurret.IsDead)
{
targetUnderTurret = null;
turrent = null;
}
if (zedOrbwalker.ActiveMode != Orbwalking.OrbwalkingMode.Combo
&& zedOrbwalker.ActiveMode != Orbwalking.OrbwalkingMode.None && turrent != null
&& targetUnderTurret != null && !targetUnderTurret.IsDead && targetUnderTurret.IsValid)
{
if (targetUnderTurret.IsValid)
{
if (ObjectManager.Player.Distance(targetUnderTurret)
< Orbwalking.GetRealAutoAttackRange(targetUnderTurret) + 20F
&& (targetUnderTurret.Health
< (ObjectManager.Player.GetAutoAttackDamage(targetUnderTurret) * 2)
+ turrent.GetAutoAttackDamage(targetUnderTurret)
&& targetUnderTurret.Health
> turrent.GetAutoAttackDamage(targetUnderTurret)
+ ObjectManager.Player.GetAutoAttackDamage(targetUnderTurret)))
{
ObjectManager.Player.IssueOrder(GameObjectOrder.AttackUnit, targetUnderTurret);
}
if (q.IsReady() && q.CanCast(targetUnderTurret)
&& ObjectManager.Player.Distance(targetUnderTurret)
< Orbwalking.GetRealAutoAttackRange(targetUnderTurret) + 20F
&& targetUnderTurret.Health
< q.GetDamage(targetUnderTurret)
+ ObjectManager.Player.GetAutoAttackDamage(targetUnderTurret, true))
{
q.Cast(targetUnderTurret);
return;
}
if (e.IsReady() && e.CanCast(targetUnderTurret) && !q.IsReady()
&& ObjectManager.Player.Distance(targetUnderTurret)
< Orbwalking.GetRealAutoAttackRange(targetUnderTurret) + 20F
&& targetUnderTurret.Health
< e.GetDamage(targetUnderTurret)
+ ObjectManager.Player.GetAutoAttackDamage(targetUnderTurret, true))
{
e.Cast(targetUnderTurret);
}
}
}
}
public override void attackMinion(Obj_AI_Minion minion, bool onlyAA)
{
if (JungleOrbwalker.CanAttack())
{
if (minion.Distance(player) < 250)
{
if (getEnchCount() == 5)
UseQ(minion);
UseW(minion);
UseE(minion);
UseR(minion);
}
}
JungleOrbwalker.attackMinion(minion, minion.Position.To2D().Extend(player.Position.To2D(), 150).To3D());
}
public static void Farm(string championName, Obj_AI_Minion minion)
{
switch(championName)
{
case "Annie":
Annie.Farm(minion);
break;
case "Ryze":
Ryze.Farm(minion);
break;
case "Tristana":
Tristana.Farm(minion);
break;
}
}
public static float JungleCalculator(Obj_AI_Minion minion, int customStacks = -1)
{
int buff = minion.GetBuffCount("KalistaExpungeMarker");
if (buff > 0 || customStacks > -1)
{
var tDamage = (RRD[Program.E.Level - 1] + RRDM[Program.E.Level - 1] * ObjectManager.Player.TotalAttackDamage) +
((customStacks < 0 ? buff : customStacks) - 1) *
(RRPS[Program.E.Level - 1] + RRPSM[Program.E.Level - 1] * ObjectManager.Player.TotalAttackDamage);
return (float)ObjectManager.Player.CalcDamage(minion, Damage.DamageType.Physical, tDamage);
}
return 0;
}
private static void Variables()
{
UseSwap = true;
lastW = 0;
wClone = null;
rClone = null;
CloneWCreated = false;
CloneWFound = false;
CloneWTick = 0;
CloneRCreated = false;
CloneRFound = false;
CloneRTick = 0;
RCastTick = 0;
WCasted = false;
CheckW = false;
}
public static float JungleTotalDamage(Obj_AI_Minion target)
{
var damage = 0f;
if (Program.E.IsReady())
{
switch (Program.Config.Item("calculator").GetValue<StringList>().SelectedIndex)
{
case 0:
damage += JungleCalculator(target);
break;
case 1:
damage += (float)ObjectManager.Player.CalcDamage(target, Damage.DamageType.Physical, Program.E.GetDamage(target));
break;
}
}
return (float)damage;
}
private static void AddMinionObject(Obj_AI_Minion minion)
{
if (minion.MaxHealth >= 225)
{
if (minion.Team == GameObjectTeam.Neutral)
{
MinionsListNeutral.Add(minion);
}
else if (minion.MaxMana == 0 && minion.MaxHealth >= 300)
{
if (minion.Team == GameObjectTeam.Unknown)
return;
if (minion.Team != ObjectManager.Player.Team)
MinionsListEnemy.Add(minion);
else if (minion.Team == ObjectManager.Player.Team)
MinionsListAlly.Add(minion);
}
}
}
private void Obj_AI_Base_OnTarget(Obj_AI_Base sender, Obj_AI_BaseTargetEventArgs args)
{
if (sender == null || args.Target == null || !sender.IsAlly || !args.Target.IsEnemy
|| !sender.SkinName.ToLowerInvariant().Contains("turret")
|| !args.Target.Name.ToLowerInvariant().Contains("minion"))
{
return;
}
if (ObjectManager.Player.Distance(args.Target) <= q.Range)
{
turrent = sender;
targetUnderTurret = new Obj_AI_Minion((ushort)args.Target.Index, (uint)args.Target.NetworkId); ;
}
else
{
turrent = null;
targetUnderTurret = null;
}
}
public override void UseR(Obj_AI_Minion minion)
{
}
void Waveclear()
{
if (SpellSlot.Q.IsReady() && !Yasuo.LSIsDashing() && !InDash)
{
if (!TornadoReady && GetBool("Waveclear.UseQ", YasuoMenu.WaveclearM) && Orbwalker.IsAutoAttacking)
{
var minion =
ObjectManager.Get <Obj_AI_Minion>()
.Where(x => x.IsValidMinion(Spells[Q].Range) && ((x.IsDashable() && (x.Health - Yasuo.GetSpellDamage(x, SpellSlot.Q) >= GetProperEDamage(x))) || (x.Health - Yasuo.GetSpellDamage(x, SpellSlot.Q) >= 0.15 * x.MaxHealth || x.QCanKill()))).MaxOrDefault(x => x.MaxHealth);
if (minion != null)
{
Spells[Q].Cast(minion);
LastTornadoClearTick = Helper.TickCount;
}
}
else if (TornadoReady && GetBool("Waveclear.UseQ2", YasuoMenu.WaveclearM))
{
var minions = ObjectManager.Get <Obj_AI_Minion>().Where(x => x.Distance(Yasuo) > Yasuo.AttackRange && x.IsValidMinion(Spells[Q2].Range) && ((x.IsDashable() && x.Health - Yasuo.GetSpellDamage(x, SpellSlot.Q) >= 0.85 * GetProperEDamage(x)) || (x.Health - Yasuo.GetSpellDamage(x, SpellSlot.Q) >= 0.10 * x.MaxHealth) || x.CanKill(SpellSlot.Q)));
var pred =
MinionManager.GetBestLineFarmLocation(minions.Select(m => m.ServerPosition.LSTo2D()).ToList(),
Spells[Q2].Width, Spells[Q2].Range);
if (pred.MinionsHit >= GetSliderInt("Waveclear.Qcount", YasuoMenu.WaveclearM))
{
Spells[Q2].Cast(pred.Position);
}
}
}
if (Helper.TickCount - LastTornadoClearTick < 500)
{
return;
}
if (SpellSlot.E.IsReady() && GetBool("Waveclear.UseE", YasuoMenu.WaveclearM) && (!GetBool("Waveclear.Smart", YasuoMenu.WaveclearM) || isHealthy) && (Helper.TickCount - WCLastE) >= GetSliderInt("Waveclear.Edelay", YasuoMenu.WaveclearM))
{
var minions = ObjectManager.Get <Obj_AI_Minion>().Where(x => x.IsDashable() && ((GetBool("Waveclear.UseENK", YasuoMenu.WaveclearM) && (!GetBool("Waveclear.Smart", YasuoMenu.WaveclearM) || x.Health - GetProperEDamage(x) > GetProperEDamage(x) * 3)) || x.ECanKill()) && (GetBool("Waveclear.ETower", YasuoMenu.WaveclearM) || GetKeyBind("Misc.TowerDive", YasuoMenu.MiscM) || !GetDashPos(x).PointUnderEnemyTurret()));
Obj_AI_Minion minion = null;
minion = minions.OrderBy(x => x.ECanKill()).ThenBy(x => GetDashPos(x).MinionsInRange(200)).FirstOrDefault();
if (minion != null)
{
Spells[E].Cast(minion);
WCLastE = Helper.TickCount;
}
}
if (GetBool("Waveclear.UseItems", YasuoMenu.WaveclearM))
{
if (GetBool("Waveclear.UseTIA", YasuoMenu.WaveclearM))
{
Tiamat.minioncount = GetSliderInt("Waveclear.MinCountHDR", YasuoMenu.WaveclearM);
Tiamat.Cast(null, true);
}
if (GetBool("Waveclear.UseTitanic", YasuoMenu.WaveclearM))
{
Titanic.minioncount = GetSliderInt("Waveclear.MinCountHDR", YasuoMenu.WaveclearM);
Titanic.Cast(null, true);
}
if (GetBool("Waveclear.UseHDR", YasuoMenu.WaveclearM))
{
Hydra.minioncount = GetSliderInt("Waveclear.MinCountHDR", YasuoMenu.WaveclearM);
Hydra.Cast(null, true);
}
if (GetBool("Waveclear.UseYMU", YasuoMenu.WaveclearM))
{
Youmu.minioncount = GetSliderInt("Waveclear.MinCountYOU", YasuoMenu.WaveclearM);
Youmu.Cast(null, true);
}
}
}
public virtual AttackableUnit GetTarget()
{
AttackableUnit result = null;
var mode = ActiveMode;
if ((mode == OrbwalkingMode.Mixed || mode == OrbwalkingMode.LaneClear) && !Menu.Item("PriorizeFarm").GetValue <bool>())
{
var target = TargetSelector.GetTarget(-1, TargetSelector.DamageType.Physical);
if (target != null && InAutoAttackRange(target))
{
return(target);
}
}
var attackGankPlankBarrels = Menu.Item("AttackGPBarrel").GetValue <StringList>().SelectedIndex;
if (attackGankPlankBarrels != 2 && (attackGankPlankBarrels == 0 || (mode == OrbwalkingMode.LaneClear || mode == OrbwalkingMode.Mixed || mode == OrbwalkingMode.LastHit || mode == OrbwalkingMode.Freeze)))
{
var enemyGangPlank = HeroManager.Enemies.FirstOrDefault(e => e.ChampionName.Equals("gangplank", StringComparison.InvariantCultureIgnoreCase));
if (enemyGangPlank != null)
{
var barrels = Get <Obj_AI_Minion>().Where(minion => minion.Team == GameObjectTeam.Neutral && minion.CharData.BaseSkinName == "gangplankbarrel" && minion.IsHPBarRendered && minion.IsValidTarget() && InAutoAttackRange(minion));
var objAiMinions = barrels as Obj_AI_Minion[] ?? barrels.ToArray();
foreach (var barrel in objAiMinions)
{
if (barrel.Health <= 1f)
{
return(barrel);
}
var t = (int)(player.AttackCastDelay * 1000) + Game.Ping / 2 + 1000 * (int)Math.Max(0, player.Distance(barrel) - player.BoundingRadius) / (int)GetMyProjectileSpeed();
var barrelBuff = barrel.Buffs.FirstOrDefault(b => b.Name.Equals("gangplankebarrelactive", StringComparison.InvariantCultureIgnoreCase));
if (barrelBuff != null && barrel.Health <= 2f)
{
var healthDecayRate = enemyGangPlank.Level >= 13 ? 0.5f : (enemyGangPlank.Level >= 7 ? 1f : 2f);
var nextHealthDecayTime = Game.Time < barrelBuff.StartTime + healthDecayRate ? barrelBuff.StartTime + healthDecayRate : barrelBuff.StartTime + healthDecayRate * 2;
if (nextHealthDecayTime <= Game.Time + t / 1000f)
{
return(barrel);
}
}
}
if (objAiMinions.Any())
{
return(null);
}
}
}
if (mode == OrbwalkingMode.LaneClear || mode == OrbwalkingMode.Mixed || mode == OrbwalkingMode.LastHit || mode == OrbwalkingMode.Freeze)
{
var MinionList = 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 + Game.Ping / 2 + 1000 * (int)Math.Max(0, player.Distance(minion) - player.BoundingRadius) / (int)GetMyProjectileSpeed();
if (mode == OrbwalkingMode.Freeze)
{
t += 200 + Game.Ping / 2;
}
var predHealth = HealthPrediction.GetHealthPrediction(minion, t, FarmDelay);
if (minion.Team != GameObjectTeam.Neutral && ShouldAttackMinion(minion))
{
var damage = player.GetAutoAttackDamage(minion, true);
var killable = predHealth <= damage;
if (mode == OrbwalkingMode.Freeze)
{
if (minion.Health < 50 || predHealth <= 50)
{
return(minion);
}
}
else
{
if (predHealth <= 0)
{
FireOnNonKillableMinion(minion);
}
if (killable)
{
return(minion);
}
}
}
}
}
if (_forcedTarget.IsValidTarget() && InAutoAttackRange(_forcedTarget))
{
return(_forcedTarget);
}
if (mode == OrbwalkingMode.LaneClear && (!Menu.Item("FocusMinionsOverTurrets").GetValue <KeyBind>().Active || !MinionManager.GetMinions(ObjectManager.Player.Position, GetRealAutoAttackRange(ObjectManager.Player)).Any()))
{
foreach (var turret in Get <Obj_AI_Turret>().Where(t => t.IsValidTarget() && InAutoAttackRange(t)))
{
return(turret);
}
foreach (var turret in Get <Obj_BarracksDampener>().Where(t => t.IsValidTarget() && InAutoAttackRange(t)))
{
return(turret);
}
foreach (var nexus in Get <Obj_HQ>().Where(t => t.IsValidTarget() && InAutoAttackRange(t)))
{
return(nexus);
}
}
if (mode != OrbwalkingMode.LastHit)
{
if (mode != OrbwalkingMode.LaneClear || !ShouldWait())
{
var target = TargetSelector.GetTarget(-1, TargetSelector.DamageType.Physical);
if (target.IsValidTarget() && InAutoAttackRange(target))
{
return(target);
}
}
}
if (mode == OrbwalkingMode.LaneClear || mode == OrbwalkingMode.Mixed)
{
var jminions = Get <Obj_AI_Minion>().Where(mob => mob.IsValidTarget() && mob.Team == GameObjectTeam.Neutral && InAutoAttackRange(mob) && mob.CharData.BaseSkinName != "gangplankbarrel" && mob.Name != "WardCorpse");
result = Menu.Item("Smallminionsprio").GetValue <bool>() ? jminions.MinOrDefault(mob => mob.MaxHealth) : jminions.MaxOrDefault(mob => mob.MaxHealth);
if (result != null)
{
return(result);
}
}
if (mode == OrbwalkingMode.LaneClear || mode == OrbwalkingMode.Mixed || mode == OrbwalkingMode.LastHit || mode == OrbwalkingMode.Freeze)
{
var closestTower = Get <Obj_AI_Turret>().MinOrDefault(t => t.IsAlly && !t.IsDead ? player.Distance(t, true) : float.MaxValue);
if (closestTower != null && player.Distance(closestTower, true) < 1500 * 1500)
{
Obj_AI_Minion farmUnderTurretMinion = null;
Obj_AI_Minion noneKillableMinion = null;
var minions = MinionManager.GetMinions(player.Position, player.AttackRange + 200)
.Where(minion => InAutoAttackRange(minion) && closestTower.Distance(minion, true) < 900 * 900)
.OrderByDescending(minion => minion.CharData.BaseSkinName.Contains("Siege"))
.ThenBy(minion => minion.CharData.BaseSkinName.Contains("Super"))
.ThenByDescending(minion => minion.MaxHealth)
.ThenByDescending(minion => minion.Health);
if (minions.Any())
{
var turretMinion = minions.FirstOrDefault(minion => minion is Obj_AI_Minion && HealthPrediction.HasTurretAggro((Obj_AI_Minion)minion));
if (turretMinion != null)
{
var hpLeftBeforeDie = 0;
var hpLeft = 0;
var turretAttackCount = 0;
var turretStarTick = HealthPrediction.TurretAggroStartTick(turretMinion as Obj_AI_Minion);
var turretLandTick = turretStarTick + (int)(closestTower.AttackCastDelay * 1000) + 1000 * Math.Max(0, (int)(turretMinion.Distance(closestTower) - closestTower.BoundingRadius)) / (int)(closestTower.BasicAttack.MissileSpeed + 70);
for (float i = turretLandTick + 50; i < turretLandTick + 10 * closestTower.AttackDelay * 1000 + 50; i = i + closestTower.AttackDelay * 1000)
{
var time = (int)i - Utils.GameTimeTickCount + Game.Ping / 2;
var predHP = (int)HealthPrediction.LaneClearHealthPrediction(turretMinion, time > 0 ? time : 0);
if (predHP > 0)
{
hpLeft = predHP;
turretAttackCount += 1;
continue;
}
hpLeftBeforeDie = hpLeft;
hpLeft = 0;
break;
}
if (hpLeft == 0 && turretAttackCount != 0 && hpLeftBeforeDie != 0)
{
var damage = (int)player.GetAutoAttackDamage(turretMinion, true);
var hits = hpLeftBeforeDie / damage;
var timeBeforeDie = turretLandTick + (turretAttackCount + 1) * (int)(closestTower.AttackDelay * 1000) - Utils.GameTimeTickCount;
var timeUntilAttackReady = LastAATick + (int)(player.AttackDelay * 1000) > Utils.GameTimeTickCount + Game.Ping / 2 + 25 ? LastAATick + (int)(player.AttackDelay * 1000) - (Utils.GameTimeTickCount + Game.Ping / 2 + 25) : 0;
var timeToLandAttack = player.IsMelee ? player.AttackCastDelay * 1000 : player.AttackCastDelay * 1000 + 1000 * Math.Max(0, turretMinion.Distance(player) - player.BoundingRadius) / player.BasicAttack.MissileSpeed;
if (hits >= 1 && hits * player.AttackDelay * 1000 + timeUntilAttackReady + timeToLandAttack < timeBeforeDie)
{
farmUnderTurretMinion = turretMinion as Obj_AI_Minion;
}
else if (hits >= 1 && hits * player.AttackDelay * 1000 + timeUntilAttackReady + timeToLandAttack > timeBeforeDie)
{
noneKillableMinion = turretMinion as Obj_AI_Minion;
}
}
else if (hpLeft == 0 && turretAttackCount == 0 && hpLeftBeforeDie == 0)
{
noneKillableMinion = turretMinion as Obj_AI_Minion;
}
if (ShouldWaitUnderTurret(noneKillableMinion))
{
return(null);
}
if (farmUnderTurretMinion != null)
{
return(farmUnderTurretMinion);
}
foreach (var minion in minions.Where(x => x.NetworkId != turretMinion.NetworkId && x is Obj_AI_Minion && !HealthPrediction.HasMinionAggro((Obj_AI_Minion)x)))
{
var playerDamage = (int)player.GetAutoAttackDamage(minion);
var turretDamage = (int)closestTower.GetAutoAttackDamage(minion, true);
var leftHP = (int)minion.Health % turretDamage;
if (leftHP > playerDamage)
{
return(minion);
}
}
var lastminion = minions.LastOrDefault(x => x.NetworkId != turretMinion.NetworkId && x is Obj_AI_Minion && !HealthPrediction.HasMinionAggro((Obj_AI_Minion)x));
if (lastminion != null && minions.Count() >= 2)
{
if (1f / player.AttackDelay >= 1f && (int)(turretAttackCount * closestTower.AttackDelay / player.AttackDelay) * player.GetAutoAttackDamage(lastminion) > lastminion.Health)
{
return(lastminion);
}
if (minions.Count() >= 5 && 1f / player.AttackDelay >= 1.2)
{
return(lastminion);
}
}
}
else
{
if (ShouldWaitUnderTurret(noneKillableMinion))
{
return(null);
}
foreach (
var minion in
minions.Where(
x =>
x is Obj_AI_Minion &&
!HealthPrediction.HasMinionAggro((Obj_AI_Minion)x)))
{
{
var playerDamage = (int)player.GetAutoAttackDamage(minion);
var turretDamage = (int)closestTower.GetAutoAttackDamage(minion, true);
var leftHP = (int)minion.Health % turretDamage;
if (leftHP > playerDamage)
{
return(minion);
}
}
}
var lastminion =
minions.LastOrDefault(
x =>
x is Obj_AI_Minion &&
!HealthPrediction.HasMinionAggro((Obj_AI_Minion)x));
if (lastminion == null || minions.Count() < 2)
{
return(null);
}
if (minions.Count() >= 5 && 1f / player.AttackDelay >= 1.2)
{
return(lastminion);
}
}
return(null);
}
}
}
if (mode == 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 = Get <Obj_AI_Minion>()
.Where(
minion =>
minion.IsValidTarget() && InAutoAttackRange(minion) && ShouldAttackMinion(minion))
.Select(
minion =>
new
{
minion,
predHealth =
HealthPrediction.LaneClearHealthPrediction(minion,
(int)(player.AttackDelay * 1000 * LaneClearWaitTimeMod), FarmDelay)
})
.Where(
t =>
t.predHealth >= 2 * player.GetAutoAttackDamage(t.minion) ||
Math.Abs(t.predHealth - t.minion.Health) < float.Epsilon)
.Select(t => t.minion).MaxOrDefault(m => !MinionManager.IsMinion(m, true) ? float.MaxValue : m.Health);
if (result != null)
{
_prevMinion = (Obj_AI_Minion)result;
}
}
}
return(result);
}
/// <summary>
/// Determines whether the specified minion is a valid attackable ward.
/// </summary>
/// <param name="minion">The minion you want to check for</param>
/// <returns><c>true</c> if the given minion is a valid attackable ward, otherwise returns <c>false</c>.</returns>
public static bool IsWard(Obj_AI_Minion minion)
{
return(minion.Name.Contains("Ward") && minion.IsHPBarRendered);
}
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 <= GetAADamage(minion))
{
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 * GetAADamage(_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 * GetAADamage(minion) ||
Math.Abs(predHealth - minion.Health) < float.Epsilon
select minion).MaxOrDefault(m => m.Health);
if (result != null)
{
_prevMinion = (Obj_AI_Minion)result;
}
}
}
return(result);
}
public static float EnemyMinionInMinionRange(Obj_AI_Minion Minion, float Range)
{
return(ObjectManager.Get <Obj_AI_Minion>().Where(m => m.Team != ObjectManager.Player.Team && m.Distance(Minion) <= Range && !m.IsDead).Count());
}
private static float EDamageMinion(Obj_AI_Minion minion)
{
return(Player.Instance.CalculateDamageOnUnit(minion, DamageType.Physical, ERawMinion(minion)) *
(Player.Instance.HasBuff("summonerexhaust") ? 0.6f : 1));
}
public static void OnUpdate()
{
if (MenuConfig.LaneClear["Check"].Enabled && Global.Player.CountEnemyHeroesInRange(2000) > 0 ||
Maths.GetEnergyPercent() < MenuConfig.LaneClear["Energy"].Value)
{
return;
}
if (_turretTarget != null && _turret != null && MenuConfig.LaneClear["TurretFarm"].Enabled)
{
if (_turretTarget.IsDead)
{
_turret = null;
_turretTarget = null;
}
else
{
var turretDamage = _turret.GetAutoAttackDamage(_turretTarget);
var playerDamage = Global.Player.GetAutoAttackDamage(_turretTarget);
var inAaRange = _turretTarget.Distance(Global.Player) <= Global.Player.AttackRange + 65;
if (!inAaRange)
{
return;
}
if (_turretTarget.Health < playerDamage * 2 + turretDamage &&
_turretTarget.Health > turretDamage + playerDamage && Global.Orbwalker.CanAttack())
{
Global.Orbwalker.Attack(_turretTarget);
}
else if (SpellManager.E.Ready && _turretTarget.Health <
Global.Player.GetSpellDamage(_turretTarget, SpellSlot.E) + playerDamage)
{
SpellManager.CastE(_turretTarget);
}
else if (SpellManager.Q.Ready && _turretTarget.Health <
Global.Player.GetSpellDamage(_turretTarget, SpellSlot.Q) + playerDamage)
{
SpellManager.CastQ(_turretTarget);
}
}
}
else
{
var minion = GameObjects.EnemyMinions.FirstOrDefault(x => x.IsValidTarget(SpellManager.Q.Range));
if (minion == null)
{
return;
}
if (SpellManager.Q.Ready && MenuConfig.LaneClear["Q"].Enabled)
{
SpellManager.CastQ(minion, MenuConfig.LaneClear["Q"].Value);
}
if (SpellManager.W.Ready && MenuConfig.LaneClear["W"].Enabled)
{
if (GameObjects.EnemyMinions.Count(x => x.IsValidTarget(1300)) >= 6 && Global.Player.Level >= 12 && Maths.GetEnergyPercent() >= 70)
{
if (ShadowManager.CanCastW1())
{
SpellManager.W.Cast(minion.ServerPosition);
}
else
{
SpellManager.W.Cast();
}
}
}
if (SpellManager.E.Ready && MenuConfig.LaneClear["E"].Enabled)
{
SpellManager.CastE(minion, MenuConfig.LaneClear["E"].Value);
}
}
}
internal static bool IsValidMinion(this Obj_AI_Minion minion)
{
return(minion != null && minion.IsValid && minion.IsVisible && minion.Team != Player.Team && minion.IsHPBarRendered && !minion.CharData.BaseSkinName.ToLower().Contains("ward"));
}
private static void WaveClear()
{
var Minions =
ObjectManager.Get <Obj_AI_Minion>()
.Where(
m =>
(m.LSIsValidTarget()) &&
(Vector3.Distance(m.ServerPosition, Player.ServerPosition) <= Spells[SpellSlot.R].Range));
if (SpellSlot.Q.IsReady() && CassioUtils.getCheckBoxItem(CassiopeiaMenu.Waveclear, "Waveclear.UseQ"))
{
var qminions =
Minions.Where(
m =>
Vector3.Distance(m.ServerPosition, Player.ServerPosition) <= Spells[SpellSlot.Q].Range);
MinionManager.FarmLocation QLocation =
MinionManager.GetBestCircularFarmLocation(
qminions.Select(m => m.ServerPosition.LSTo2D()).ToList(), Spells[SpellSlot.Q].Width,
Spells[SpellSlot.Q].Range);
if (QLocation.MinionsHit >= 1)
{
Spells[SpellSlot.Q].Cast(QLocation.Position);
}
}
if (SpellSlot.W.IsReady() && CassioUtils.getCheckBoxItem(CassiopeiaMenu.Waveclear, "Waveclear.UseW"))
{
var wminions = Minions.Where(m =>
Vector3.Distance(m.ServerPosition, Player.ServerPosition) <= Spells[SpellSlot.W].Range);
MinionManager.FarmLocation WLocation =
MinionManager.GetBestCircularFarmLocation(
wminions.Select(m => m.ServerPosition.LSTo2D()).ToList(), Spells[SpellSlot.W].Width,
Spells[SpellSlot.W].Range);
if (WLocation.MinionsHit >= 1)
{
Spells[SpellSlot.W].Cast(WLocation.Position);
}
}
if (SpellSlot.E.IsReady() && CassioUtils.getCheckBoxItem(CassiopeiaMenu.Waveclear, "Waveclear.UseE"))
{
Obj_AI_Minion KillableMinionE = null;
var eminions = Minions.Where(m =>
Vector3.Distance(m.ServerPosition, Player.ServerPosition) <= Spells[SpellSlot.E].Range);
if (CassioUtils.getCheckBoxItem(CassiopeiaMenu.Waveclear, "Waveclear.useekillable"))
{
KillableMinionE = eminions.FirstOrDefault(m => m.Health < Player.LSGetSpellDamage(m, SpellSlot.E));
}
else
{
KillableMinionE = eminions.OrderBy(x => x.Health).FirstOrDefault();
}
if (KillableMinionE != null)
{
if (CassioUtils.getCheckBoxItem(CassiopeiaMenu.Waveclear, "Waveclear.useepoison"))
{
if (KillableMinionE.isPoisoned())
{
Spells[SpellSlot.E].Cast(KillableMinionE);
}
}
else
{
Spells[SpellSlot.E].Cast(KillableMinionE);
}
}
}
if (SpellSlot.R.IsReady() && CassioUtils.getCheckBoxItem(CassiopeiaMenu.Waveclear, "Waveclear.UseR"))
{
MinionManager.FarmLocation RLocation =
MinionManager.GetBestLineFarmLocation(
Minions.Select(m => m.ServerPosition.LSTo2D()).ToList(), Spells[SpellSlot.R].Width,
Spells[SpellSlot.R].Range);
if (RLocation.MinionsHit > CassioUtils.getSliderItem(CassiopeiaMenu.Waveclear, "Waveclear.Rcount"))
{
Spells[SpellSlot.R].Cast(RLocation.Position);
}
}
}
private void Game_OnUpdate(EventArgs args)
{
if (!azir.Spells.R.IsReady())
{
return;
}
var insecPoint = new Vector3(0, 2, 3);
if (Clickposition == new Vector3(0, 0, 0))
{
insecPoint = Game.CursorPos;
}
else
{
insecPoint = Clickposition;
}
if (!AzirMenu._jumpMenu["inseckey"].Cast <KeyBind>().CurrentValue)
{
steps = Steps.firstCalcs;
soldier = null;
return;
}
azir.Orbwalk(Game.CursorPos);
if (!insecPoint.IsValid())
{
return;
}
var target = TargetSelector.SelectedTarget;
if (target == null)
{
return;
}
if (!target.IsValidTarget() || target.IsZombie)
{
steps = Steps.firstCalcs;
return;
}
var insecPos = new Vector3(0, 0, 0);
if (Clickposition == new Vector3(0, 0, 0))
{
insecPos = Game.CursorPos;
}
else
{
insecPos = insecPoint;
}
var postoGo = target.ServerPosition;
switch (steps)
{
case Steps.firstCalcs:
if (target.Distance(HeroManager.Player) <= azir.Spells.W.Range + azir.Spells.Q.Range - 100)
{
steps = Steps.jump;
}
break;
case Steps.jump:
if (HeroManager.Player.ServerPosition.Distance(postoGo) <= 220)
{
steps = Steps.R;
}
else
{
azir._modes._jump.updateLogicJumpInsec(postoGo);
}
break;
case Steps.R:
if (azir.Hero.Distance(target) < 220)
{
var tower = ObjectManager.Get <Obj_AI_Turret>().FirstOrDefault(it => it.IsValidTarget(1000));
if (tower != null)
{
azir.Spells.R.Cast(tower.ServerPosition);
steps = Steps.firstCalcs;
}
else
{
azir.Spells.R.Cast(insecPoint);
steps = Steps.firstCalcs;
}
}
break;
}
}
/// <summary>
/// Determines whether the specified minion has turret aggro.
/// </summary>
/// <param name="minion">The minion</param>
/// <returns></returns>
public static bool HasTurretAggro(Obj_AI_Minion minion)
{
return(ActiveAttacks.Values.Any(m => m.Source is Obj_AI_Turret && m.Target.NetworkId == minion.NetworkId));
}
public static bool IsMinion(Obj_AI_Minion minion, bool includeWards = false)
{
return(IsMinion(minion as Obj_AI_Base, includeWards));
}
/// <summary>
/// Tells whether the <see cref="Obj_AI_Minion" /> is an actual minion.
/// </summary>
/// <param name="minion">Minion</param>
/// <param name="includeWards">Whether to include wards.</param>
/// <returns>Whether the <see cref="Obj_AI_Minion" /> is an actual minion.</returns>
public static bool IsMinion(Obj_AI_Minion minion, bool includeWards = false)
{
var name = minion.BaseSkinName.ToLower();
return(name.Contains("minion") || (includeWards && (name.Contains("ward") || name.Contains("trinket"))));
}
public void OnPostAttack(object sender, PostAttackEventArgs args)
{
var heroTarget = args.Target as Obj_AI_Hero;
if (Orbwalker.Mode.Equals(OrbwalkingMode.Combo))
{
Obj_AI_Hero hero = args.Target as Obj_AI_Hero;
if (hero == null || !hero.IsValid || !hero.IsEnemy)
{
return;
}
if (Player.HasItem(ItemId.TitanicHydra) || Player.HasItem(ItemId.Tiamat) ||
Player.HasItem(ItemId.RavenousHydra))
{
var items = new[] { ItemId.TitanicHydra, ItemId.Tiamat, ItemId.RavenousHydra };
var slot = Player.Inventory.Slots.First(s => items.Contains(s.ItemId));
if (slot != null)
{
var spellslot = slot.SpellSlot;
if (spellslot != SpellSlot.Unknown &&
Player.SpellBook.GetSpell(spellslot).State == SpellState.Ready)
{
Player.SpellBook.CastSpell(spellslot);
}
}
}
}
if (Orbwalker.Mode.Equals(OrbwalkingMode.Mixed))
{
if (!Menu["harass"]["waa"].Enabled)
{
return;
}
Obj_AI_Hero hero = args.Target as Obj_AI_Hero;
if (hero == null || !hero.IsValid || !hero.IsEnemy)
{
return;
}
if (Player.HasItem(ItemId.TitanicHydra) || Player.HasItem(ItemId.Tiamat) ||
Player.HasItem(ItemId.RavenousHydra))
{
var items = new[] { ItemId.TitanicHydra, ItemId.Tiamat, ItemId.RavenousHydra };
var slot = Player.Inventory.Slots.First(s => items.Contains(s.ItemId));
if (slot != null)
{
var spellslot = slot.SpellSlot;
if (spellslot != SpellSlot.Unknown &&
Player.SpellBook.GetSpell(spellslot).State == SpellState.Ready)
{
Player.SpellBook.CastSpell(spellslot);
}
}
}
}
if (Orbwalker.Mode.Equals(OrbwalkingMode.Laneclear))
{
if (!Menu["farming"]["items"].Enabled)
{
return;
}
Obj_AI_Minion hero = args.Target as Obj_AI_Minion;
if (hero == null || !hero.IsValid || !hero.IsEnemy)
{
return;
}
if (Player.HasItem(ItemId.TitanicHydra) || Player.HasItem(ItemId.Tiamat) ||
Player.HasItem(ItemId.RavenousHydra))
{
var items = new[] { ItemId.TitanicHydra, ItemId.Tiamat, ItemId.RavenousHydra };
var slot = Player.Inventory.Slots.First(s => items.Contains(s.ItemId));
if (slot != null)
{
var spellslot = slot.SpellSlot;
if (spellslot != SpellSlot.Unknown &&
Player.SpellBook.GetSpell(spellslot).State == SpellState.Ready)
{
Player.SpellBook.CastSpell(spellslot);
}
}
}
}
}
private static bool IsSoldier(this Obj_AI_Minion soldier)
{
return(soldier.IsAlly && String.Equals(soldier.BaseSkinName, "azirsoldier", StringComparison.InvariantCultureIgnoreCase));
}
internal override void PostAttack(object sender, PostAttackEventArgs e)
{
var heroTarget = e.Target as Obj_AI_Hero;
if (Orbwalker.Implementation.Mode.Equals(OrbwalkingMode.Combo))
{
Obj_AI_Hero hero = e.Target as Obj_AI_Hero;
if (hero == null || !hero.IsValid || !hero.IsEnemy)
{
return;
}
if (RootMenu["combo"]["eaa"].Enabled)
{
if (E.Cast())
{
Orbwalker.Implementation.ResetAutoAttackTimer();
}
}
if (RootMenu["combo"]["items"].Enabled)
{
if (Player.HasItem(ItemId.TitanicHydra) || Player.HasItem(ItemId.Tiamat) ||
Player.HasItem(ItemId.RavenousHydra))
{
var items = new[] { ItemId.TitanicHydra, ItemId.Tiamat, ItemId.RavenousHydra };
var slot = Player.Inventory.Slots.First(s => items.Contains(s.ItemId));
if (slot != null)
{
var spellslot = slot.SpellSlot;
if (spellslot != SpellSlot.Unknown &&
Player.SpellBook.GetSpell(spellslot).State == SpellState.Ready)
{
Player.SpellBook.CastSpell(spellslot);
}
}
}
}
}
if (Orbwalker.Implementation.Mode.Equals(OrbwalkingMode.Mixed))
{
Obj_AI_Hero hero = e.Target as Obj_AI_Hero;
if (hero == null || !hero.IsValid || !hero.IsEnemy)
{
return;
}
if (RootMenu["harass"]["eaa"].Enabled)
{
if (E.Cast())
{
Orbwalker.Implementation.ResetAutoAttackTimer();
}
}
if (RootMenu["combo"]["items"].Enabled)
{
if (Player.HasItem(ItemId.TitanicHydra) || Player.HasItem(ItemId.Tiamat) ||
Player.HasItem(ItemId.RavenousHydra))
{
var items = new[] { ItemId.TitanicHydra, ItemId.Tiamat, ItemId.RavenousHydra };
var slot = Player.Inventory.Slots.First(s => items.Contains(s.ItemId));
if (slot != null)
{
var spellslot = slot.SpellSlot;
if (spellslot != SpellSlot.Unknown &&
Player.SpellBook.GetSpell(spellslot).State == SpellState.Ready)
{
Player.SpellBook.CastSpell(spellslot);
}
}
}
}
}
if (Orbwalker.Implementation.Mode.Equals(OrbwalkingMode.Laneclear))
{
Obj_AI_Minion hero = e.Target as Obj_AI_Minion;
if (hero == null || !hero.IsValid || !hero.IsEnemy)
{
return;
}
if (Player.HasItem(ItemId.TitanicHydra) || Player.HasItem(ItemId.Tiamat) ||
Player.HasItem(ItemId.RavenousHydra))
{
var items = new[] { ItemId.TitanicHydra, ItemId.Tiamat, ItemId.RavenousHydra };
var slot = Player.Inventory.Slots.First(s => items.Contains(s.ItemId));
if (slot != null)
{
var spellslot = slot.SpellSlot;
if (spellslot != SpellSlot.Unknown &&
Player.SpellBook.GetSpell(spellslot).State == SpellState.Ready)
{
Player.SpellBook.CastSpell(spellslot);
}
}
}
}
}
internal static bool IsWard(this Obj_AI_Minion minion)
{
return(minion.GetMinionType().HasFlag(MinionTypes.Ward) && minion.CharData.BaseSkinName != "BlueTrinket");
}
private void Waveclear()
{
if (SpellSlot.Q.IsReady() && !Yasuo.IsDashing())
{
if (!TornadoReady && YasuoMenu.getCheckBoxItem(YasuoMenu.WaveclearA, "Waveclear.UseQ"))
{
var minion =
ObjectManager.Get <Obj_AI_Minion>()
.Where(
x =>
x.IsValidMinion(Spells[Q].Range) &&
((x.IsDashable() &&
(x.Health - Yasuo.GetSpellDamage(x, SpellSlot.Q) >= GetProperEDamage(x))) ||
x.Health - Yasuo.GetSpellDamage(x, SpellSlot.Q) >= 0.15 * x.MaxHealth || x.QCanKill()))
.MaxOrDefault(x => x.MaxHealth);
if (minion != null)
{
Spells[Q].Cast(minion.ServerPosition);
}
}
else if (TornadoReady && YasuoMenu.getCheckBoxItem(YasuoMenu.WaveclearA, "Waveclear.UseQ2"))
{
var minions =
ObjectManager.Get <Obj_AI_Minion>()
.Where(
x =>
x.Distance(Yasuo) > Yasuo.AttackRange && x.IsValidMinion(Spells[Q2].Range) &&
((x.IsDashable() &&
x.Health - Yasuo.GetSpellDamage(x, SpellSlot.Q) >= 0.85 * GetProperEDamage(x)) ||
(x.Health - Yasuo.GetSpellDamage(x, SpellSlot.Q) >= 0.10 * x.MaxHealth) ||
x.CanKill(SpellSlot.Q)));
var pred =
MinionManager.GetBestLineFarmLocation(minions.Select(m => m.ServerPosition.To2D()).ToList(),
Spells[Q2].Width, Spells[Q2].Range);
if (pred.MinionsHit >= YasuoMenu.getSliderItem(YasuoMenu.WaveclearA, "Waveclear.Qcount"))
{
Spells[Q2].Cast(pred.Position);
}
}
}
if (SpellSlot.E.IsReady() && YasuoMenu.getCheckBoxItem(YasuoMenu.WaveclearA, "Waveclear.UseE") &&
(!YasuoMenu.getCheckBoxItem(YasuoMenu.WaveclearA, "Waveclear.Smart") || isHealthy))
{
var minions =
ObjectManager.Get <Obj_AI_Minion>()
.Where(
x =>
x.IsDashable() &&
((YasuoMenu.getCheckBoxItem(YasuoMenu.WaveclearA, "Waveclear.UseENK") &&
(!YasuoMenu.getCheckBoxItem(YasuoMenu.WaveclearA, "Waveclear.Smart") ||
x.Health - GetProperEDamage(x) > GetProperEDamage(x) * 3)) || x.ECanKill()) &&
(YasuoMenu.getCheckBoxItem(YasuoMenu.WaveclearA, "Waveclear.ETower") ||
YasuoMenu.getKeyBindItem(YasuoMenu.MiscA, "Misc.TowerDive") ||
!GetDashPos(x).PointUnderEnemyTurret()));
Obj_AI_Minion minion = null;
minion = minions.MaxOrDefault(x => GetDashPos(x).MinionsInRange(200));
if (minion != null)
{
Spells[E].Cast(minion);
}
}
if (YasuoMenu.getCheckBoxItem(YasuoMenu.WaveclearA, "Waveclear.UseItems"))
{
if (YasuoMenu.getCheckBoxItem(YasuoMenu.WaveclearA, "Waveclear.UseTIA"))
{
Tiamat.minioncount = YasuoMenu.getSliderItem(YasuoMenu.WaveclearA, "Waveclear.MinCountHDR");
Tiamat.Cast(null, true);
}
if (YasuoMenu.getCheckBoxItem(YasuoMenu.WaveclearA, "Waveclear.UseHDR"))
{
Hydra.minioncount = YasuoMenu.getSliderItem(YasuoMenu.WaveclearA, "Waveclear.MinCountHDR");
Hydra.Cast(null, true);
}
if (YasuoMenu.getCheckBoxItem(YasuoMenu.WaveclearA, "Waveclear.UseYMU"))
{
Youmu.minioncount = YasuoMenu.getSliderItem(YasuoMenu.WaveclearA, "Waveclear.MinCountYOU");
Youmu.Cast(null, true);
}
}
}
//-------------------------------------------Game_OnTick----------------------------------------------
static void Game_OnTick(EventArgs args)
{
if (Player.IsDead)
{
return;
}
if (Zhonya.IsReady() && Menu["UseZhonya?"].Cast <CheckBox>().CurrentValue&& Player.HealthPercent <= Menu["ZhonyaHealth"].Cast <Slider>().CurrentValue&& EntityManager.Heroes.Enemies.Any(it => it.Distance(Player) <= it.GetAutoAttackRange() && it.IsValidTarget()))
{
Zhonya.Cast();
}
if (Player.CountEnemiesInRange(1000) > 0)
{
Modes.SaveAlly();
}
Target = TargetSelector.GetTarget(1300, DamageType.Magical);
Player2D = Player.ServerPosition.To2D();
//---------------------------------------------Smite Usage---------------------------------------------
if (Smite != null)
{
if (Smite.IsReady() && Menu["Use Smite?"].Cast <CheckBox>().CurrentValue)
{
Obj_AI_Minion Mob = EntityManager.MinionsAndMonsters.GetJungleMonsters(Player.Position, Smite.Range).FirstOrDefault();
if (Mob != default(Obj_AI_Minion))
{
bool kill = GetSmiteDamage() >= Mob.Health;
if (kill)
{
if ((Mob.Name.Contains("SRU_Dragon") || Mob.Name.Contains("SRU_Baron")))
{
Smite.Cast(Mob);
}
else if (Mob.Name.StartsWith("SRU_Red") && Menu["Red?"].Cast <CheckBox>().CurrentValue)
{
Smite.Cast(Mob);
}
else if (Mob.Name.StartsWith("SRU_Blue") && Menu["Blue?"].Cast <CheckBox>().CurrentValue)
{
Smite.Cast(Mob);
}
else if (Mob.Name.StartsWith("SRU_Murkwolf") && Menu["Wolf?"].Cast <CheckBox>().CurrentValue)
{
Smite.Cast(Mob);
}
else if (Mob.Name.StartsWith("SRU_Krug") && Menu["Krug?"].Cast <CheckBox>().CurrentValue)
{
Smite.Cast(Mob);
}
else if (Mob.Name.StartsWith("SRU_Gromp") && Menu["Gromp?"].Cast <CheckBox>().CurrentValue)
{
Smite.Cast(Mob);
}
else if (Mob.Name.StartsWith("SRU_Razorbeak") && Menu["Raptor?"].Cast <CheckBox>().CurrentValue)
{
Smite.Cast(Mob);
}
}
}
}
}
//--------------------------------------------Stack Stun-------------------------------------------
if (Menu["StackStun"].Cast <CheckBox>().CurrentValue&& !Player.HasBuff("recall") && !Player.HasBuff("pyromania_particle"))
{
if (!(Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.LaneClear) || Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.LastHit)) && E.IsReady())
{
E.Cast();
}
if (Player.IsInShopRange() && W.IsReady())
{
W.Cast(Player.Position);
}
}
//-----------------------------------------------Auto Ignite----------------------------------------
if (Menu["Auto Ignite"].Cast <CheckBox>().CurrentValue&& Ignite != null)
{
if (Ignite.IsReady())
{
var IgniteEnemy = EntityManager.Heroes.Enemies.FirstOrDefault(it => DamageLibrary.GetSummonerSpellDamage(Player, it, DamageLibrary.SummonerSpells.Ignite) >= it.Health - 30);
if (IgniteEnemy != null)
{
if ((IgniteEnemy.Distance(Player) >= 300 || Player.HealthPercent <= 40))
{
Ignite.Cast(IgniteEnemy);
}
}
}
}
//----------------------------------------------------KS----------------------------------------------
if (Menu["KS"].Cast <CheckBox>().CurrentValue&& Player.CountEnemiesInRange(Q.Range) > 0)
{
Modes.KS();
}
//--------------------------------------------Orbwalker Modes-------------------------------------------
if (Target != null)
{
if (Target.IsValidTarget())
{
Modes.UpdateVariables();
if (Player.HasBuff("infernalguardiantime"))
{
EloBuddy.Player.IssueOrder(GameObjectOrder.MovePet, Target); EloBuddy.Player.IssueOrder(GameObjectOrder.AutoAttackPet, Target);
}
//---------------------------------------------Flee Key-----------------------------------------------
if (R.IsReady())
{
if (Menu["Ult on Target"].Cast <KeyBind>().CurrentValue&& Target.IsValidTarget(R.Range - 50))
{
R.Cast(R.GetPrediction(Target).CastPosition);
}
else if (Menu["Flash+R"].Cast <KeyBind>().CurrentValue&& Target.IsValidTarget(R.Range + Flash.Range - 80) && Flash.IsReady())
{
var RPos = GetBestRPos(Target.ServerPosition.To2D());
if (RPos.First().Value > 0)
{
var FlashPos = Player.Position.Extend(RPos.First().Key, Flash.Range).To3D();
Flash.Cast(FlashPos);
Core.DelayAction(() => R.Cast(RPos.First().Key.To3D()), Game.Ping + 20);
}
}
}
//---------------------------------------------------Combo--------------------------------------------
if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo))
{
Modes.Combo();
}
//---------------------------------------------------Mixed--------------------------------------------
if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Harass) && Player.ManaPercent >= Menu["Harass, Mana %"].Cast <Slider>().CurrentValue)
{
Modes.Harass();
}
}
else
{
Target = null;
}
}
//---------------------------------------------------LaneClear--------------------------------------------
if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.LaneClear))
{
Modes.LaneClear();
}
//---------------------------------------------------LastHit--------------------------------------------
if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.LastHit) && Q.IsReady())
{
Modes.LastHit();
}
return;
}
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)Player.BasicAttack.MissileSpeed;
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.CharData.BaseSkinName.ToLower())) &&
(_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);
}
/// <summary>
/// Gets the target.
/// </summary>
/// <returns>AttackableUnit.</returns>
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("LWH").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 + Game.Ping / 2 +
1000 * (int)Math.Max(0, player.Distance(minion) - player.BoundingRadius) / int.MaxValue;
var predHealth = HealthPrediction.GetHealthPrediction(minion, t, FarmDelay);
if (minion.Team != GameObjectTeam.Neutral && (config.Item("AttackPetsnTraps").GetValue <bool>() &&
minion.CharData.BaseSkinName != "jarvanivstandard" || MinionManager.IsMinion(minion, config.Item("AttackWards").GetValue <bool>())))
{
if (predHealth <= 0)
{
FireOnNonKillableMinion(minion);
}
if (predHealth > 0 && predHealth <= player.GetAutoAttackDamage(minion, true))
{
return(minion);
}
}
if (minion.Team == GameObjectTeam.Neutral && (config.Item("AttackBarrel").GetValue <bool>() &&
minion.CharData.BaseSkinName == "gangplankbarrel" && minion.IsHPBarRendered))
{
if (minion.Health < 2)
{
return(minion);
}
}
}
}
//Forced target
if (forcedTarget.IsValidTarget() && InAutoAttackRange(forcedTarget))
{
return(forcedTarget);
}
/* turrets / inhibitors / nexus */
if (ActiveMode == OrbwalkingMode.LaneClear && (!config.Item("FocusMinionsOverTurrets").GetValue <KeyBind>().Active || !MinionManager.GetMinions(ObjectManager.Player.Position, GetRealAutoAttackRange(ObjectManager.Player)).Any()))
{
/* 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 && ActiveMode != OrbwalkingMode.Flee)
{
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 && this.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), 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) &&
(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), FarmDelay)
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);
}
/// <summary>
/// Determines whether the specified object is a minion.
/// </summary>
/// <param name="minion">The minion.</param>
/// <param name="includeWards">if set to <c>true</c> [include wards].</param>
/// <returns><c>true</c> if the specified minion is minion; otherwise, <c>false</c>.</returns>
public static bool IsMinion(Obj_AI_Minion minion, bool includeWards = false)
{
return(minion.Name.Contains("Minion") || includeWards && IsWard(minion));
}
public AttackableUnit GetTarget()
{
AttackableUnit result = null;
var r = float.MaxValue;
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)
{
foreach (var minion in
ObjectManager.Get <Obj_AI_Minion>()
.Where(
minion =>
minion.IsValidTarget() && InAutoAttackRange(minion) &&
minion.Health <
2 *
(ObjectManager.Player.BaseAttackDamage + ObjectManager.Player.FlatPhysicalDamageMod))
)
{
var t = (int)(Player.AttackCastDelay * 1000) - 100 + Game.Ping / 2 +
1000 * (int)Player.Distance(minion) / (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)
{
foreach (var mob in
ObjectManager.Get <Obj_AI_Minion>()
.Where(
mob =>
mob.IsValidTarget() && InAutoAttackRange(mob) && mob.Team == GameObjectTeam.Neutral)
.Where(mob => mob.MaxHealth >= r || Math.Abs(r - float.MaxValue) < float.Epsilon))
{
result = mob;
r = mob.MaxHealth;
}
}
/*Lane Clear minions*/
r = float.MaxValue;
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, false) ||
Math.Abs(predHealth - _prevMinion.Health) < float.Epsilon)
{
return(_prevMinion);
}
}
foreach (var minion in
ObjectManager.Get <Obj_AI_Minion>()
.Where(minion => minion.IsValidTarget() && InAutoAttackRange(minion)))
{
var predHealth = HealthPrediction.LaneClearHealthPrediction(
minion, (int)((Player.AttackDelay * 1000) * LaneClearWaitTimeMod), FarmDelay);
if (predHealth >= 2 * Player.GetAutoAttackDamage(minion) ||
Math.Abs(predHealth - minion.Health) < float.Epsilon)
{
if (minion.Health >= r || Math.Abs(r - float.MaxValue) < float.Epsilon)
{
result = minion;
r = minion.Health;
_prevMinion = minion;
}
}
}
}
}
return(result);
}
public AttackMinions(Obj_AI_Minion minion)
{
Minion = minion;
}
/// <summary>
/// Determines whether the specified minion has turret aggro.
/// </summary>
/// <param name="minion">The minion</param>
/// <returns>
/// The <see cref="bool" />
/// </returns>
public static bool HasTurretAggro(Obj_AI_Minion minion)
{
return(ActiveAttacks.Values.Any(m => m.Source is Obj_AI_Turret && m.Target.Compare(minion)));
}
public static int countMinionsInrange(Obj_AI_Minion l, float p)
{
return(ObjectManager.Get <Obj_AI_Minion>().Count(i => !i.IsDead && i.IsEnemy && l.Distance(i) < p));
}
public virtual AttackableUnit GetTarget()
{
AttackableUnit result = null;
if ((ActiveMode == OrbwalkingMode.Mixed || ActiveMode == OrbwalkingMode.LaneClear) &&
!_config.Item("PriorizeFarm").GetValue <bool>())
{
var target = TargetSelector.GetTarget(-1, DamageType.Physical);
if (target != null)
{
return(target);
}
}
/*Killable Minion*/
if (ActiveMode == OrbwalkingMode.LaneClear || ActiveMode == OrbwalkingMode.Mixed ||
ActiveMode == OrbwalkingMode.LastHit)
{
var minionList =
MinionManager.GetMinions(Player.Position, float.MaxValue)
.Where(
minion =>
InAutoAttackRange(minion) &&
minion.Health <
2 *
(ObjectManager.Player.BaseAttackDamage + ObjectManager.Player.FlatPhysicalDamageMod))
.OrderByDescending(minion => minion.CharData.BaseSkinName.Contains("Siege"))
.ThenBy(minion => minion.CharData.BaseSkinName.Contains("Super"))
.ThenByDescending(minion => minion.MaxHealth)
.ThenBy(minion => minion.Health);
foreach (var minion in minionList)
{
var t = (int)(_player.AttackCastDelay * 1000) - 100 + Game.Ping / 2 +
1000 * (int)_player.Distance(minion) / (int)GetMyProjectileSpeed();
var predHealth = HealthPrediction.GetHealthPrediction(minion, t, FarmDelay);
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
GameObjects.EnemyTurrets.Where(t => t.IsValidTarget() && InAutoAttackRange(t)))
{
return(turret);
}
/* inhibitor */
foreach (var turret in
GameObjects.EnemyInhibitors.Where(t => t.IsValidTarget() && InAutoAttackRange(t)))
{
return(turret);
}
/* nexus */
if (GameObjects.EnemyNexus != null && GameObjects.EnemyNexus.IsValidTarget() &&
InAutoAttackRange(GameObjects.EnemyNexus))
{
return(GameObjects.EnemyNexus);
}
}
/*Champions*/
if (ActiveMode != OrbwalkingMode.LastHit)
{
var target = TargetSelector.GetTarget(-1, DamageType.Physical);
if (target.IsValidTarget())
{
return(target);
}
}
/*Jungle minions*/
if (ActiveMode == OrbwalkingMode.LaneClear || ActiveMode == OrbwalkingMode.Mixed)
{
result =
MinionManager.GetMinions(Player.Position, float.MaxValue, MinionTypes.All, MinionTeam.Neutral)
.Where(InAutoAttackRange)
.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
MinionManager.GetMinions(Player.Position, float.MaxValue).Where(InAutoAttackRange)
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);
}
void Flee()
{
Orbwalker.DisableAttacking = true; // BERB
if (GetBool("Flee.UseQ2", YasuoMenu.MiscM) && !Yasuo.LSIsDashing() && SpellSlot.Q.IsReady() && TornadoReady)
{
var qtarg = TargetSelector.GetTarget(Spells[Q2].Range, DamageType.Physical);
if (qtarg != null)
{
Spells[Q2].Cast(qtarg.ServerPosition);
}
}
if (FleeMode == FleeType.ToCursor)
{
Orbwalker.OrbwalkTo(Game.CursorPos);
var smart = GetBool("Flee.Smart", YasuoMenu.MiscM);
if (Spells[E].IsReady())
{
if (smart)
{
Obj_AI_Base dashTarg;
if (Yasuo.ServerPosition.PointUnderEnemyTurret())
{
var closestturret =
ObjectManager.Get <Obj_AI_Turret>()
.Where(x => x.IsEnemy)
.MinOrDefault(y => y.LSDistance(Yasuo));
var potential =
ObjectManager.Get <Obj_AI_Base>()
.Where(x => x.IsDashable())
.MaxOrDefault(x => GetDashPos(x).LSDistance(closestturret));
var gdpos = GetDashPos(potential);
if (potential != null && gdpos.LSDistance(Game.CursorPos) < Yasuo.LSDistance(Game.CursorPos) && gdpos.LSDistance(closestturret.Position) - closestturret.BoundingRadius > Yasuo.LSDistance(closestturret.Position) - Yasuo.BoundingRadius)
{
Spells[E].Cast(potential);
}
}
dashTarg = ObjectManager.Get <Obj_AI_Base>()
.Where(x => x.IsDashable())
.MinOrDefault(x => GetDashPos(x).LSDistance(Game.CursorPos));
if (dashTarg != null)
{
var posafdash = GetDashPos(dashTarg);
if (posafdash.LSDistance(Game.CursorPos) < Yasuo.LSDistance(Game.CursorPos) &&
!posafdash.PointUnderEnemyTurret())
{
Spells[E].CastOnUnit(dashTarg);
}
}
}
else
{
var dashtarg =
ObjectManager.Get <Obj_AI_Minion>()
.Where(x => x.IsDashable())
.MinOrDefault(x => GetDashPos(x).LSDistance(Game.CursorPos));
if (dashtarg != null)
{
Spells[E].CastOnUnit(dashtarg);
}
}
}
if (GetBool("Flee.StackQ", YasuoMenu.MiscM) && SpellSlot.Q.IsReady() && !TornadoReady && !Yasuo.LSIsDashing())
{
Obj_AI_Minion qtarg = null;
if (!Spells[E].IsReady())
{
qtarg =
ObjectManager.Get <Obj_AI_Minion>()
.Find(x => x.IsValidTarget(Spells[Q].Range) && MinionManager.IsMinion(x));
}
else
{
var etargs =
ObjectManager.Get <Obj_AI_Minion>()
.Where(
x => x.IsValidTarget(Spells[E].Range) && MinionManager.IsMinion(x) && x.IsDashable());
if (!etargs.Any())
{
qtarg =
ObjectManager.Get <Obj_AI_Minion>()
.Find(x => x.IsValidTarget(Spells[Q].Range) && MinionManager.IsMinion(x));
}
}
if (qtarg != null)
{
Spells[Q].Cast(qtarg);
}
}
}
if (FleeMode == FleeType.ToNexus)
{
var nexus = ObjectManager.Get <Obj_Shop>().FirstOrDefault(x => x.IsAlly);
if (nexus != null)
{
Orbwalker.OrbwalkTo(nexus.Position);
var bestminion = ObjectManager.Get <Obj_AI_Base>().Where(x => x.IsDashable()).MinOrDefault(x => GetDashPos(x).LSDistance(nexus.Position));
if (bestminion != null && (!GetBool("Flee.Smart", YasuoMenu.MiscM) || GetDashPos(bestminion).LSDistance(nexus.Position) < Yasuo.LSDistance(nexus.Position)))
{
Spells[E].CastOnUnit(bestminion);
if (GetBool("Flee.StackQ", YasuoMenu.MiscM) && SpellSlot.Q.IsReady() && !TornadoReady)
{
Spells[Q].Cast(bestminion);
}
}
}
}
if (FleeMode == FleeType.ToAllies)
{
Obj_AI_Base bestally = HeroManager.Allies.Where(x => !x.IsMe && x.CountEnemiesInRange(300) == 0).MinOrDefault(x => x.LSDistance(Yasuo));
if (bestally == null)
{
bestally =
ObjectManager.Get <Obj_AI_Minion>()
.Where(x => x.IsValidAlly(3000))
.MinOrDefault(x => x.LSDistance(Yasuo));
}
if (bestally != null)
{
Orbwalker.OrbwalkTo(bestally.ServerPosition);
if (Spells[E].IsReady())
{
var besttarget =
ObjectManager.Get <Obj_AI_Base>()
.Where(x => x.IsDashable())
.MinOrDefault(x => GetDashPos(x).LSDistance(bestally.ServerPosition));
if (besttarget != null)
{
Spells[E].CastOnUnit(besttarget);
if (GetBool("Flee.StackQ", YasuoMenu.MiscM) && SpellSlot.Q.IsReady() && !TornadoReady)
{
Spells[Q].Cast(besttarget);
}
}
}
}
else
{
var nexus = ObjectManager.Get <Obj_Shop>().FirstOrDefault(x => x.IsAlly);
if (nexus != null)
{
Orbwalker.OrbwalkTo(nexus.Position);
var bestminion = ObjectManager.Get <Obj_AI_Base>().Where(x => x.IsDashable()).MinOrDefault(x => GetDashPos(x).LSDistance(nexus.Position));
if (bestminion != null && GetDashPos(bestminion).LSDistance(nexus.Position) < Yasuo.LSDistance(nexus.Position))
{
Spells[E].CastOnUnit(bestminion);
}
}
}
}
}
public Barrel(Obj_AI_Minion objAiBase, int tickCount)
{
barrel = objAiBase;
time = tickCount;
}
