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"));
}
private static AttackableUnit GetPossibleTarget()
{
AttackableUnit Target = null;
var R = float.MaxValue;
if (Config.Item("OW_Misc_PriorityUnit").GetValue <StringList>().SelectedIndex == 1 && (CurrentMode == Mode.Harass || CurrentMode == Mode.LaneClear))
{
var Obj = GetBestHeroTarget();
if (Obj.IsValidTarget())
{
return(Obj);
}
}
if (CurrentMode == Mode.Harass || CurrentMode == Mode.LaneClear || CurrentMode == Mode.LastHit)
{
foreach (var Obj in ObjectManager.Get <Obj_AI_Minion>().Where(i => i.IsValidTarget() && i.Name != "Beacon" && InAutoAttackRange(i) && i.Team != GameObjectTeam.Neutral))
{
var Time = (int)(Player.AttackCastDelay * 1000) - 100 + Game.Ping / 2 + 1000 * (int)(Player.Distance(Obj.ServerPosition) / Orbwalking.GetMyProjectileSpeed());
var predHp = HealthPrediction.GetHealthPrediction(Obj, Time, GetCurrentFarmDelay());
if (predHp <= 0)
{
FireOnNonKillableMinion(Obj);
}
if (predHp > 0 && predHp <= Player.GetAutoAttackDamage(Obj, true))
{
return(Obj);
}
}
}
if (ForcedTarget.IsValidTarget() && InAutoAttackRange(ForcedTarget))
{
return(ForcedTarget);
}
if (CurrentMode == Mode.LaneClear)
{
foreach (var Obj in ObjectManager.Get <Obj_AI_Turret>().Where(i => i.IsValidTarget() && InAutoAttackRange(i)))
{
return(Obj);
}
foreach (var Obj in ObjectManager.Get <Obj_BarracksDampener>().Where(i => i.IsValidTarget() && InAutoAttackRange(i)))
{
return(Obj);
}
foreach (var Obj in ObjectManager.Get <Obj_HQ>().Where(i => i.IsValidTarget() && InAutoAttackRange(i)))
{
return(Obj);
}
}
if (CurrentMode != Mode.LastHit)
{
var Obj = GetBestHeroTarget();
if (Obj.IsValidTarget())
{
return(Obj);
}
}
if (CurrentMode == Mode.Harass || CurrentMode == Mode.LaneClear)
{
foreach (var Obj in ObjectManager.Get <Obj_AI_Minion>().Where(i => i.IsValidTarget() && i.Name != "Beacon" && InAutoAttackRange(i) && i.Team == GameObjectTeam.Neutral && (i.MaxHealth >= R || Math.Abs(R - float.MaxValue) < float.Epsilon)))
{
Target = Obj;
R = Obj.MaxHealth;
}
}
if (CurrentMode == Mode.LaneClear && !ShouldWait())
{
if (PrevMinion.IsValidTarget() && InAutoAttackRange(PrevMinion))
{
var predHp = HealthPrediction.LaneClearHealthPrediction(PrevMinion, (int)(Player.AttackDelay * 1000 * ClearWaitTimeMod), GetCurrentFarmDelay());
if (predHp >= 2 * Player.GetAutoAttackDamage(PrevMinion, true) || Math.Abs(predHp - PrevMinion.Health) < float.Epsilon)
{
return(PrevMinion);
}
}
foreach (var Obj in ObjectManager.Get <Obj_AI_Minion>().Where(i => i.IsValidTarget() && i.Name != "Beacon" && InAutoAttackRange(i)))
{
var predHp = HealthPrediction.LaneClearHealthPrediction(Obj, (int)(Player.AttackDelay * 1000 * ClearWaitTimeMod), GetCurrentFarmDelay());
if ((predHp >= 2 * Player.GetAutoAttackDamage(Obj, true) || Math.Abs(predHp - Obj.Health) < float.Epsilon) && (Obj.Health >= R || Math.Abs(R - float.MaxValue) < float.Epsilon))
{
Target = Obj;
R = Obj.MaxHealth;
PrevMinion = Obj;
}
}
}
return(Target);
}
public Obj_AI_Base GetTarget()
{
Obj_AI_Base result = null;
float[] r = { float.MaxValue };
if ((ActiveMode == OrbwalkingMode.Mixed || ActiveMode == OrbwalkingMode.LaneClear) && !_config.Item("PriorizeFarm").GetValue <bool>())
{
var target = SimpleTs.GetTarget(-1, SimpleTs.DamageType.Physical) ?? GetSoldierTargetHero();
if (target != null)
{
return(target);
}
}
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) || InSoldierAttackRange(minion))))
{
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 && predHealth > 0 &&
predHealth <=
DamageLib.CalcPhysicalMinionDmg(
_player.BaseAttackDamage + _player.FlatPhysicalDamageMod, minion, true) - 1 +
Math.Max(0, GetAutoAttackPassiveDamage(minion) - 10))
{
return(minion);
}
}
}
//Forced target
if (_forcedTarget != null && _forcedTarget.IsValidTarget() &&
(InAutoAttackRange(_forcedTarget) || InSoldierAttackRange(_forcedTarget)))
{
return(_forcedTarget);
}
/*Champions*/
if (ActiveMode != OrbwalkingMode.LastHit)
{
var target = SimpleTs.GetTarget(-1, SimpleTs.DamageType.Physical) ?? GetSoldierTargetHero();
if (target != null)
{
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) || InSoldierAttackRange(mob)) && mob.Team == GameObjectTeam.Neutral)
.Where(mob => mob.MaxHealth >= r[0] || Math.Abs(r[0] - float.MaxValue) < float.Epsilon))
{
result = mob;
r[0] = mob.MaxHealth;
}
}
if (result != null)
{
return(result);
}
/*Lane Clear minions*/
r[0] = float.MaxValue;
if (ActiveMode == OrbwalkingMode.LaneClear)
{
if (!ShouldWait())
{
if (_prevMinion != null && _prevMinion.IsValidTarget() && (InAutoAttackRange(_prevMinion) || InSoldierAttackRange(_prevMinion)))
{
var predHealth = HealthPrediction.LaneClearHealthPrediction(
_prevMinion, (int)((_player.AttackDelay * 1000) * LaneClearWaitTimeMod), FarmDelay);
if (predHealth >=
2 *
DamageLib.CalcPhysicalMinionDmg(
_player.BaseAttackDamage + _player.FlatPhysicalDamageMod, _prevMinion, true) - 1 +
Math.Max(0, GetAutoAttackPassiveDamage(_prevMinion) - 10) ||
Math.Abs(predHealth - _prevMinion.Health) < float.Epsilon)
{
return(_prevMinion);
}
}
foreach (var minion in from minion in ObjectManager.Get <Obj_AI_Minion>()
.Where(minion => minion.IsValidTarget() && (InAutoAttackRange(minion) || InSoldierAttackRange(minion)))
let predHealth = HealthPrediction.LaneClearHealthPrediction(
minion, (int)((_player.AttackDelay * 1000) * LaneClearWaitTimeMod), FarmDelay)
where predHealth >=
2 *
DamageLib.CalcPhysicalMinionDmg(
_player.BaseAttackDamage + _player.FlatPhysicalDamageMod, minion, true) - 1 +
Math.Max(0, GetAutoAttackPassiveDamage(minion) - 10) ||
Math.Abs(predHealth - minion.Health) < float.Epsilon
where minion.Health >= r[0] || Math.Abs(r[0] - float.MaxValue) < float.Epsilon
select minion)
{
result = minion;
r[0] = minion.Health;
_prevMinion = minion;
}
}
}
/*turrets*/
if (ActiveMode != OrbwalkingMode.LaneClear)
{
return(result);
}
foreach (var turret in
ObjectManager.Get <Obj_AI_Turret>().Where(t => t.IsValidTarget() && InAutoAttackRange(t)))
{
return(turret);
}
return(result);
}
/// <summary>
/// Process Karma Last Hit
/// </summary>
public static void ProcessLastHit()
{
// Minion list
var minions = ObjectManager.Get <Obj_AI_Minion>().FindAll(m => m.IsValidTarget(Instances.Range));
minions.RemoveAll(m => m.Distance(Instances.Player.ServerPosition) < Instances.Player.AttackRange);
if (minions.Count == 0)
{
// If no minions, ignore.
return;
}
// player local value
var player = Instances.Player;
// Using menu & spells a lot, copy to local value.
var menu = Instances.Menu;
var spells = Instances.Spells;
var manaPercent = player.ManaPercentage();
#region Last Hit - Q
// If Q is ready and we enabled it inside the menu
if (spells[SpellSlot.Q].IsReady() && menu.Item("l33t.karma.farming.lhq").GetValue <bool>() &&
manaPercent >= menu.Item("l33t.karma.farming.lhminmpq").GetValue <Slider>().Value)
{
// Main minion
Obj_AI_Minion minion = null;
// Search for best minion
foreach (var m in
from m in minions
let pred = spells[SpellSlot.Q].GetPrediction(m)
where pred.CollisionObjects.Count == 0
select m)
{
if (minion == null &&
Damages.GetDamage(m, SpellSlot.Q, false) >
HealthPrediction.GetHealthPrediction(m, (int)((player.AttackDelay * 1000) * 2)) &&
HealthPrediction.GetHealthPrediction(m, (int)((player.AttackDelay * 1000) * 2)) >
player.GetAutoAttackDamage(m))
{
minion = m;
}
else if ((minion != null) && minion.Health > m.Health)
{
minion = m;
}
}
// Check if minion is valid for range.
if (minion != null && (minion.IsValidTarget(spells[SpellSlot.Q].Range)) &&
player.Distance(minion.ServerPosition) > player.AttackRange)
{
// Cast Q onto minion with prediction.
var pred = spells[SpellSlot.Q].GetPrediction(minion);
spells[SpellSlot.Q].Cast(pred.CastPosition);
}
}
#endregion
}
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 ||
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)GetMyProjectileSpeed();
var predHealth = HealthPrediction.GetHealthPrediction(minion, t, FarmDelay);
if (minion.Team != GameObjectTeam.Neutral && (_config.Item("AttackPetsnTraps").GetValue <bool>() && minion.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);
}
}
}
}
//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), 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.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), 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);
}
public Obj_AI_Base GetTarget()
{
Obj_AI_Base result = null;
var r = float.MaxValue;
if ((ActiveMode == OrbwalkingMode.Mixed || ActiveMode == OrbwalkingMode.LaneClear) &&
!_config.Item("PriorizeFarm").GetValue <bool>())
{
var target = SimpleTs.GetTarget(-1, SimpleTs.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))
{
if (predHealth <= 0)
{
FireOnNonKillableMinion(minion);
}
if (predHealth > 0 && predHealth <= Player.GetAutoAttackDamage(minion, true))
{
return(minion);
}
}
}
}
//Forced target
if (_forcedTarget != null && _forcedTarget.IsValidTarget() && InAutoAttackRange(_forcedTarget))
{
return(_forcedTarget);
}
/*Champions*/
if (ActiveMode != OrbwalkingMode.LastHit)
{
var target = SimpleTs.GetTarget(-1, SimpleTs.DamageType.Physical);
if (target != null)
{
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;
}
}
if (result != null)
{
return(result);
}
/*Lane Clear minions*/
r = float.MaxValue;
if (ActiveMode == OrbwalkingMode.LaneClear)
{
if (!ShouldWait())
{
if (_prevMinion != null && _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, false) ||
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;
}
}
}
}
}
/*turrets*/
if (ActiveMode == OrbwalkingMode.LaneClear)
{
foreach (var turret in
ObjectManager.Get <Obj_AI_Turret>().Where(t => t.IsValidTarget() && InAutoAttackRange(t)))
{
return(turret);
}
}
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["PriorizeFarm"].Cast <CheckBox>().CurrentValue)
{
var target = TargetSelector.GetTarget(-1, DamageType.Physical);
if (target != null && InAutoAttackRange(target))
{
return(target);
}
}
/*Killable Minion*/
if (ActiveMode == OrbwalkingMode.LaneClear || (ActiveMode == OrbwalkingMode.Mixed && _config["LWH"].Cast <CheckBox>().CurrentValue) ||
ActiveMode == OrbwalkingMode.LastHit)
{
var MinionList =
EntityManager.MinionsAndMonsters.Minions
.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 = Prediction.Health.GetPrediction(minion, t + FarmDelay);
if (minion.Team != GameObjectTeam.Neutral && (_config["AttackPetsnTraps"].Cast <CheckBox>().CurrentValue&&
minion.CharData.BaseSkinName != "jarvanivstandard" || minion.IsMinion || minion.IsWard() && _config["AttackWards"].Cast <CheckBox>().CurrentValue))
{
if (predHealth <= 0)
{
FireOnNonKillableMinion(minion);
}
if (predHealth > 0 && predHealth <= _Player.GetAutoAttackDamage(minion, true))
{
return(minion);
}
}
if (minion.Team == GameObjectTeam.Neutral && (_config["AttackBarrel"].Cast <CheckBox>().CurrentValue&&
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["FocusMinionsOverTurrets"].Cast <KeyBind>().CurrentValue || !EntityManager.MinionsAndMonsters.Minions.Any(m => Player.Instance.IsInAutoAttackRange(m))))
{
/* 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, DamageType.Physical);
if (target.IsValidTarget() && InAutoAttackRange(target))
{
return(target);
}
}
/*Jungle minions*/
if (ActiveMode == OrbwalkingMode.LaneClear || ActiveMode == OrbwalkingMode.Mixed)
{
var jminions =
EntityManager.MinionsAndMonsters.Monsters
.Where(
mob =>
mob.IsValidTarget() && mob.Team == GameObjectTeam.Neutral && this.InAutoAttackRange(mob) &&
mob.CharData.BaseSkinName != "gangplankbarrel");
var m = jminions.FirstOrDefault();
if (m != null)
{
return(m);
}
}
/*Lane Clear minions*/
if (ActiveMode == OrbwalkingMode.LaneClear)
{
if (!ShouldWait())
{
if (_prevMinion.IsValidTarget() && InAutoAttackRange(_prevMinion))
{
var predHealth = Prediction.Health.GetPrediction(
_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
EntityManager.MinionsAndMonsters.Minions
.Where(minion => minion.IsValidTarget() && InAutoAttackRange(minion) &&
(_config["AttackWards"].Cast <CheckBox>().CurrentValue ||
!minion.IsWard() &&
(_config["AttackPetsnTraps"].Cast <CheckBox>().CurrentValue&&
minion.CharData.BaseSkinName != "jarvanivstandard" || minion.IsMinion ||
minion.IsWard() &&
_config["AttackWards"].Cast <CheckBox>().CurrentValue)) &&
minion.CharData.BaseSkinName != "gangplankbarrel")
let predHealth =
Prediction.Health.GetPrediction(
minion, (int)((_Player.AttackDelay * 1000) * LaneClearWaitTimeMod) + FarmDelay)
where
predHealth >= 2 * _Player.GetAutoAttackDamage(minion) ||
Math.Abs(predHealth - minion.Health) < float.Epsilon
select minion).FirstOrDefault();
if (result != null)
{
_prevMinion = (Obj_AI_Minion)result;
}
}
}
return(result);
}
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);
}
public static bool IsDragon(this Obj_AI_Minion minion)
{
return(minion.IsValidTarget() && (minion.Name.ToLower().Contains("baron") || minion.Name.ToLower().Contains("dragon")));
}
private void JungleSmite()
{
try
{
if (!getKeyBindItem("ElSmite.Activated"))
{
return;
}
Minion = (Obj_AI_Minion) EntityManager.MinionsAndMonsters.Monsters.FirstOrDefault(buff => this.Player.IsInRange(buff, 570) && (buff.Name.StartsWith(buff.BaseSkinName) || BuffsThatActuallyMakeSenseToSmite.Contains(buff.BaseSkinName)) && !buff.Name.Contains("Mini") && !buff.Name.Contains("Spawn"));
if (Minion == null)
{
return;
}
if (getCheckBoxItem(Minion.CharData.BaseSkinName))
{
if (this.SmiteSpell.IsReady())
{
if (Minion.IsValidTarget(570f))
{
if (this.Player.GetSummonerSpellDamage(Minion, LeagueSharp.Common.Damage.SummonerSpell.Smite) >= Minion.Health && this.SmiteSpell.CanCast(Minion))
{
this.SmiteSpell.Cast(Minion);
}
}
if (getCheckBoxItem("Smite.Spell"))
{
this.ChampionSpellSmite((float)this.Player.GetSummonerSpellDamage(Minion, LeagueSharp.Common.Damage.SummonerSpell.Smite), Minion);
}
}
}
}
catch (Exception e)
{
Console.WriteLine("An error occurred: '{0}'", e);
}
}
public static AttackableUnit GetTarget()
{
AttackableUnit result = null;
if (Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.None)
{
return(null);
}
/*Killable Minion*/
if (Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LaneClear || Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Mixed ||
Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LastHit)
{
foreach (var minion in
ObjectManager.Get <Obj_AI_Minion>()
.Where(
minion =>
minion.IsValidTarget() && Orbwalker.InAutoAttackRange(minion) &&
minion.Health <
2 *
(RealAutoAttack(minion)))
)
{
var t = (int)(Player.AttackCastDelay * 1000) - 100 + Game.Ping / 2 +
1000 * (int)Player.Distance(minion) / (int)Orbwalking.GetMyProjectileSpeed();
var predHealth = HealthPrediction.GetHealthPrediction(minion, t, Program.Config.Item("FarmDelay").GetValue <Slider>().Value);
if (minion.Team != GameObjectTeam.Neutral && MinionManager.IsMinion(minion, true))
{
if (predHealth > 0 && predHealth <= RealAutoAttack(minion))
{
return(minion);
}
}
}
}
/* turrets / inhibitors / nexus */
if (Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LaneClear)
{
/* turrets */
foreach (var turret in
ObjectManager.Get <Obj_AI_Turret>().Where(t => t.IsValidTarget() && Orbwalker.InAutoAttackRange(t)))
{
return(turret);
}
/* inhibitor */
foreach (var turret in
ObjectManager.Get <Obj_BarracksDampener>().Where(t => t.IsValidTarget() && Orbwalker.InAutoAttackRange(t)))
{
return(turret);
}
/* nexus */
foreach (var nexus in
ObjectManager.Get <Obj_HQ>().Where(t => t.IsValidTarget() && Orbwalker.InAutoAttackRange(t)))
{
return(nexus);
}
}
/*Champions*/
if (Orbwalker.ActiveMode != Orbwalking.OrbwalkingMode.LastHit)
{
var target = TargetSelector.GetTarget(-1, TargetSelector.DamageType.Physical);
if (target.IsValidTarget())
{
return(target);
}
}
/*Jungle minions*/
if (Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LaneClear || Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Mixed)
{
result =
ObjectManager.Get <Obj_AI_Minion>()
.Where(
mob =>
mob.IsValidTarget() && Orbwalker.InAutoAttackRange(mob) && mob.Team == GameObjectTeam.Neutral)
.MaxOrDefault(mob => mob.MaxHealth);
if (result != null)
{
return(result);
}
}
/*Lane Clear minions*/
if (Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LaneClear)
{
if (!ShouldWait())
{
if (_prevMinion.IsValidTarget() && Orbwalker.InAutoAttackRange(_prevMinion))
{
var predHealth = HealthPrediction.LaneClearHealthPrediction(
_prevMinion, (int)((Player.AttackDelay * 1000) * 2f), Program.Config.Item("FarmDelay").GetValue <Slider>().Value);
if (predHealth >= 2 * RealAutoAttack(_prevMinion) ||
Math.Abs(predHealth - _prevMinion.Health) < float.Epsilon)
{
return(_prevMinion);
}
}
result = (from minion in
ObjectManager.Get <Obj_AI_Minion>()
.Where(minion => minion.IsValidTarget() && Orbwalker.InAutoAttackRange(minion))
let predHealth =
HealthPrediction.LaneClearHealthPrediction(
minion, (int)((Player.AttackDelay * 1000) * 2f), Program.Config.Item("FarmDelay").GetValue <Slider>().Value)
where
predHealth >= 2 * RealAutoAttack(minion) ||
Math.Abs(predHealth - minion.Health) < float.Epsilon
select minion).MaxOrDefault(m => m.Health);
if (result != null)
{
_prevMinion = (Obj_AI_Minion)result;
}
}
}
return(null);
}
private static bool IsInRangeQ(Obj_AI_Minion minion)
{
return(minion.IsValidTarget(Math.Max(475 + minion.BoundingRadius / 3 - 4, 475)));
}
public override void UseE(Obj_AI_Minion minion)
{
if (E.IsReady() && minion.IsValidTarget(E.Range))
{
foreach (var buff in minion.Buffs.Where(buff => buff.DisplayName.ToLower() == "twitchdeadlyvenom").Where(buff => buff.Count == 6))
{
E.Cast();
}
}
}
public virtual AttackableUnit GetTarget()
{
AttackableUnit result = null;
if ((ActiveMode == OrbwalkingMode.Mixed || ActiveMode == OrbwalkingMode.LaneClear) &&
!_config.Item("PriorizeFarm").GetValue <bool>())
{
var target = TargetSelector.GetTarget(-1);
if (target != null)
{
return(target);
}
}
/*Killable Minion*/
if (ActiveMode == OrbwalkingMode.LaneClear || ActiveMode == OrbwalkingMode.Mixed ||
ActiveMode == OrbwalkingMode.LastHit)
{
var FreezeActive = _config.Item("Freeze").GetValue <KeyBind>().Active&& (ActiveMode != OrbwalkingMode.LaneClear);
var MinionList =
ObjectManager.Get <Obj_AI_Minion>()
.Where(
minion =>
minion.IsValidTarget() && InAutoAttackRange(minion) &&
minion.Health <
2 *
(ObjectManager.Player.BaseAttackDamage + ObjectManager.Player.FlatPhysicalDamageMod));
foreach (var minion in MinionList)
{
var FreezeDamage = Player.GetAutoAttackDamage(minion, false) * (_config.Item("FreezeHealth").GetValue <Slider>().Value / 100f);
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 (FreezeActive && predHealth.Equals(minion.Health))
{
continue;
}
if (minion.Team != GameObjectTeam.Neutral && MinionManager.IsMinion(minion, true))
{
if (predHealth <= 0)
{
FireOnNonKillableMinion(minion);
}
if (predHealth > 0 && predHealth <= (FreezeActive ? FreezeDamage : 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);
if (target.IsValidTarget())
{
if (target.IsMelee && Items.HasItem((int)ItemId.Thornmail, target) && target.HealthPercent > Player.HealthPercent && Player.HealthPercent < 20)
{
return
(MinionManager.GetMinions(Player.ServerPosition, Orbwalking.GetRealAutoAttackRange(null))
.OrderBy(m => m.Armor)
.FirstOrDefault() ?? target);
}
else
{
return(target);
}
}
}
if (ActiveMode == OrbwalkingMode.Combo && Items.HasItem((int)ItemId.The_Bloodthirster, Player))
{
var minion =
MinionManager.GetMinions(Player.ServerPosition, GetRealAutoAttackRange(null))
.OrderBy(m => m.Armor).FirstOrDefault();
if (Player.CountEnemiesInRange(600) == 0 && Player.HealthPercent < 60 && minion != null)
{
return(minion);
}
}
/*Jungle minions*/
if (ActiveMode == OrbwalkingMode.LaneClear || ActiveMode == OrbwalkingMode.Mixed)
{
result =
ObjectManager.Get <Obj_AI_Minion>()
.Where(
mob =>
mob.IsValidTarget() && mob.Team == GameObjectTeam.Neutral && InAutoAttackRange(mob) && mob.CharData.BaseSkinName != "gangplankbarrel")
.MaxOrDefault(mob => mob.MaxHealth);
if (result != null)
{
return(result);
}
}
/*Lane Clear minions*/
if (ActiveMode == OrbwalkingMode.LaneClear)
{
if (!ShouldWait())
{
if (_prevMinion.IsValidTarget() && InAutoAttackRange(_prevMinion))
{
var predHealth = HealthPrediction.LaneClearHealthPrediction(
_prevMinion, (int)((Player.AttackDelay * 1000) * LaneClearWaitTimeMod), FarmDelay);
if (predHealth >= 2 * Player.GetAutoAttackDamage(_prevMinion) ||
Math.Abs(predHealth - _prevMinion.Health) < float.Epsilon)
{
return(_prevMinion);
}
}
result = (from minion in
ObjectManager.Get <Obj_AI_Minion>()
.Where(minion => minion.IsValidTarget() && InAutoAttackRange(minion) && minion.CharData.BaseSkinName != "gangplankbarrel")
let predHealth =
HealthPrediction.LaneClearHealthPrediction(
minion, (int)((Player.AttackDelay * 1000) * LaneClearWaitTimeMod), FarmDelay)
where
predHealth >= 2 * Player.GetAutoAttackDamage(minion) ||
Math.Abs(predHealth - minion.Health) < float.Epsilon
select minion).MaxOrDefault(m => m.Health);
if (result != null)
{
_prevMinion = (Obj_AI_Minion)result;
}
}
}
return(result);
}
public static void DoSmite()
{
var smiteSlot = ObjectManager.Player.Spellbook.Spells.FirstOrDefault(x => x.SpellData.Name.ToLower().Contains("smite"));
if (smiteSlot == null)
{
return;
}
if (smiteSlot != null)
{
SmiteSpell = new Spell(smiteSlot.Slot, 570f, TargetSelector.DamageType.True);
}
mobs = MinionManager.GetMinions(ObjectManager.Player.ServerPosition, 570f, MinionTypes.All, MinionTeam.Neutral).FirstOrDefault(buff => buff.Name.StartsWith(buff.CharData.BaseSkinName) &&
SmiteMobs.Contains(buff.CharData.BaseSkinName) && !buff.Name.Contains("Mini") && !buff.Name.Contains("Spawn"));
if (mobs != null)
{
if (ssMenu.Get <MenuCheckbox>(mobs.CharData.BaseSkinName).Checked)
{
if (SmiteSpell.IsReady())
{
if (Vector3.Distance(ObjectManager.Player.ServerPosition, mobs.ServerPosition) <= 570 && mobs.IsValidTarget(SmiteSpell.Range))
{
if (ObjectManager.Player.GetSummonerSpellDamage(mobs, Damage.SummonerSpell.Smite) >=
mobs.Health && SmiteSpell.CanCast(mobs))
{
ObjectManager.Player.Spellbook.CastSpell(SmiteSpell.Slot, mobs);
Logger.Log("Smited!");
}
}
}
}
}
else if (ssMenu.Get <MenuCheckbox>("SRU_Dragon").Checked)
{
if (SmiteSpell.IsReady())
{
if (ObjectManager.Dragon != null && ObjectManager.Dragon.IsInRange(ObjectManager.Player, 570))
{
if (ObjectManager.Player.GetSummonerSpellDamage(ObjectManager.Dragon,
Damage.SummonerSpell.Smite) >= ObjectManager.Dragon.Health &&
SmiteSpell.CanCast(ObjectManager.Dragon))
{
ObjectManager.Player.Spellbook.CastSpell(SmiteSpell.Slot, ObjectManager.Dragon);
}
}
}
}
else
{
SmiteKill();
}
}
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)
{
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)
{
result =
ObjectManager.Get <Obj_AI_Minion>()
.Where(
mob =>
mob.IsValidTarget() && InAutoAttackRange(mob) && mob.Team == GameObjectTeam.Neutral)
.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))
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);
}
private void OnDrawingDraw(EventArgs args)
{
try
{
if (!Menu.Item(Name + "Hotkey").GetValue <KeyBind>().Active || ObjectManager.Player.IsDead)
{
return;
}
var minion = _currentMinion != null && _currentMinion.IsValidTarget();
if (_smiteSpell != null && Menu.Item(Name + "SpellSmiteDrawingRange").GetValue <bool>())
{
Render.Circle.DrawCircle(
ObjectManager.Player.Position, SmiteRange,
minion && _smiteSpell.IsReady() && _smiteSpell.CanCast(_currentMinion)
? Menu.Item(Name + "SpellSmiteDrawingUseableColor").GetValue <Color>()
: Menu.Item(Name + "SpellSmiteDrawingUnusableColor").GetValue <Color>(),
Menu.Item(Name + "SpellSmiteDrawingThickness").GetValue <Slider>().Value);
}
if (Menu.Item(Name + "Spell" + ObjectManager.Player.ChampionName + "Enabled").GetValue <bool>())
{
foreach (var spell in _heroSpells.Where(s => s.Enabled && s.Drawing))
{
Render.Circle.DrawCircle(
ObjectManager.Player.Position, spell.Range,
spell.CanCast(_currentMinion) ? spell.UseableColor : spell.UnusableColor, spell.Thickness);
}
}
if (minion && _currentMinion.IsVisible && Menu.Item(Name + "DrawingDamageIndicator").GetValue <bool>())
{
var damage = 0d;
if (Menu.Item(Name + "Spell" + ObjectManager.Player.ChampionName + "Enabled").GetValue <bool>())
{
var heroSpell = _heroSpells.Where(s => s.Enabled).OrderByDescending(s => s.Priority).ToList();
if (heroSpell.Any())
{
HeroSpell spell = null;
if (heroSpell.Count == 1)
{
spell = heroSpell.First();
}
else if (heroSpell.Count > 1)
{
spell = heroSpell.FirstOrDefault(s => s.Spell.IsReady()) ??
heroSpell.OrderBy(h => h.Spell.Instance.CooldownExpires).First();
}
if (spell != null && spell.Spell.Instance.CooldownExpires - Game.Time < 3f)
{
damage += spell.CalculateDamage(_currentMinion, false);
}
}
}
if (_smiteSpell != null && Menu.Item(Name + "SpellSmiteUse").GetValue <bool>())
{
if (_smiteSpell.Instance.CooldownExpires - Game.Time < 3f)
{
damage += ObjectManager.Player.GetSummonerSpellDamage(
_currentMinion, Damage.SummonerSpell.Smite);
}
}
if (damage > 0)
{
var pos = Drawing.WorldToScreen(_currentMinion.Position);
Drawing.DrawText(
pos.X, pos.Y + _currentMinion.BoundingRadius / 2f,
Menu.Item(Name + "DrawingDamageColor").GetValue <Color>(),
((int)(_currentMinion.Health - damage)).ToString());
}
}
}
catch (Exception ex)
{
//Global.Logger.AddItem(new LogItem(ex));
}
}
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(m => m.MaxHealth);
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);
}
private static bool IsInRangeQ(Obj_AI_Minion minion)
{
return minion.IsValidTarget(Math.Min(465 + minion.BoundingRadius / 3, 480));
}
private Vector3 GetJungleSafeTumblePos(Obj_AI_Minion target)
{
var cursorPos = Game.CursorPos;
if (IsSafeTumblePos(cursorPos)) return cursorPos;
if (!target.IsValidTarget()) return Vector3.Zero;
var targetPosition = target.ServerPosition;
var myTumbleRangeCircle =
new Geometry.Circle(ObjectManager.Player.ServerPosition.To2D(), 300).ToPolygon().ToClipperPath();
var goodCandidates = from p in myTumbleRangeCircle
select new Vector2(p.X, p.Y).To3D() into v3
let dist = v3.Distance(targetPosition)
where dist > menu.Item("QMinDist", true).GetValue<Slider>().Value && dist < 500
select v3;
return goodCandidates.OrderByDescending(candidate => candidate.Distance(cursorPos)).FirstOrDefault();
}
public static void Execute()
{
if (Menu.GetSliderValue("Mana") <= Util.MyHero.ManaPercent)
{
var target = TargetSelector.Target;
if (target.IsValidTarget())
{
SpellManager.CastQ(target, Menu.GetSliderValue("Q"));
var minion = EntityManager.MinionsAndMonsters.Get(EntityManager.MinionsAndMonsters.EntityType.Minion, EntityManager.UnitTeam.Enemy, Util.MyHero.Position, SpellManager.Q.Range, true).FirstOrDefault();
if (minion != null && minion.IsValidTarget())
{
SpellManager.CastQ(minion, Menu.GetSliderValue("Q"));
}
if (Menu.GetCheckBoxValue("E"))
{
SpellManager.CastE(target);
}
if (Menu.GetCheckBoxValue("W"))
{
SpellManager.CastW(target);
}
if (Menu.GetCheckBoxValue("AA"))
{
if (Util.MyHero.HasBuff("dravenspinningattack"))
{
var buff = Util.MyHero.GetBuff("dravenspinningattack");
if (Orbwalker.CanAutoAttack)
{
if (buff.EndTime - Game.Time <= 1.25f + Util.MyHero.AttackCastDelay)
{
Obj_AI_Base BestTarget = null;
AIHeroClient target2 = TargetSelector.Target;
if (target2 != null && target2.IsValidTarget())
{
BestTarget = target2;
}
else
{
Obj_AI_Minion BestMinion = EntityManager.MinionsAndMonsters.EnemyMinions.Where(m => m.IsValidTarget() && Util.MyHero.IsInAutoAttackRange(m) && (Prediction.Health.GetPrediction(m, 2 * 1000 * (int)(Util.MyHero.AttackDelay + Util.MyHero.AttackCastDelay + Extensions.Distance(Util.MyHero, m) / Util.MyHero.BasicAttack.MissileSpeed - 0.07f)) > 2 * Util.MyHero.GetAutoAttackDamage(m) || Prediction.Health.GetPrediction(m, 1000 * (int)(Util.MyHero.AttackCastDelay + Extensions.Distance(Util.MyHero, m) / Util.MyHero.BasicAttack.MissileSpeed - 0.07f)) == m.Health)).OrderBy(m => m.HealthPercent).LastOrDefault();
if (BestMinion != null && BestMinion.IsValidTarget())
{
BestTarget = BestMinion;
}
else
{
BestMinion = EntityManager.MinionsAndMonsters.EnemyMinions.Where(m => m.IsValidTarget() && Util.MyHero.IsInAutoAttackRange(m)).OrderBy(m => m.HealthPercent).LastOrDefault();
if (BestMinion != null && BestMinion.IsValidTarget())
{
BestTarget = BestMinion;
}
}
}
Orbwalker.ForcedTarget = BestTarget;
}
else
{
Orbwalker.ForcedTarget = null;
}
}
}
}
}
}
}
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 && _config.Item("Harass.MLH").GetValue <bool>() || //미니언 킬 하레스..!!
ActiveMode == OrbwalkingMode.LastHit)
{
var FreezeActive = _config.Item("Freeze").GetValue <KeyBind>().Active&& (ActiveMode != OrbwalkingMode.LaneClear);
var MinionList =
ObjectManager.Get <Obj_AI_Minion>()
.Where(
minion =>
minion.IsValidTarget() && InAutoAttackRange(minion) &&
minion.Health <
Player.GetAutoAttackDamage2(minion, true) * 2); //좀 병신같았던 Farm 수정. 이전엔 패시브 고려안해서 패시브 데미지 때문에 미니언 버리는 경우도 많았음.
foreach (var minion in MinionList)
{
var FreezeDamage = Player.GetAutoAttackDamage2(minion, true) * (_config.Item("FreezeHealth").GetValue <Slider>().Value / 100f);
var t = (int)(Player.AttackCastDelay * 1000) - 100 + Game.Ping / 2 +
1000 * (int)Player.Distance(minion, false) / (int)GetMyProjectileSpeed();
var predHealth = HealthPrediction.GetHealthPrediction(minion, t, FarmDelay);
if (FreezeActive && predHealth.Equals(minion.Health))
{
continue;
}
if (minion.Team != GameObjectTeam.Neutral && MinionManager.IsMinion(minion, true))
{
if (predHealth <= 0)
{
FireOnNonKillableMinion(minion);
}
if (predHealth > 0 && predHealth <= (FreezeActive ? FreezeDamage : Player.GetAutoAttackDamage2(minion, true)))
{
return(minion);
}
}
}
}
//Forced target
if (_forcedTarget.IsValidTarget() && InAutoAttackRange(_forcedTarget))
{
return(_forcedTarget);
}
/* turrets / inhibitors / nexus */
if (ActiveMode == OrbwalkingMode.LaneClear)
{
/* turrets */
foreach (var turret in
ObjectManager.Get <Obj_AI_Turret>().Where(t => t.IsValidTarget() && InAutoAttackRange(t)))
{
return(turret);
}
/* inhibitor */
foreach (var turret in
ObjectManager.Get <Obj_BarracksDampener>().Where(t => t.IsValidTarget() && InAutoAttackRange(t)))
{
return(turret);
}
/* nexus */
foreach (var nexus in
ObjectManager.Get <Obj_HQ>().Where(t => t.IsValidTarget() && InAutoAttackRange(t)))
{
return(nexus);
}
}
/*Champions*/
if (ActiveMode != OrbwalkingMode.LastHit)
{
var target = TargetSelector.GetTarget(-1, TargetSelector.DamageType.Physical);
if (target.IsValidTarget())
{
return(target);
}
}
/*Jungle minions*/
if (ActiveMode == OrbwalkingMode.LaneClear || ActiveMode == OrbwalkingMode.Mixed)
{
result =
ObjectManager.Get <Obj_AI_Minion>()
.Where(
mob =>
mob.IsValidTarget() && InAutoAttackRange(mob) && mob.Team == GameObjectTeam.Neutral)
.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.GetAutoAttackDamage2(_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))
let predHealth =
HealthPrediction.LaneClearHealthPrediction(
minion, (int)((Player.AttackDelay * 1000) * LaneClearWaitTimeMod), FarmDelay)
where
predHealth >= 2 * Player.GetAutoAttackDamage2(minion) ||
Math.Abs(predHealth - minion.Health) < float.Epsilon
select minion).MaxOrDefault(m => m.Health);
if (result != null)
{
_prevMinion = (Obj_AI_Minion)result;
}
}
}
return(result);
}
private static bool IsInRangeQ(Obj_AI_Minion minion)
{
return(minion.IsValidTarget(Math.Min(465 + minion.BoundingRadius / 3, 480)));
}
public virtual AttackableUnit GetTarget()
{
AttackableUnit result = null;
var mode = ActiveMode;
if ((mode == OrbwalkingMode.Mixed || mode == OrbwalkingMode.LaneClear) && !true)
{
var target = TargetSelector.GetTarget(-1, DamageType.Physical);
if (target != null && InAutoAttackRange(target))
{
return(target);
}
}
/*Killable Minion*/
if (mode == OrbwalkingMode.LaneClear || mode == OrbwalkingMode.Mixed || mode == OrbwalkingMode.LastHit || mode == OrbwalkingMode.Freeze)
{
var MinionList = Cache.GetMinions(Player.Position, 0, MinionTeam.NotAlly).OrderBy(minion => HealthPrediction.GetHealthPrediction(minion, 1000));
foreach (var minion in MinionList)
{
if (minion.Team != GameObjectTeam.Neutral)
{
if (!ShouldAttackMinion(minion))
{
continue;
}
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);
var damage = Player.GetAutoAttackDamage(minion, true);
var killable = predHealth <= damage;
if (mode == OrbwalkingMode.Freeze)
{
if (minion.Health < 50 || predHealth <= 50)
{
return(minion);
}
}
else
{
if (killable && predHealth > 0)
{
return(minion);
}
}
}
else if (minion.Health < 2 && true && minion.CharData.BaseSkinName == "gangplankbarrel" && minion.IsHPBarRendered)
{
return(minion);
}
}
}
//Forced target
if (_forcedTarget.IsValidTarget() && InAutoAttackRange(_forcedTarget))
{
return(_forcedTarget);
}
/* turrets / inhibitors / nexus */
if ((mode == OrbwalkingMode.LaneClear || mode == OrbwalkingMode.Mixed) &&
(!true || !MinionListAA.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 (mode != OrbwalkingMode.LastHit)
{
var target = TargetSelector.GetTarget(-1, DamageType.Physical);
if (target.IsValidTarget() && InAutoAttackRange(target))
{
return(target);
}
}
/*Jungle minions*/
if (mode == OrbwalkingMode.LaneClear || mode == OrbwalkingMode.Mixed)
{
var jminions = Cache.GetMinions(Player.Position, 0, MinionTeam.Neutral);
result = false ? jminions.MinOrDefault(mob => mob.MaxHealth) : jminions.MaxOrDefault(mob => mob.MaxHealth);
if (result != null)
{
return(result);
}
}
/* UnderTurret Farming */
if (mode == OrbwalkingMode.LaneClear || mode == OrbwalkingMode.Mixed || mode == OrbwalkingMode.LastHit ||
mode == OrbwalkingMode.Freeze)
{
var closestTower =
ObjectManager.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;
// return all the minions underturret in auto attack range
var minions = MinionListAA.Where(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())
{
// get the turret aggro minion
var turretMinion =
minions.FirstOrDefault(
minion =>
minion is Obj_AI_Minion &&
HealthPrediction.HasTurretAggro(minion as Obj_AI_Minion));
if (turretMinion != null)
{
var hpLeftBeforeDie = 0;
var hpLeft = 0;
var turretAttackCount = 0;
var turretStarTick = HealthPrediction.TurretAggroStartTick(
turretMinion as Obj_AI_Minion);
// from healthprediction (don't blame me :S)
var turretLandTick = turretStarTick + (int)(closestTower.AttackCastDelay * 1000) +
1000 *
Math.Max(
0,
(int)
(turretMinion.Distance(closestTower) -
closestTower.BoundingRadius)) /
(int)(closestTower.BasicAttack.MissileSpeed + 70);
// calculate the HP before try to balance it
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;
}
// calculate the hits is needed and possibilty to balance
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;
}
// should wait before attacking a minion.
if (ShouldWaitUnderTurret(noneKillableMinion))
{
return(null);
}
if (farmUnderTurretMinion != null)
{
return(farmUnderTurretMinion);
}
// balance other minions
foreach (var minion in
minions.Where(
x =>
x.NetworkId != turretMinion.NetworkId && x is Obj_AI_Minion &&
!HealthPrediction.HasMinionAggro(x as Obj_AI_Minion)))
{
var playerDamage = (int)Player.GetAutoAttackDamage(minion);
var turretDamage = (int)closestTower.GetAutoAttackDamage(minion, true);
var leftHP = (int)minion.Health % turretDamage;
if (leftHP > playerDamage)
{
return(minion);
}
}
// late game
var lastminion =
minions.LastOrDefault(x => x.NetworkId != turretMinion.NetworkId && x is Obj_AI_Minion &&
!HealthPrediction.HasMinionAggro(x as Obj_AI_Minion));
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);
}
// balance other minions
foreach (var minion in
minions.Where(
x => x is Obj_AI_Minion && !HealthPrediction.HasMinionAggro(x as Obj_AI_Minion))
)
{
if (closestTower != null)
{
var playerDamage = (int)Player.GetAutoAttackDamage(minion);
var turretDamage = (int)closestTower.GetAutoAttackDamage(minion, true);
var leftHP = (int)minion.Health % turretDamage;
if (leftHP > playerDamage)
{
return(minion);
}
}
}
//late game
var lastminion =
minions
.LastOrDefault(x => x is Obj_AI_Minion && !HealthPrediction.HasMinionAggro(x as Obj_AI_Minion));
if (lastminion != null && minions.Count() >= 2)
{
if (minions.Count() >= 5 && 1f / Player.AttackDelay >= 1.2)
{
return(lastminion);
}
}
}
return(null);
}
}
}
/*Lane Clear minions*/
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 = (from minion in
MinionListAA.Where(
minion => ShouldAttackMinion(minion, false))
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);
}
/// <summary>
/// Process Karma Lane Clear
/// </summary>
public static void ProcessLaneClear()
{
// Get minions list
var minions = ObjectManager.Get <Obj_AI_Minion>().FindAll(m => m.IsValidTarget(Instances.Range));
if (minions.Count == 0)
{
// If no minions, ignore.
return;
}
// player local value
var player = Instances.Player;
// Using menu & spells a lot, copy to local value.
var menu = Instances.Menu;
var spells = Instances.Spells;
var manaPercent = player.ManaPercentage();
#region Lane Clear - Q
if (spells[SpellSlot.Q].IsReady())
{
#region Lane Clear - R + Q
// Check if R is ready, we allowed R+Q in menu, we have more or equal mana percent than what we placed in menu and if we have enough minions in lane.
if (spells[SpellSlot.R].IsReady() && menu.Item("l33t.karma.farming.lcrq").GetValue <bool>() &&
manaPercent >= menu.Item("l33t.karma.farming.lcminmpq").GetValue <Slider>().Value&&
minions.Count >= menu.Item("l33t.karma.farming.lcminminions").GetValue <Slider>().Value)
{
// Best minion
var minion = minions.FirstOrDefault();
// How many targets get hit by last minion because of AoE
var targeted = 0;
// Search for minion
foreach (var m in minions)
{
// Find all minions that are not our minion and check how many minions would it hit.
var lTargeted = minions.FindAll(lm => lm != m).Count(om => om.Distance(m) < 250f);
// If more minions it would hit than our last minion, continue with prediction.
if (lTargeted > targeted)
{
// Prediction
var pred = spells[SpellSlot.R].GetPrediction(m);
// Check if Q doesn't hit anything in travel
if (pred.CollisionObjects.Count == 0)
{
// Update minion if passes checks
minion = m;
targeted = lTargeted;
}
}
}
// If minion is valid for our range
if (minion != null && (minion.IsValidTarget(spells[SpellSlot.R].Range)))
{
// Prediction
var pred = spells[SpellSlot.R].GetPrediction(minion);
// Casting
spells[SpellSlot.R].Cast();
spells[SpellSlot.Q].Cast(pred.CastPosition);
return;
}
}
#endregion
#region Lane Clear - Solo Q
// Check if we allowed Q in menu and we have enough mana by what we placed inside the menu
if (menu.Item("l33t.karma.farming.lcq").GetValue <bool>() &&
manaPercent >= menu.Item("l33t.karma.farming.lcminmpq").GetValue <Slider>().Value)
{
// Best minion
Obj_AI_Minion minion = null;
// Search for minion
foreach (var m in
from m in minions
let pred = spells[SpellSlot.Q].GetPrediction(m)
where pred.CollisionObjects.Count == 0
select m)
{
if (minion == null)
{
var healthPred = HealthPrediction.GetHealthPrediction(
m, (int)((player.AttackDelay * 1000) * 3));
if (healthPred < Damages.GetDamage(m, SpellSlot.Q, false) ||
healthPred > Damages.GetDamage(m, SpellSlot.Q, false) + player.GetAutoAttackDamage(m))
{
minion = m;
}
}
else if (minion.Health > m.Health)
{
minion = m;
}
}
// If minion is valid for our range
if (minion != null && (minion.IsValidTarget(spells[SpellSlot.Q].Range)) &&
minion.Distance(player.ServerPosition) > player.AttackRange)
{
// Prediction
var pred = spells[SpellSlot.Q].GetPrediction(minion);
// Cast
spells[SpellSlot.Q].Cast(pred.CastPosition);
}
}
#endregion
}
#endregion
}