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; }